类（Python day 15,16）

类是变量与操作的集合（属性与函数的集合）

函数才是操作，变量负责接收属性

最简单的类

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)

两天的学习，个人拙见请见谅