Python 基础 四 面向对象杂谈
一、isinstance(obj,cls) 与issubcalss(sub,super)
isinstance(obj,cls)检查是否obj是否是类 cls 的对象
class Foo:
pass f1=Foo()
print(isinstance(f1,Foo)) #True issubclass(sub, super)检查sub类是否是 super 类的派生类
class Foo:
pass class Xoo(Foo):
pass print(issubclass(Xoo,Foo)) #True
二、__getattribute__
在介绍__getattribute__之前是否还记得之前学过一个叫__getattr__的方法，这两者之间是否存在某种关系呢？实际上呢，还是有关系的，是个什么情况呢，就是大哥和小弟的关系，有大哥在的时候大哥上，大哥不在小弟上，或者大哥不想干了，让给了小弟，那你小弟就必须上了是吧。
先看一下__getattr__的例子：
class Foo:
def __init__(self,x):
self.x=x def __getattr__(self, item):
print('执行的是我')
# return self.__dict__[item] f1=Foo(10)
print(f1.x) #d当访问的属性存在的时候是不会触发__getattr__
#f1.xxxxxx #不存在的属性访问，触发__getattr__,若自己没有重写此方法时，就会触发系统默认的此方法，若重写了就会按你自己写的东西执行
好了，再看一下两个都存在的触发方式及结果：
class Foo:
def __init__(self,x):
self.x=x def __getattr__(self, item):
print('执行的是getattr')
# return self.__dict__[item]
def __getattribute__(self, item):
print('执行的是getattribute')
raise AttributeError('抛出异常了')
# raise TabError('xxxxxx')
f1=Foo(10)
#f1.x
f1.xxxxxx #不存在的属性访问，触发__getattr__，若有__getattribute__就先触发此方法（不管属性是否存在），若后面有raise方法抛出异常的时候，就会再次交给__getattr__处理
三、item系列
看到这里是否还记得之前说过一个系列叫做：attr,这两者又是什么关系？我们先看看item系列
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的属性字典是空的————》{}
#f1.name='egon'#---->setattr-------->f1.__dict__['name']='egon'
#print(f1.__dict__) #{'name': 'egon'}
f1['name']='egon'#--->setitem--------->f1.__dict__['name']='egon'
f1['age']=18 #会触发 内部的__setitem__方法
#
print('===>',f1.__dict__) # ===> {}查看属性字典却没有添加进去，只是触发了内部的__setitem__方法，若要添加上，就必须对底层进行操作: self.__dict__[key]=value
# 这样就把属性字典添加上了 ===> {'name': 'egon', 'age': 18}
del f1.name # 删除属性值
print(f1.__dict__) # {'age': 18}
# #
print(f1.age)
del f1['name'] #触发__delitem__，若要真实的删除属性字典中的值就必须对底层进行操作： self.__dict__.pop(key)
#print(f1.__dict__)
总结一下item系列的触发是通过字典类型的方式操作完成的，而attr方式的触发是通过对象加点（.）的方式触发的，这就是两者的最大区别，但是两者最终的效果是一样的。
四 、 _str_ ;_reper_;__format__
_str_ ;_reper_;改变对象的字符串显示方式换句话就是展示print（）函数的 执行结果的：
class Foo:
def __init__(self,name,age):
self.name=name
self.age=age
def __str__(self):
return '名字是%s 年龄是%s' %(self.name,self.age)
# #
f1=Foo('egon',18)
print(f1) #str(f1)--->f1.__str__() 若没有__str__函数，则执行print（）就会执行提供的默认的打印内容
#比如本实例中打印的内容为：<__main__.Foo object at 0x006166D0>,若我们在定义的时候写了__str__函数就会按照我们自己定义好的方式执行打印操作：名字是egon 年龄是18
#
x=str(f1)
print(x)
#
y=f1.__str__()
print(y)
class Foo:
def __init__(self,name,age):
self.name=name
self.age=age
def __str__(self):
return '折是str'
def __repr__(self):
return '名字是%s 年龄是%s' %(self.name,self.age) f1=Foo('egon',19)
#repr(f1)---->f1.__repr__()
print(f1) #str（f1）---》f1.__str__()------>f1.__repr__()
总结：当 str 与repr同时存在的时候执行顺序是：先找str 若没有再去找repr，若都没有就去执行默认的print（）打印结果。
__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('我执行啦')
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'))
print('===========>',format(d1,'asdfasdfsadfasdfasdfasdfasdfasdfasdfasd
五 、__slots__ (省内存)
1.__slots__是什么:是一个类变量,变量值可以是列表,元祖,或者可迭代对象,也可以是一个字符串(意味着所有实例只有一个数据属性)
2.引子:使用点来访问属性本质就是在访问类或者对象的__dict__属性字典(类的字典是共享的,而每个实例的是独立的)
3.为何使用__slots__:字典会占用大量内存,如果你有一个属性很少的类,但是有很多实例,为了节省内存可以使用__slots__取代实例的__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__) #AttributeError: 'Foo' object has no attribute '__dict__' 为何会出现这个结果，这就是不让各个实例对象自己封存自己的数据属性了。
print(Foo.__slots__) #['name', 'age']类中指存放了键的属性
print(f1.__slots__) # ['name', 'age']
f1.name='egon'
f1.age=17
print(f1.name)
print(f1.age)
f1.gender='male' #Foo' object has no attribute 'gender' 在定义数据属性的时候就没有定义性别的属性，so就加不进去
六、__doc__
class Foo:
'我是描述信息'
pass print(Foo.__doc__) # 我是描述信息
需要注意的是：此属性是不具有继承的：
class Foo:
'我是描述信息'
pass class Bar(Foo):
pass
print(Bar.__doc__) #该属性无法继承给子类 打印结果为：None
七、__module__和__class__
_module__ 表示当前操作的对象在那个模块
__class__ 表示当前操作的对象的类是什么
八、__del__
析构方法，当对象在内存中被释放时，自动触发执行。
class Foo:
def __del__(self):
print('执行我啦')
f1=Foo()
del f1
print('------->')
#输出结果
执行我啦
------->
九 、__call__方法
对象后面加括号，触发执行。
注：构造方法的执行是由创建对象触发的，即：对象 = 类名() ；而对于 __call__ 方法的执行是由对象后加括号触发的，即：对象() 或者 类()()
class Foo:
def __init__(self):
print('你就是大傻逼')
def __call__(self, *args, **kwargs):
print('__call__')
obj = Foo() # 执行 __init__
obj() # 执行 __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 # l=list('hello')
# for i in l:
# print(i)
f1=Foo(10)
print(f1.__next__())
print(f1.__next__())
print(f1.__next__())
print(f1.__next__()) for i in f1: # obj=iter(f1)------------>f1.__iter__() #此时的f1的值为最后一次迭代额值
print(i) #obj.__next_()
十一、描述符（__get__,__set__,__delete__）(这个东西很高大上，不过现在的级别还是没啥卵用，就先简单的了解一下下)
1 描述符是什么:描述符本质就是一个新式类,在这个新式类中,至少实现了__get__(),__set__(),__delete__()中的一个,这也被称为描述符协议
__get__():调用一个属性时,触发
__set__():为一个属性赋值时,触发
__delete__():采用del删除属性时,触发
一个小小的例子：
class Foo: #在python3中Foo是新式类,它实现了三种方法,这个类就被称作一个描述符
def __get__(self, instance, owner):
pass
def __set__(self, instance, value):
pass
def __delete__(self, instance):
pass
2 描述符是干什么的:描述符的作用是用来代理另外一个类的属性的(必须把描述符定义成这个类的类属性，不能定义到构造函数中)
#描述符Str
class Str:
def __get__(self, instance, owner):
print('Str调用')
def __set__(self, instance, value):
print('Str设置...')
def __delete__(self, instance):
print('Str删除...') #描述符Int
class Int:
def __get__(self, instance, owner):
print('Int调用')
def __set__(self, instance, value):
print('Int设置...')
def __delete__(self, instance):
print('Int删除...') class People:
name=Str()
age=Int()
def __init__(self,name,age): #name被Str类代理,age被Int类代理,
self.name=name
self.age=age #何地？：定义成另外一个类的类属性 #何时？：且看下列演示 p1=People('alex',18) #描述符Str的使用
p1.name
p1.name='egon'
del p1.name #描述符Int的使用
p1.age
p1.age=18
del p1.age #我们来瞅瞅到底发生了什么
print(p1.__dict__)
print(People.__dict__) #补充
print(type(p1) == People) #type(obj)其实是查看obj是由哪个类实例化来的
print(type(p1).__dict__ == People.__dict__) 描述符应用之何时?何地?
描述符
3 描述符分两种
一 数据描述符:至少实现了__get__()和__set__()
1 class Foo:
2 def __set__(self, instance, value):
3 print('set')
4 def __get__(self, instance, owner):
5 print('get')
二 非数据描述符:没有实现__set__()
1 class Foo:
2 def __get__(self, instance, owner):
3 print('get')
4 注意事项:
一 描述符本身应该定义成新式类,被代理的类也应该是新式类
二 必须把描述符定义成这个类的类属性，不能为定义到构造函数中
三 要严格遵循该优先级,优先级由高到底分别是
1.类属性
2.数据描述符
3.实例属性
4.非数据描述符
5.找不到的属性触发__getattr__()
今天的主要内容就这些，看起来还不错，实践，实践，还是实践！！！