9.面向对象进阶

Posted 2021-01-13 xixi18

一.isinstance(obj,cls)和issubclass(sub,super)
(1)isinstance(obj,cls)检查一个对象obj是否是一个类cls的实例
(2)issubclass(sub,super)检查sub类是否是super类的派生类

class Foo:                  #定义一个类Foo
    pass

class Bar(Foo):             #定义一个类Bar继承了Foo
    pass

f1=Foo()                     #实例化得到f1这个对象
print(isinstance(f1,Foo))    #f1是对象，Foo是类，isinstance判断f1这个对象是否由Foo这个类实例化而来
print(issubclass(Bar,Foo))   #Bar是对象，Foo是类，issubclass判断Bar是否是Foo的子类

返回：
True
True
二.__getattr__和__getattribute__二者同时出现，只会执行__getattribute__，除非__getattribute__在执行中抛出异常AttributeError

class Foo:
    def __init__(self,x):
        self.x=x

    def __getattr__(self, item):               #是在__getattribute__里抛出AttributeError异常的时候才会触发__getattr__的运行
        print(‘执行的是getattr‘)

    def __getattribute__(self, item):          #不管属性找得到找不到首先触发__getattribute__运行,属性存在会从当前实例属性字典里返回想要的值，如果不存在会报异常
         print(‘执行的是getattribute‘)
         raise AttributeError(‘抛出异常了‘)   #AttributeError这句话模拟python自动抛出的异常会把指令发给__getattr__，如果没有__getattr__程序会崩掉
f1=Foo(10)
f1.xxxxxx                                        #调用不存在的属性xxxxxx

返回：
执行的是getattribute
执行的是getattr
三.__setitem__,__getitem__,__delitem__跟字典相关的查询，赋值，删除

class Foo:                                #定义一个类
    def __getitem__(self, item):          #查询
        print(‘getitem‘,item)
        return self.__dict__[item]       #self调用他的属性字典__dict__,[item]找那个属性

    def __setitem__(self, key, value):    #赋值
        print(‘setitem‘)
        self.__dict__[key]=value          #self调用他的属性字典__dict__，[key]就是中括号传过来的值name,value是xixi

    def __delitem__(self, key):           #删除
        print(‘delitem‘)
        self.__dict__.pop(key)            #self调用他的属性字典__dict__,pop(key)指定删除

f1=Foo()                                   #实例化得到f1这个对象
print(f1.__dict__)                         #查看f1实例字典，没定义init方法f1字典里是空：{}
#以字典方式赋值
f1[‘name‘]=‘xixi‘                        #会触发 __setitem__函数运行--->f1.__dict__[‘name‘]=‘xixi‘
print(f1.__dict__)                         #查看f1实例字典,赋值成功：‘name‘: ‘xixi‘}
#以字典方式查询：
print(f1[‘name‘])                         #可以调到name的value返回：getitem name 和 xixi
#以字典方式删除
del f1[‘name‘]
print(f1.__dict__)                         #返回：delitem 和 {}

打印：
{}
setitem
{‘name‘: ‘xixi‘}
getitem name
xixi
delitem
{}
四.__str__和__repr__用来控制输出，输出的解法都是自己return的值，return的值必须是字符串
1.__str__函数或者print函数实际触发实例下面的__str__()方法

class Foo:
    def __init__(self,name,age):   #init方法传name,age
        self.name=name
        self.age=age

    def __str__(self):                                       #__str__调用的是f1.__str__()方法，必须要return个值
        return ‘名字是%s 年龄是%s‘ %(self.name,self.age)  #可以自己控制str的打印的信息

f1=Foo(‘xixi‘,18)                  #实例化传俩个参数
#方式一：
print(f1)                           #实际触发的是系统提供的str(f1)方法的运行，str(f1)执行的是f1.__str__()
#方式二：
x=str(f1)
print(x)
#方式三：
x=f1.__str__()
print(x)

返回：
名字是xixi 年龄是18
名字是xixi 年龄是18
名字是xixi 年龄是18
2.__repr__或者交互解释器实际触发实例下面的__repr__()方法

class Foo:
    def __init__(self,name,age):   #init方法传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(‘xixi‘,18)                  #实例化传俩个参数
print(f1)                           #如果有str先找str（f1）下的f1.__str__()，如果找不到str直接找f1.__repr__()作为一个替代品

返回：
名字是xixi 年龄是18
五.__format__自定制格式化方法

format_dic={                                    #自定制格式化俩种日期输出格式
    ‘ymd‘:‘{0.year}{0.mon}{0.day}‘,        #‘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):          #自定义__format__方法,必须有返回值字符串
        print(‘开始执行‘)
        print(‘--->‘,format_spec)               #format_spec没有传参数就是空
        if not format_spec or format_spec not in format_dic:  #判断format_spec这个值如果是空not format_spec或者不在字典的key里format_spec not in format_dic
            format_spec = ‘ymd‘                 #给一个默认的格式是ymd
        fm=format_dic[format_spec]               #有了format_spec这个值就可以从字典里取到想要的值,fm就是取到了‘{0.year}{0.mon}{0.day}‘后面的格式
        return fm.format(self)                  #拿到格式就可以fm.format相当于.format(d1)
d1=Date(2018,10,‘08‘)

print(format(d1,‘ymd‘))    #format把d1传给self,把ymd传给format_spec
print(format(d1,‘y-m-d‘))  #format把d1传给self,把y-m-d传给format_spec
print(‘不传format_spec打印默认格式‘,format(d1))
print(‘传的format_spec不在format_dic字典里打印默认格式‘,format(d1,‘aaaa‘))

返回：
开始执行
---> ymd
20181008
开始执行
---> y-m-d
2018-10-08
开始执行
--->
不传format_spec打印默认格式 20181008
---> aaaa
传的format_spec不在format_dic字典里打印默认格式 20181008
六.__slots__属性
1.是一个类变量，变量值可以是列表，元祖，或者可迭代对象，也可以是一个字符串(意味着所有实例只有一个数据属性)
2.使用点来访问属性本质就是在访问类或者对象的__dict__属性字典(类的字典是共享的，而每个实例的是独立的)
3.为何使用__slots__：字典会占用大量内存，如果你有一个属性很少的类，但是有很多实例，为了节省内存可以使用__slots__取代实例的__dict__
4.当你使用__slots__后，__slots__就会为实例使用一种更加紧凑的内部表示。实例通过一个很小的固定大小的数组来构建，而不是为每个实例定义一个字典，这个跟元祖列表很类似
5.缺点：不能在给实例添加新的属性，只能使用在__slots__中定义的那些属性名

class Foo:
    __slots__=[‘name‘,‘age‘]  #定义字符串类似属性字典的形式{‘name‘:None,‘age‘:None}，只是定义了key，由这个类产生的实例不再具有__dict__属性字典

f1=Foo()                        #由Foo生成的实例只能有俩个定义的属性[‘name‘,‘age‘]
f1.name=‘xixi‘
print(f1.name)
f1.age=18
print(f1.__slots__)   #显示f1可以定义的属性[‘name‘, ‘age‘]，就是print(Foo.__slots__)类的属性

#f1.gender=‘male‘     #给f1加一个没有的属性gender会报错

f2=Foo()              #实例化f2
print(f2.__slots__)   #f2没有类属性只有__slots__，f2也只能定义俩个属性[‘name‘, ‘age‘]
f2.name=‘shishi‘
f2.age=18
print(f2.name)
print(f2.age)

打印结果：
xixi
[‘name‘, ‘age‘]
[‘name‘, ‘age‘]
shishi
18
七.__doc__属性：在每一个类里面会加一个这个东西，只要调就是从自己的位置调

class Foo:
    pass

class Bar(Foo):
    pass

print(Bar.__doc__)  #该属性无法继承给子类
print(Bar.__doc__)  #该属性无法继承给子类

返回：
None
None
八.__module__和__class__
__module__表示当前操作的对象在那个模块
__class__表示当前操作的对象的类是什么
lib目录下有一个定义aa模块

class C:
    def __init__(self):
        self.name = ‘xixi‘

调用aa模块

from lib.xx import C  #调用lib目录下有一个aa模块,aa模块里有一个C类

c1=C()                 #实例化
print(c1.name)         #可以调用到

print(c1.__module__)   #查看c1来自那个模块
print(c1.__class__)    #查看c1来自那个类产生的

返回：
xixi
lib.xx
<class ‘lib.xx.C‘>
九__del__析构方法
当对象在内存中被释放时，自动触发执行

class Foo:
    def __init__(self,name):
        self.name=name

    def __del__(self):
        print(‘我执行啦‘)

f1=Foo(‘xixi‘)           #由Foo产生个实例传name

#del f1    #删除实例会触发__del__
#del f1.name #删除实例的属性不会触发__del__
print(‘--------------------->‘)
#程序运行完毕会自动回收内存，触发__del__

返回：
--------------------->
我执行啦
十.__call__
对象后面加括号，触发执行。

class Foo:                                 #创建一个类Foo
    def __call__(self, *args, **kwargs):   #定义__call__方法
        print(‘实例执行obj()‘)

f1=Foo()       #Foo()得到一个实例f1,Foo触发的call方法返回的实例

f1()           #f1加小括号调的是的这个对象Foo类下的__call__
#Foo()         #Foo也是一个对象Foo加小括号调的是的abc类下的__call__

返回：
实例执行obj()
十一.__next__和__iter__实现迭代器协议

class Foo:                      #创建一个Foo类
    def __init__(self,n):       #创造构造函数可以传值n
        self.n=n
    # __iter__
    def __iter__(self):         #加上__iter__方法变成把一个对象变成一个可迭代对象
        return self             #返回self
    #__next__
    def __next__(self):         #必须有一个next方法
        if self.n == 9:          #当n=9
            raise StopIteration(‘终止‘)  #StopIteration终止循环
        self.n+=1                #每次n这个值自增
        return self.n           #返回自增1这个值

f1=Foo(5)                        #得到f1这个对象

#for循环
for i in f1:  #for循环f1这个对象实际上先把这个对象变成f1.__iter__()，每次得到的结果是可迭代对象obj
     print(i)  #每次循环就是在调用obj下面的.__next_()方法

返回：
6
7
8
9
迭代器协议实现斐波那契数列

class Fib:                 #创建一个类Fib
    def __init__(self):    #创造构造函数
        self.a=1            #起始值a
        self.b=1            #起始值b

    def __iter__(self):     #定义__iter__方法
        return self        #return自己

    def __next__(self):     #定义 __next__方法
        if self.a > 50:     #当self.a大于50
            raise StopIteration(‘终止了‘)    #退出循环
        self.a,self.b=self.b,self.a + self.b   #self.a等于self.b,self.b等于self.a + self.b俩个相加的结果
        return self.a                         #返回self.a



f1=Fib()                                       #得到f1这个对象

print(next(f1))
print(next(f1))
print(‘==================================‘)
for i in f1:         #for循环从3以后开始
    print(i)

返回：
1
2
==================================
3
5
8
13
21
34
55
十二.描述符(__get__,__set__,__delete__)
1.描述符是什么：描述符本质就是一个新式类，在这个新式类中，至少实现了__get__(),__set__(),__delete__()这三个方法中的一个，这也被称为描述符协议
__get__()调用一个属性时触发
__set__()为一个属性赋值时触发
__delete__()采用del删除属性时触发
2.描述符的作用是用来代理另外一个类的属性的(必须把描述符定义成这个类的属性，不能定义到构造函数)

class Foo:                                     #定义新式类
    def __get__(self, instance, owner):        #定义__get__方法：一个对象调用属性的时候会触发
        print(‘===>get方法‘)

    def __set__(self, instance, value):        #定义__set__方法
        print(‘===>set方法‘)

    def __delete__(self, instance):            #定义__delete__方法
        print(‘===>delete方法‘)
#描述符必须要有另外一个类属性里定义才会触发
class Bar:                                    #定义一个Bar类
    x=Foo()                                   #在Bar类中定义一个类属性，这个类属性的值是Foo实例化的结果，类属性就是描述符的一个对象
b1=Bar()                                      #b1通过Bar得到一个实例
#调用
b1.x                                          #b1点x调用x这个属性就是Foo就可以触发描述符里的__get__方法：===>get方法
#赋值
b1.x=1                                        #b1点x=1调用x=1这个属性就是Foo就可以触发描述符里赋值的__set__方法：‘===>set方法
#删除
del b1.x                                      #del b1点x调用x这个属性就是Foo就可以触发描述符里赋值的__delete__方法：‘===>delete方法

返回：
===>get方法
===>set方法
===>delete方法
set方法的详解

class Foo:
    def __set__(self, instance, value):
        print(‘===>set方法‘,instance,value)   #打印一下
        instance.__dict__[‘x‘]=value           #操作实例下的属性字典进行了一个真正的赋值操作

class Bar:
    x=Foo()           #第三步：触发Foo()的 __set__方法
    def __init__(self,n):
        self.x=n      #第二步:相当于b1.x=10，x这个属性被代理了，赋值触发的是x=Foo()

b1=Bar(10)            #第一步：实例化操作self.x=n(这步实例化的过程相当于找的是 __set__)
print(b1.__dict__)

#修改x的值
b1.x=7777777
print(b1.__dict__)

返回：
===>set方法 <__main__.Bar object at 0x005747B0> 10
{‘x‘: 10}
===>set方法 <__main__.Bar object at 0x005747B0> 7777777
{‘x‘: 7777777}
3.描述符分俩种
(1)数据描述符：至少实现了__get__()和__set__()

class Foo:                                     #定义新式类
    def __get__(self, instance, owner):        #定义__get__方法：
        print(‘===>get方法‘)

    def __set__(self, instance, value):        #定义__set__方法
        print(‘===>set方法‘)

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

class Foo:                                     #定义新式类
    def __get__(self, instance, owner):        #定义__get__方法：
        print(‘===>get方法‘)

4.注意：
(1)描述符本身应该定义成新式类，被代理的类也应该是新式类
(2)必须把描述符定义成这个类的属性，不能为定义到构造函数中
(3)要严格遵循该优先级，优先级由高到底分别是：类属性--->数据描述符--->实例属性--->非数据描述符--->找不到的属性出发__getatter__()