Python面向对象编程Day 27部分知识点

内置函数补充及__getattribute__

isinstance(obj,cls)检查obj是否是类cls的实例，反映族谱关系（不仅父类可以，父类的父类也可以） 

issubclass(subcls,cls)检查subcls是否是cls的子类

__getattribute__属性存不存在都会触发它 ‘大哥’ 里面抛出Attribute Error时交给小弟处理

__getattr__属性不存在触发 ‘小弟

 item系列

item是字典方式触发的

__setitem__

__getitem__

__delitem__

class Foo:
    def __getitem__(self, item):
        print('getitem',item)
        return self.__dict__[item]

    def __setitem__(self, key, value):
        print('setitem')
        self.__dict__[key]=value

    def __delitem__(self, key):
        print('delitem')
        self.__dict__.pop(key)

f1=Foo()
print(f1.__dict__)
# f1.name='egon'  #---->点触发attr系列方法
f1['name']='egon'　　#--->中括号字典形式触发item系列方法
f1['age']=18

print('===>',f1.__dict__)

# del f1.name
# print(f1.__dict__)
25 # print(f1.age)
del f1['name']
print(f1.__dict__)

print(f1['age'])

输出

{}
setitem
setitem
===> {'name': 'egon', 'age': 18}
delitem
{'age': 18}
getitem age
18

__str__和__repr__

class Foo:
    def __init__(self,name,age):
        self.name=name
        self.age=age
    def __repr__(self):
        return 'this is repr'
    # def __str__(self):
    #     return 'this is str'
f1=Foo('cy',23)
print(f1)   #str(f1)-->f1.__str__()

输出

this is repr

st函数或者print函数--->obj.__str__()

repr函数或者交互式解释器--->obj.__repr__()

如果__str__没被定义，那就使用__repr__来代替输出

str和repr返回的必须是字符串，否则抛出异常

自定制format

format_dic={
    'ymd':'{0.year}{0.mon}{0.day}',
    'm-d-y':'{0.mon}-{0.day}-{0.year}',
    '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):
        print('执行__format__方法')
        print('--->',format_spec)
        if not format_spec or format_spec not in format_dic:
            format_spec='ymd'
        fm=format_dic[format_spec]
        return fm.format(self)
d1=Date(2016,12,26)
# format(d1) #d1.__format__()
print('没设置格式，采用默认格式==>',format(d1))
print(format(d1,'ymd'))
print(format(d1,'y:m:d'))
print(format(d1,'m-d-y'))
print('已设定格式但格式不存在，采用默认格式==>',format(d1,'m-d:y'))

输出

执行__format__方法
--->
没设置格式，采用默认格式==> 20161226
执行__format__方法
---> ymd
20161226
执行__format__方法
---> y:m:d
2016:12:26
执行__format__方法
---> m-d-y
12-26-2016
执行__format__方法
---> m-d:y
已设定格式但格式不存在，采用默认格式==> 20161226

__slots__

（慎用）是一个类变量，变量值可以是字符串、列表、元组或者可迭代对象（意味着所有实例只有一个数据属性）

　　为何使用__slots__？优势在于省内存（字典会占用大量内存，如果有一个属性很少的类，但是有很多实例，为了节省内存可以使用__slots__取代实例的__dict__，设置了__slots__之后，__dict__就没了）

　　使用点来访问属性本质就是在访问类或对象的__dict__属性字典（类的字典是共享的，而每个实例是独立的）

　　特点：不允许设置其他数据属性。　　

　　

class Foo:
    __slots__=['name','age']  #{'name':None,'age':None}
    # __slots__='name' #{'name':None,'age':None}

f1=Foo()
# f1.name='egon'
# print(f1.name)

# f1.age=18  #--->setattr----->f1.__dict__['age']=18

# print(f1.__dict__)
print(Foo.__slots__)
print(f1.__slots__)
f1.name='egon'
f1.age=17
print(f1.name)
print(f1.age)
# f1.gender='male'


f2=Foo()
print(f2.__slots__)
f2.name='alex'
f2.age=18
print(f2.name)
print(f2.age)

输出

['name', 'age']
['name', 'age']
egon
17
['name', 'age']
alex
18

__doc__

定义于开头用来说明文档信息的一个字符串，且无法被继承。

写不写都有，不写默认是None。

__module__和__class__

查看实例来自哪个模块　　对象.__module__

查看实例是什么类　　对象.__class__

__del__ 析构方法

此方法一般无需定义，因为python是门高级语言，使用时无需关心内存的分配和释放，此工作交由python解释器执行，所以析构函数的调用是由解释器在进行垃圾回收时自动触发执行的，文件执行完毕之后触发该函数执行。

class Foo:
    def __init__(self,name):
        self.name=name
    def __del__(self):
        print('我执行啦')

f1=Foo('alex')

# del f1    #删除实例会触发__del__
del f1.name #删除实例的属性不会触发__del__
print('--------------------->')

#程序运行完毕会自动回收内存，触发__del__

输出

--------------------->
我执行啦

__call__

对象后面加括号，触发执行。

__next__和__iter__实现迭代器协议

class Foo:
    def __init__(self,n):
        self.n=n
    def __iter__(self):
        return self

    def __next__(self):
        if self.n == 13:
            raise StopIteration('终止了')
        self.n+=1
        return self.n

f1=Foo(10)

for i in f1:  # obj=iter(f1)------------>f1.__iter__()
     print(i)  #obj.__next__()

输出

11
12
13

　　迭代器协议实现斐波那契数列

class Fib:
    def __init__(self):
        self._a=1
        self._b=1

    def __iter__(self):
        return self
    def __next__(self):
        if self._a > 100:
            raise StopIteration('终止了')
        self._a,self._b=self._b,self._a + self._b
        return self._a

f1=Fib()
print(next(f1))
print(next(f1))
print(next(f1))
print(next(f1))
print(next(f1))
print('==================================')
for i in f1:
    print(i)

输出

1
2
3
5
8
==================================
13
21
34
55
89
144

描述符理论

（开发大型框架时用到）

本质是一个新式类，至少实现了__get__()/__set__()/__delete__()中的一个，这也被成为描述符协议。

　　__get__()：调用一个属性时触发

　　__set__()：为一个属性赋值时触发

　　__delete__()：采用del删除属性时触发

描述符有什么用？描述符的作用是用来代理另外一个类的属性的

描述符分为两种：

　　数据描述符：至少实现了__get__()和__set__()

　　非数据描述符：没实现__set__()

注意事项：

　　1.描述符本身应该定义成新式类，被代理的类也应该是新式类；

　　2.必须把描述符定义成类属性，而不能定义到构造函数中；

　　3.要严格遵循该优先级，从高到低：

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

例：

class Foo:
    def __get__(self, instance, owner):
        print('===>get方法')
    def __set__(self, instance, value):
        print('===>set方法',instance,value)
        instance.__dict__['x']=value #对b1.__dict__进行修改
    def __delete__(self, instance):
        print('===>delete方法')

class Bar:
    x=Foo() #描述符定义位置 在何地？   x用描述符来描述
    def __init__(self,n):
        self.x=n #b1.x=10 触发Foo的set方法
#触发在何时？
b1=Bar(10)  #在执行赋值操作
print(b1.__dict__)
b1.x=1  #在执行赋值操作
print(b1.__dict__)

b1.y=2  #没有触发set，因为变量y并没用描述符描述
print(b1.__dict__)

输出

===>set方法 <__main__.Bar object at 0x000001CDBB0197B8> 10
{'x': 10}
===>set方法 <__main__.Bar object at 0x000001CDBB0197B8> 1
{'x': 1}
{'x': 1, 'y': 2}

优先级的体现

class Foo:
    def __get__(self, instance, owner):
        print('===>get方法')
    def __set__(self, instance, value):
        print('===>set方法',instance,value)
        instance.__dict__['x']=value #b1.__dict__
    def __delete__(self, instance):
        print('===>delete方法')

class Bar:
    x=Foo()
Bar.x=1    #覆盖类属性，改变了Bar的__dict__
print(Bar.__dict__)
print(Bar.x)

输出

{'__module__': '__main__', 'x': 1, '__dict__': <attribute '__dict__' of 'Bar' objects>, '__weakref__': <attribute '__weakref__' of 'Bar' objects>, '__doc__': None}
1

反序列化的时候要保证类还在内存中。