类是变量与操作的集合(属性与函数的集合)
函数才是操作,变量负责接收属性
最简单的类
class lei_1():
name=''
age=''
def hanshu_1(self):
print('My name is',self.name)
print('My age are',self.age)
mk=lei_1()
lei_1.name='mike'
lei_1.age=10
mk.hanshu_1()
单纯的类
class lei_2():#class标志着类的定义
def __init__(self,name,age):
self.name=name
self.age=age
def hs_2(self):
print('My name is',self.name)
print('My age are',self.age)
jr=lei_2('jake',20)
jr.hs_2()
用__init__(self,,…)
语法:def init(self,,…)
class lei_3():
def __init__(self,name,age):
self.name=name
self.age=age
def hs_3(self):
print('我的名字是',self.name)
print('年龄是',self.age)
zs=lei_3('张三',30)
zs.hs_3()
修改参数
class Lei_3():
def __init__(self,name,age):
self.name=name
self.age=age
def hs_4(self):
self.a=100
def hs_5(self):
print('俺是',self.name)
print('这',self.age)
print(self.a,type(self.a))
ls=Lei_3('李四',40)
ls.a='1000' #外部定义对象的参数传给对象
ls.hs_5()
这只是修改了李四的参数,其他人的属性只要不覆盖就没有修改
访问类属性和对象属性
class Lei_4():
count=0
def __init__(self,name):
#初始化方法,把现有数据开辟一个新的对象并给予定义
self.name=name
Lei_4.count+=1
xq=Lei_4('小强')
print(xq) #<__main__.Lei_4 object at 0x00000000023BAA90>
print(xq.name)
xh=Lei_4('小红')
print(xh) #<__main__.Lei_4 object at 0x00000000023BAA58>
print(xh.name)
print(Lei_4.count) #2
类执行了两次,所以类属性修改到了2
继承
class Fu_lei():
def __init__(self,name,age):
self.name=name
self.age=age
def xiaohua(self):
print('第一个玩笑')
class Zi_lei(Fu_lei):
def __init__(self,name,age,sex): #初始化方法,把现有数据开辟一个新的对象并给予定义
super().__init__(name,age) #这是调用父类的方法
self.sex=sex
def hs_6(self):
print(self.name,'我是')
print(self.age,'年龄')
print(self.sex,'性别')
def xiaohua(self):
print('第二个方法')
ww=Zi_lei('王五',60,'男')
ww.hs_6()
ww.xiaohua()#第二个方法,是因为子类继承父类时,如果冲突,那么优先使用子类
子类继承父类时,如果冲突,那么优先使用子类
就是当父类和子类的函数名冲突时,通过一个具体的对象调用函数名,是优先调用子类的
类似于局部变量与全局变量的优先级
def init(self,name,age,sex):
super().init(name,age)
这个语法就定义了,这是子类继承父类的格式,没有这个,会报错
类属性修改的问题
class Stu():
count=200
def __init__(self,name):
self.name=name
Stu.count+=1
zs=Stu('张三') #201
Stu.count+=200 #401
ls=Stu('李四') #402
zs.count=1001 #这里修改的是张三的对象属性,不改变类属性,因为此时类没有调用
print(Stu.count) #zs=Stu('张三') ls=Stu('李四'),都使得类变量加了一次 202
print(zs.count) #1001
print(ls.count) #202
类属性会随着类的调用而修改,但是对象属性的修改不调用类,所以不修改类属性
多态
class Dog():
def jiao(self):
print('汪汪汪')
class Pig():
def jiao(self):
print('哼哼哼')
class Cat():
def jiao (self):
print('喵喵喵')
# class Dog
# def __init__(self,a):_init_这种是当要给对象添加属性时才使用
# self.a=a
def jiaoyixia(a): #这里会通过函数将对象属性传入类
a.jiao()
a=Dog() #定义对象
b=Pig()
c=Cat()
jiaoyixia(a) #调用函数
jiaoyixia(b)
jiaoyixia(c)
对象强私有属性不能被外部直接输出
class Guil():
def __init__(self,name,age):
self.name=name #这是对象变量的弱私有属性
self.__age=age
print('我可以输出对象变量的强私有属性',self.__age)
def say(self):
print('我是',self.name)
print('今年',self.__age)
def getage(self): #输出强私有属性的方法之一
return self.__age
def Older(self,old):
self.__age+=old #修改强私有属性的方法之一
zs=Guil('张三',16)
zs.say()
# print(zs.__age)#加下划线的是不允许你自己调用,只能通过调用类的函数内部打印出来
zs.Older(5)
print(zs.getage())
self.age=age是对象的弱私有属性,外部想查看时,可以直接输出
self.__age=age是对象的强私有属性,外部不允许直接调用、查看
修改类中对象的默认属性
class Student():
def __init__(self,name,sex):
self.name=name
self.sex=sex
def hehe(self):
self.salary=10000 #对象默认属性
def say(self):
# self.salary=20
print(self.name)
print(self.salary,type(self.salary))
print(self.sex)
zs=Student("小明",'woman')
zs.hehe()
zs.salary='100' #这个是在外部定义了一个参数
zs.say()
张三修改了自己的默认属性变成100,但是李四被定义是还是会用1000
对象属性添加默认条件
class Student():
count=0 #类属性
# __slots__ = 3#TypeError: 'int' object is not iterable,前面等号后面是什么名字,下面self里面也必须是什么名字
__slots__ = ('name','__age','sex','chengji')#还必须与名字一模一样,是对对象属性个数的限定条件
def __init__(self,name,age,sex):#初始化方法,把现有数据开辟一个新的对象并给予定义
self.name=name #对象属性
self.__age=age
self.sex=sex
def showSelf(self): #成员方法(函数)
print(self.name,self.__age,self.sex)
def nianling(self):
return self.__age #输出对象强属性的方法之一
# print(self.__age),输出对象强属性的方法之一
zs=Student('张三',18,'男')
zs.showSelf()
# print(zs.__age),内部强属性不允许外部访问,只能通过内部输出或者内部访问
print(zs.nianling())
zs.chengji=100
print(zs.chengji)
slots = (‘name’,’__age’,‘sex’,‘chengji’)
def init(self,name,age,sex)
init()中的对象属性个数不得低于__slots__()中的对象属性
继承
class A():
def __init__(self,x):
self.x=x
class B(A):
# def __init__(self,x,y):
# self.y=y
# super().__init__(x)
def show(self):#没有前面的继承父类。这里面的打印x与前面父类的x没有任何关系,没有super,子类继承不了父类,只负责把对象传给父类
print(self.x,'hello')
b=B(1)
print(b.x)
class People(): #父类
def __init__(self,name,sex):
#初始化
self.name=name
self.sex=sex
self.__age=100
#强私有属性,他人无法继承
def wanxiao(self):
print('我是公民张三')
class Student(People):
#我将继承前人的属性,子类
def __init__(self,name,sex,socre):
super().__init__(name,sex)
#调用父类的初始化方法
self.socre=socre
def say(self):
print('我叫',self.name)
print(self.sex)
print(self.socre)
def wanxiao(self):
#如果父类子类的函数名调用冲突,
#那么优秀调用子类的函数,如果用super那么会调用父类的函数
super().wanxiao()
print('我是学生张三')
zs=Student('张三','男',60)
#这个是将括号内的函数先传入People类,然后Student继承,前面的
zs.shengao='一米八'
print(zs.shengao)
zs.say()
装饰器
import time
def zsq(func):
print('开始')
def neibu():
print('1111111')
star=time.time()
func()
end=time.time()
print('11111111##',end-star)
return neibu
@zsq #可以开始找被装饰的东西了
def qiuhe():
i=0
h=0
while i<4:
h+=i
i+=1
print(h)
qiuhe() #下面一定要启动这个函数,否则装饰谁去
@zsq 这个不光调用了装饰器这个函数,并且还将装饰器与被装饰的函数连接了起来
一定要先将被装饰的函数调用起来,否则如何装饰,@zsq只是会调用装饰器,不会调用被装饰者
两层修饰器
def huan(hy):
def neibu(name):
print('!!!!!!!!!!!!!!!!!!!')
hy(name)
print('###################')
return neibu
def huanying(hy):
def neibu(name):
print('^^^^^^^^^^^^^^^^^^')
hy(name)
print('__________________')
# neibu()#TypeError: neibu() missing 1 required positional argument: 'name'
# return neibu()#TypeError: neibu() missing 1 required positional argument: 'name'
return neibu
#没有return时,前面的def如何启用??,要是加了括号,那么参数如何传入呢
@huan
@huanying
def laifang(name):
print('热烈欢迎',name)
laifang('李总')
两层修饰,先@谁,谁就在最外层
修饰器的结构是
添加被修饰函数的形参
将修饰内容传入内部函数
在内部函数中调用被修饰函数
在最后一定要调用被修饰函数,传入修饰内容
生成器
当程序要加载的内容过大时,内存一次装填不下,那么引入yield函数会解决
def xyz():
i=0
while i<5:
yield i
i+=1
a=xyz() #在这里函数不会立即执行,只是相当于点火了,但是还不加油门
#当函数内部有yield时,既有return功能,又有单一次装填内存的功能,一遍计算,一遍生成
print(next(a)) #走一次yield会把函数给暂停一下
print(next(a))
print(next(a)) #3
print(next(a))
执行到a=xyz()时,a现在的状态
当执行到#3时,函数因为有yield的状态
yield做斐波那契
def fbnq(n):
a,b=0,1
i=0
while i<n:
a,b=b,a+b
yield a
i+=1
x=fbnq(5)
y=1
while y<=5:
print(next(x))
y+=1
yield执行时的状态
迭代器 iter()
a=[1,2,3,4,]
b=iter(a) #迭代a
for i in a:
print(i)
两天的学习,个人拙见请见谅