#__init__ 构造方法，双下划线
#__del__ 析构方法，在对象就要被垃圾回收前调用。但发生调用
#的具体时间是不可知的。所以建议尽量避免使用__del__
print('-------example1')
class A:def __init__(self):self.a='a'def printA(self):print(self.a)
class B(A):def __init__(self):#A.__init__(self)   未绑定方法，自由提供self参数#super(B, self).__init__()self.b='b'def printB(self):print(self.b)
b=B()
try:b.printA()      #注释后，没有.a属性
except Exception as e:print(e)
#B继承A后，构造方法覆盖了A的构造方法，所以b.printA()没有self.a的属性。
#旧版python 方法：加上注释的未绑定方法就好
#新式类方法：注释的super 方法。先继承会覆盖后继承
print('-------example2')
class A:def __init__(self):self.chr='a'def printA(self):print(self.chr)
class AA:       #继承没有def __init__(self):A.__init__(self)    #未绑定方法def printAA(self):print(self.chr)
aa=AA()
aa.printAA()    #得到 a （不继承A也可以调用A的构造函数？要用printA就要继承）
print('-------example3')
#super 的多继承
#即使类已经继承多个超类，它也只需要使用一次super函数（但要保证所有的超类的构造方法都使用了super）
#super(TYPE, self).method调用的是mro列表中第一个，也即继承列表第一个类的方法。这个没有举例
class A:def __init__(self):self.a='a'def printA(self):print(self.a)
class B:def __init__(self):self.b='b'def printB(self):print(self.b)
class C(A,B):def __init__(self):super(C,self).__init__()self.c='c'def printC(self):print(self.c)c=C()
c.printA()
try:c.printB()  #报错，没有.b属性
except Exception as e:print(e)
#解决方法，在所有超类里使用super。只在B中使用super还是不行
class A:def __init__(self):super(A, self).__init__()self.a='a'def printA(self):print(self.a)
class B:def __init__(self):super(B, self).__init__()self.b='b'def printB(self):print(self.b)
class C(A,B):def __init__(self):super(C,self).__init__()self.c='c'def printC(self):print(self.c)print('-------example4')
#实现序列，映射
#__len__(self), __getitem__(self,key), __setitem__(self,key,value), __delitem__(self,key)
#定义后相应用len(obj),obj[key],obj[key]=value,del obj[key]
#当为一个序列，key键应该是一个整数(自己写函数检查)。对映射，可以使用任何种类的键。例子P144
#继承标准库的UserList,UserString,UserDict的上面方法
class CountList(list):def __init__(self,*args):super(CountList,self).__init__(*args)self.count=0def __getitem__(self,index):self.count+=1return super(CountList,self).__getitem__(index)c=CountList(range(10))
c.reverse()
print(c)
del c[3:5]
print(c)
print(c.count)
print(c[2]+c[5])
print(c.count)print('-------example5')
#property函数，统一处理类的多个属性，实现get,set,del操作。不需要为每一个属性写一个处理方法了
#绑定del 函数，可以使用 del t.all 语句
class Test:def __init__(self):self.a=0self.b=0def setAll(self, size):self.a, self.b=sizedef getAll(self):return self.a, self.ball=property(getAll,setAll)     #property中函数setAll的参数size#要与property返回的all一样是一个元组
t=Test()
t.all=1,2       #只有property 中绑定了setAll函数才可以赋值
print(t.all)
print(t.a)print('-------example6')
#静态方法staticmethod，类成员方法classmethod
class A:@staticmethoddef smethod():print('smethod')def cmethod(cls):print('classmethod')
A.smethod()
A.cmethod(A)      #这里有问题， 需要有时间查资料print('-------example7')
#__getattribute__(self,name) __getattr__(self,name)__
#__setattr__(self,name,value) __delattr__(self,name)__ P151
#__getattribute__特殊方法，用于查询任意属性。
#__getattr__只能用来查询不在__dict__系统中的属性
#定义__getattribute__后，命令行输入a.后，不会有a的属性、方法的提示了
#定义__getattr__ 不会有这种情况
#当我们查询一个属性时，如果通过__dict__方法无法找到该属性，
#那么Python会调用对象的__getattr__方法，来即时生成该属性
class A:def __init__(self):self.a=0self.b=0def __setattr__(self,name,value):if name=='size':self.a,self.b=valueelse:#这里换成self.name=value时，a=A()为什么会死循环self.__dict__[name]=value def __getattr__(self,name):if name=='size':return self.a,self.belse:raise AttributeError
a=A()
a.size=1,2
a.size
try:a.c
except Exception as e:print(e)
#拓展1
setattr(a,'d',3)
print(a.__dict__)       #多了变量d
delattr(a,'d')
print(a.__dict__)       #少了变量d
print('-------example8')
#拓展2
class C(object):  a = 'abc'  def __getattribute__(self, *args, **kwargs):  print("__getattribute__() is called")  return object.__getattribute__(self, *args, **kwargs)  def __getattr__(self, name):  print("__getattr__() is called ")  return name + " from getattr"  def __get__(self, instance, owner):  print("__get__() is called", instance, owner)  return self  def foo(self, x):  print(x)
class C2(object):  d = C()
c = C()
c2 = C2()
c.a     #__getattribute__() is called
c.zzzzzz        #__getattribute__() is called, __getattr__() is called
c2.d    #__get__() is called <__main__.C2 object at 0x026AAB30> <class '__main__.C2'>#<__main__.C object at 0x026AAAB0>
c2.d.a  #__get__() is called <__main__.C2 object at 0x026AAB30> <class '__main__.C2'>#__getattribute__() is called
#每次通过实例访问属性，都会经过__getattribute__函数。而当属性不存在时，
#仍然需要访问__getattribute__，不过接着要访问__getattr__。这就好像是一个异常处理函数。
#每次访问descriptor（即实现了__get__的类），都会先经过__get__函数。
#object.__get__(self, instance, owner)
#如果class定义了它，则这个class就可以称为descriptor。
#owner是所有者的类，instance是访问descriptor的实例，如果不是通过实例访问，
#而是通过类访问的话，instance则为None。
#（descriptor的实例自己访问自己是不会触发__get__，而会触发__call__，
#只有descriptor作为其它类的属性才有意义。）（所以下文的d是作为C2的一个属性被调用）
print('-------example9')#自己问题例子
class Test:def __init__(self):self.a=0self.b=0def setAll(self, size):self.a, self.b=sizedef getAll(self):return self.a, self.bdef __getattribute__(self,name):if name=='size1':return self.a,self.belif name=='a':#return self.a  #加上这句，调用t.a 就会死循环，这个一直进入自己#return self.__dict__['a'] #报'NoneType' object is not subscriptableprint('a visited')return object.__getattribute__(self,name)#加这句可以elif name=='b':print('b visited')def __getattr__(self,name):if name=='size2':print('size2 visited')return self.a,self.belse:raise AttributeErrordef __setattr__(self, name, value):if name=='a':print('a is changed')elif name=='b':print('b is changed')elif name=='all':print('all changed')all=property(getAll,setAll)
t=Test()
try:t.getAll() #出错，NoneType object is not callable， setAll也是这个错。#__getattribute__加上return后不会有问题
except Exception as e:print(e)try:t.size1 #为什么返回None, None。因为__getattribute__在访问a,b时没有返回a,b的值
except Exception as e:print(e)
print('-------example10')#__dict__属性
#__dict__分层存储属性。每一层的__dict__只存储该层新增的属性。
#子类不需要重复存储父类中的属性。
class bird(object):'__doc__ test'feather = True
class chicken(bird):fly = Falsedef __init__(self, age):self.age = age
summer=chicken(2)
print(bird.__dict__)
print(chicken.__dict__)
print(summer.__dict__)
print(summer.__dict__['age'])
b=bird()
print(b.__dict__)      #这个是空{} feather属性存储在bird.__dict__中print('-------example11')
#迭代器，实现__iter__(返回一个迭代器)和__next__方法
#如果next方法被调用，但迭代器没有值可以返回，就会引发一个StopIteration异常
class Fibs:def __init__(self):self.a=0self.b=1def __next__(self):self.a,self.b=self.b,self.a+self.breturn self.adef __iter__(self):return self
fibs=Fibs()
for f in fibs:if f>1000:print(f)break#从可迭代对象中获得迭代器
it=iter([1,2])
print(it.__next__())   #1
print(it.__next__())   #2
try:print(it.__next__())   #StopIteration
except Exception as e:print(e)#把迭代器转换成序列
class Test():value=0def __next__(self):self.value+=1if self.value>10:raise StopIteration #
                return self.valuedef __iter__(self):return self
t=Test()
print(list(t)) #
                print('-------example12')
#生成器，用函数语法定义的迭代器。任何包含yield语句的函数称为生成器
#他不是像return那样返回值，而是每次产生多个值
#生成器方法：send,throw,close
#在生成器close方法被调用后再通过生成器生成一个值会导致RuntimeError
def repe(value):for i in value:yield i
value=[i*2 for i in range(10)]
print(value) #0~18
r=repe(value)
try:print(r.send('a')) #TypeError: can't send non-None value to a just-started generator
except Exception as e:print(e)
print(r.__next__()) #r.send(None)      返回0，第一个数
print(r.send('a'))     #返回2，第2个数
for i in r:print(i)        #从第3个数4开始到结束
try    :print(r.send('a')) #报错，StopIteration
except Exception as e:print(e)#生成器推导式，返回的不是列表而是生成器
g=(i*2 for i in range(2,10))    #圆括号，不是方括号
print(g.__next__())    #4#send方法
#只有在生成器挂起后才有意义（也就是说在yield第一次被执行后）。即调用一次next__后
#如果真想对刚刚启动的生成器使用send方法，可以将None作为参数进行调用
def repe(value):while True:yield value
r=repe(4)
print(r.send(None))    #返回4
print(r.send('a'))     #返回4def repe(value):while True:new=yield valueprint('new:',new,'value:',value)if new is not None:value=new
r=repe(4)
print(r.send(None))    #返回4
print(r.send('a'))     #返回a    new=a,value=4
print(r.send('aa'))    #返回aa   new=aa,value=a