一堆内置函数

__del__       当删除一个对象时，python解释器也会默认调用一个方法，这个方法为__del__()方法

__call__      一个对象加一个小括号可以执行该类下面的__call__方法

__doc__      无法被继承

__module__表示当前操作的对象在哪个模块

__class__    表示当前操作的对象的类是什么

instance和ssubcclass：

class Foo:
    pass
f1=Foo()
a=isinstance(f1,Foo)#判断f1是否是Foo的派生的实例，返回一个布尔值
print(a)

class Fzz(Foo):
    pass
f2=Fzz()
b=issubclass(Fzz,Foo)#判断Fzz是否是Foo的子类，返回一个布尔值
c=isinstance(f2,Fzz)#判断f2是否是Fzz的派生的实例，返回一个布尔值
d=isinstance(f2,Foo)#判断f2是否是Foo的派生的实例(祖铺关系)，返回一个布尔值

print(b)
print(c)
print(d)

item:

class Foo:
    def __setitem__(self, key, value):
        print('__setitem__')
    def __getitem__(self, item):
        print('__getitem__')
    def __delitem__(self, key):
        print('__delitem__')
f1=Foo()
f1['name']='lee'
f1['name']
del f1['name']
#以字典的形式赋值操作会触发item，.点的方式触发attr

__str__和__repr__:

l1=list('rewrew')
print(l1)

class Foo:
    def __init__(self):
        pass
    def __repr__(self):
        return '解释器会触发__repr__'

l2=Foo()
print(l2) #print触发的是__str__方法,如果找不到会触发__repr__
a=l2

#print触发的是__str__方法,如果找不到会触发__repr__,解释器会触发__repr__:

自制format格式化：

format_dict={
    'ymd':'{0.year}{0.mon}{0.day}',
    'y-m-d':'{0.year}-{0.mon}-{0.day}',
    'y:m:d':'{0.year}:{0.mon}:{0.day}'
}
class Date:
    def __init__(self,year,mon,day):
        self.year=year
        self.mon=mon
        self.day=day
    def __format__(self, format_spec):
        fm=format_dict[format_spec]
        print(self)
        return  fm.format(self)
a=Date('2012','11','20')
b=format(a,'y-m-d')#触发__format__
print(b)

__slots__:

class Foo:
    __slots__ = ['name','id']#__slots__指定实例的属性，实例不会再有字典self.__dict__
a=Foo()
a.name=10
b=Foo()
b.name=122
#a.b=15
print(a.name)
print(b.name)
print(a.__slots__)
print(Foo.__slots__)
#print(a.__dict__)实例不会再有字典self.__dict__
print(Foo.__dict__)

 

迭代器协议：斐波那契数列

class Foo:
    def __init__(self):
        self.a=1
        self.b=1
    def __iter__(self):#迭代器先出发__iter__再触发__next__,for循环遵循迭代器协议，遇到raise StopIteration跳出循环，迭代器只会保存一个值，循环就被替换
        return self
    def __next__(self):
        if self.a>12:
            raise StopIteration('终止了')
        self.a,self.b=self.b,self.a+self.b
        return self.a
c=Foo()
for i in c:
    print(i)

#迭代器先出发__iter__再触发__next__,for循环遵循迭代器协议，遇到raise StopIteration跳出循环，迭代器只会保存一个值，循环就被替换

描述符优先级：

class Foo:
    def __get__(self, instance, owner):
        print('get')
    def __set__(self, instance, value):
        print('set',instance, value)
        instance.__dict__['x']=value                     #因为描述符优先实例属性，B1实例化触发__set__方法，在set方法里面设置b1实例字典中key的值
    def __delete__(self, instance):
        print('delete')

class Bar:
    x=Foo()                                              #Bar的实例对x的调用全部都会去找Foo包含的方法，即实例属性低于数据描述符
    def __init__(self,n):
        self.x=n
        return self.x
b1=Bar(10)
print(b1.x)
del b1.x
#print(b1.__dict__)
#数据描述符：至少实现了__get__(),__set__()
#类属性>数据描述符>实例属性>非数据描述符>找不到的属性触发__getattr__()

#类属性>数据描述符>实例属性>非数据描述符>找不到的属性触发__getattr__()