python,day08笔记
昨日内容回顾
-
函数
1.函数的定义 2.函数的调用 3.函数的语法结构 4.函数的分类 5.函数的返回值 6.函数的参数 7.基于函数的注册登录功能 ''' 函数其实就是功能或者叫工具 函数必须要先定义后调用 函数在定义的时候不执行函数体代码，只检测语法 位置参数 关键字参数 默认参数 可变长参数 *args **kwargs *和**在形式参数和实际参数中的作用 ''' -
模块
写好的功能拿过来就可以直接使用，极大的减少了开发的时间 1.模块可以是python解释器内置的 2.模块可以是自己写的 3.模块可以是第三方写的 如何导入模块 句式1 import ... 句式2 from ... import ... 如何使用第三方模块 1.必须要先下载 pip3 install 模块名 2.默认的下载地址是国外，速度会比较的慢 pip3 install -i 国内源地址 模块名 3.pycharm快捷操作 手动修改仓库地址 4.考虑修改python解释器的配置文件
今日内容概要
-
常用模块
random模块、时间模块、hashlib模块
-
面向对象
什么是对象、什么是类、如何创建类、如何创建对象、基本使用
-
数据库之MySQL(重点)
今日内容详细
常用模块
学完python的模块之后，你将来遇到问题不要想着立刻自己动手写，应该先找一下有没有模块以及实现了我要写的功能或者说大致实现
# 利用random模块实现随机验证码(搜狗笔试题)
'''五位随机验证码 每一位都可以是大写字母或者小写字母或者数字'''
# 必备知识点
'''
英文字母跟十进制数的对应关系
A-Z 65-90
a-z 97-122
'''
# 写一个for循环 循环五次
# 每一次循环 产生三个数据 大写字母 小写字母 数字
# 三个里面随机选一个
import random
code = '' # 将产生的数据拼接到字符串中
for i in range(5):
# 产生随机的大写字母
random_upper = chr(random.randint(65,90))
# 产生随机的小写字母
random_lower = chr(random.randint(97, 122))
# 产生随机的数字
random_int = str(random.randint(0,9))
# 上述三个里面随机选一个
temp = random.choice([random_upper,random_lower,random_int])
# 拼接到code中
code += temp
print(code)
# 封装成函数版本
def get_code(n):
code = '' # 将产生的数据拼接到字符串中
for i in range(n):
# 产生随机的大写字母
random_upper = chr(random.randint(65,90))
# 产生随机的小写字母
random_lower = chr(random.randint(97, 122))
# 产生随机的数字
random_int = str(random.randint(0,9))
# 上述三个里面随机选一个
temp = random.choice([random_upper,random_lower,random_int])
# 拼接到code中
code += temp
return code
res = get_code(10)
print(res)
时间模块
time
datetime
都是内置模块(自己自带的)
时间数据三大类型
1.时间戳
2.结构化时间(不是给人看的)
3.格式化时间(专门给人看的)
import time
# 获取时间戳 距离1970 Unix诞生距今距离的秒数
# print(time.time()) # 1604542031.9748151
# 时间戳可以用来计算某段代码执行的时间
# time.sleep(3) # 让你的程序终止3秒
# def get_code(n):
# time.sleep(3)
# code = '' # 将产生的数据拼接到字符串中
# for i in range(n):
# # 产生随机的大写字母
# random_upper = chr(random.randint(65,90))
# # 产生随机的小写字母
# random_lower = chr(random.randint(97, 122))
# # 产生随机的数字
# random_int = str(random.randint(0,9))
# # 上述三个里面随机选一个
# temp = random.choice([random_upper,random_lower,random_int])
# # 拼接到code中
# code += temp
# return code
#
# start_time = time.time()
# get_code(10)
# end_time = time.time()
# print('运行时间:%s'%(end_time - start_time))
#
# 格式化时间
# res = time.strftime('%Y/%m/%d %H:%M:%S')
# print(res) # 2020/11/05 10:13:07
# res1 = time.strftime('%Y/%m/%d %X')
# print(res1) # 2020/11/05 10:13:07
# 结构化时间
# print(time.struct_time((2020,11,11,1,1,1,1,1,1)))
# import datetime
# print(datetime.datetime.today()) # 2020-11-05 10:16:38.606066
# print(datetime.date.today()) # 2020-11-05
# from datetime import datetime,date
# print(datetime.today())
# print(date.today())
'''
date 年月日
datetime 年月日 时分秒
'''
加密模块
# 加密模块
import hashlib
# pwd = 'jason666'
#
# # 使用md5算法加密数据
# md5 = hashlib.md5()
# # 将明文数据传入md5中
# md5.update(pwd.encode('utf-8')) # 传入的数据必须是bytes(二进制)类型
# # 获取加密之后密文结果
# res = md5.hexdigest()
# print(res) # 098c59b640f78d517a77370d12404c6f
'''
密文越长说明内部使用的加密算法越复杂
密文是无法反解密的
所谓的反解其实内部原理很简单，就是提前假设除很多
密码的组合 然后将这些密码用加密算法加密
{
'明文':'密文',
'明文1':'密文1',
}
'''
面向对象
什么是对象
对象其实就是一系列数据和功能的结合体
# 数据
username = 'jason'
password = 123
# 功能
def index():
print(username,password)
比喻
对象就相当于是化妆包，数据就相当于是化妆的原材料,功能就相当于是眉笔等工具
==对象就是将两者整合到一起的产物==
什么是类
类是对象公共的数据和功能的结合体，用来减少对象内代码的书写
减少代码冗余
我们可以把同一类对象相同的数据与功能存放到类里，而无需每个对象都重复存一份，这样每个对象里只需存自己独有的数据即可，极大地节省了空间。所以，如果说对象是用来存放数据与功能的容器，那么类则是用来存放多个对象相同的数据与功能的容器。
面向对象编程
面向对象编程的基本思路
以开发一个选课系统为例，先考虑学生对象
# 学生的数据有
学校
名字
年龄
性别
# 学生的功能有
选课
# 学生对象1：
数据:
学校=清华大学
姓名=李建刚
性别=男
年龄=28
功能：
选课
# 学生对象2：
数据:
学校=清华大学
姓名=王大力
性别=女
年龄=18
功能：
选课
# 学生对象3：
数据:
学校=清华大学
姓名=牛嗷嗷
性别=男
年龄=38
功能：
选课
# 学生类
相同的特征:
学校=清华大学
相同的功能：
选课
# 代码层面如何定义类(掌握)
class Student:
# 相同的特征:
school = '清华大学'
# 相同的功能：
def choose_course(self):
pass
"""
类的语法结构
1.class 是定义类的关键字
2.Student 是类的名字(类名建议首字母大写)
3.注释 解释这个类的一些信息
4.类体代码 就是多个对象公共的数据和功能存放地
"""
# 代码层面如何产生对象(掌握)
'''类名+括号即可产生对象'''
st1 = Student()
st2 = Student()
st3 = Student()
如何查看对象/类（一切皆对象）里面的名字
# 如何查看对象/类里面的数据
print(Student.__dict__) # 查看类中所有的名字
print(st1.__dict__) # {}
print(st2.__dict__) # {}
print(st3.__dict__) # {}
"""
类
公共的数据
公共的功能
对象1
数据1
功能1
对象2
数据1
功能1
对象3
数据1
功能1
三个对象都仅仅只有公共的数据和功能，自己没有独有的数据和功能
针对双下划线开头双下划綫结尾的变量名我们在读的时候 不要读杠杠xxx杠杠
最标准的读法是 双下xxx
"""
如何让对象有自己独有的数据
'''就是在定义类的时候在类体代码中加一个__init__方法即可'''
class Student:
school = '老男孩大学'
# 固定写法 让类在产生对象的时候可以让对象有自己独有的数据
def __init__(self, username, gender, age):
'''固定写法 init函数里面有几个形式参数下面就按照固定的句式写几行代码'''
self.username = username
self.gender = gender
self.age = age
def choose_course(self):
pass
st1 = Student('jason','male',18)
st2 = Student('egon','female',73)
st3 = Student('alex','male',84)
print(Student.__dict__)
print(st1.__dict__)
print(st2.__dict__)
print(st3.__dict__)
"""
{'__module__': '__main__', 'school': '老男孩大学', '__init__': <function Student.__init__ at 0x0000001D30DA98C8>, 'choose_course': <function Student.choose_course at 0x0000001D30DA9950>, '__dict__': <attribute '__dict__' of 'Student' objects>, '__weakref__': <attribute '__weakref__' of 'Student' objects>, '__doc__': None}
{'username': 'jason', 'gender': 'male', 'age': 18}
{'username': 'egon', 'gender': 'female', 'age': 73}
{'username': 'alex', 'gender': 'male', 'age': 84}
"""
如何访问数据
# 访问每个对象的username
# 最复杂的方式
# print(st1.__dict__['username'])
# 在面向对象中访问数据统一使用句点符(.)
# 自己访问自己的
# print(st1.username)
# print(st1.gender)
# print(st1.age)
# print(Student.school)
# 对象访问类里面的
# print(st1.school)
# print(st2.school)
# print(st3.school)
# print(st1.choose_course)
# print(st2.choose_course)
# print(st3.choose_course)
# 数据的查找顺序
print(st1.username)
print(st2.username)
print(st3.username)
'''
数据的查找顺序
1.先从对象自己里面找
2.找不到才会去产生对象的类里面找
3.类里面如果没有则去类的父类中找(面向对象的继承)
'''
绑定方法与非绑定方法
class Student:
school = '老男孩大学'
# 固定写法 让类在产生对象的时候可以让对象有自己独有的数据
def __init__(self, username, gender, age):
'''固定写法 init函数里面有几个形式参数下面就按照固定的句式写几行代码'''
self.username = username
self.gender = gender
self.age = age
# 绑定给对象的方法
def choose_course(self):
'''self哪个对象来调用 这个self就指代哪个对象'''
print('self:',self)
print('%s is choosing course'%self.username)
# 绑定给类的方法
@classmethod
def get_cls(cls):
print(cls)
# 普通函数
@staticmethod
def get_func(self):
print(self)
st1 = Student('jason','male',18)
st2 = Student('egon','female',73)
st3 = Student('alex','male',84)
# print('st1:',st1)
# print('st2:',st2)
# print('st3:',st3)
# 类中定义的函数 默认都是绑定给对象的
'''
对象来调 会自动将对象当做第一个参数自动传入
'''
# st1.choose_course() # st1.choose_course(st1)
# st2.choose_course() # st2.choose_course(st1)
# st3.choose_course() # st3.choose_course(st1)
# print(Student.choose_course())
'''
类来调 有几个参数就需要自己手动传几个 不会自动传入
'''
# print(st1.username) # 不加赋值符号就是获取
# st1.username = 'jasonNBNB' # 加了赋值符号就是设值
# print(st1.username)
'''
绑定给类的方法
类来调会自动将类当做第一个参数传入
对象来调也不需要传参数 会自动找到该对象的类传入
普通函数
不管谁来调 都需要自己手动传参数
'''
# Student.get_cls() # Student.get_cls(Student)
# print(Student)
# st1.get_cls() # st1.get_cls(Student)
# Student.get_func()
# st1.get_func()
"""
总结:
在类中定义的函数我们一般情况下不叫函数
叫方法
在类中的数据我们也不叫数据
叫属性
并且属性有时候既可以指代数据也可以指代功能
"""
面向对象的三大特性
1.封装
将数据和功能封装到了类/对象里面
2.继承
一个类可以继承多个父类，继承之后就可以拥有该类的一切
3.多态
一种事物的多种形态
封装之隐藏变量
class MyClass:
school = 'oldboy'
__username = 'jason'
obj = MyClass()
print(obj.school)
'''
在定义类的时候 如果变量名前面加了两个下划线
那么该变量会变成隐藏变量 外界无法直接访问
__username 变形成 _MyClass__username
__变量名 变形成 _类名__变量名
'''
print(obj._MyClass__username)
继承
class P1:
pass
class P2:
pass
class S1(P1):
pass
class S2(P1,P2):
pass
'''
在类定义的时候类名后面可以加括号
括号里面可以书写你想要继承的类的名字
并且在python不单单支持单继承
还支持多继承
'''
# 如何查看类的父类
# print(S1.__bases__) # (<class '__main__.P1'>,)
# print(S2.__bases__) # (<class '__main__.P1'>, <class '__main__.P2'>)
#
# print(P1.__bases__) # (<class 'object'>,)
# print(P2.__bases__) # (<class 'object'>,)
'''
在python3中 类如果没有继承任何的父类
那么这个类会默认继承object
'''
"""
经典类
不继承任何的类包括object
只有在python2中才有经典类
新式类
继承了object或者其子类的类
"""
class PPP(object):
username = 'jason666'
class PP1(PPP):
username = 'jason4'
class PP2(PPP):
username = 'jason5'
class PP3(PPP):
username = 'jason6'
class P1(PP1):
username = 'jason1'
class P2(PP2):
username = 'jason2'
class P3(PP3):
username = 'jason3'
class SS1(P1,P2,P3):
# username = 'egon'
# def __init__(self,username):
# self.username = username
pass
# obj1 = SS1('alex')
# print(obj1.username)
# obj2 = SS1()
# print(obj2.username)
# 当多继承的情况发生的时候 我们可以根据mro方法直接确定查找的顺序
print(SS1.mro())
"""
[
<class '__main__.SS1'>,
<class '__main__.P1'>,
<class '__main__.P2'>,
<class '__main__.P3'>,
<class 'object'>]
"""
"""
广度优先(菱形继承)
[
<class '__main__.SS1'>,
<class '__main__.P1'>,
<class '__main__.PP1'>,
<class '__main__.P2'>,
<class '__main__.PP2'>,
<class '__main__.P3'>,
<class '__main__.PP3'>,
<class '__main__.PPP'>,
<class 'object'>]
"""
多态
# 我们可以在不考虑三者类型的情况下直接使用统计三个对象的长度
s.__len__()
l.__len__()
t.__len__()
# Python内置了一个统一的接口
len(s)
len(l)
len(t)
鸭子类型
如果你看上去像鸭子，走路像鸭子，说话像鸭子
那么你就是鸭子!!!
linux系统一切皆文件
#二者看起来都像文件,因而就可以当文件一样去用，然而它们并没有直接的关系
class Txt: #Txt类有两个与文件类型同名的方法，即read和write
def read(self):
pass
def write(self):
pass
class Disk: #Disk类也有两个与文件类型同名的方法：read和write
def read(self):
pass
def write(self):
pass
浙公网安备 33010602011771号