十一.python面向对象（进阶）

1.反射

1.1 什么是反射

　　反射的概念是由Smith在1982年首次提出的，主要是指程序可以访问、检测和修改它本身状态或行为的一种能力（自省）。这一概念的提出很快引发了计算机科学领域关于应用反射性的研究。它首先被程序语言的设计领域所采用,并在Lisp和面向对象方面取得了成绩。

1.2 反射的四个方法

1.hasattr(object,name)

   判断object中有没有一个name字符串对应的方法或属性

2.getattr(object, name, default=None)

　获取属性，获取object中是否有name属性，如果有则获取，如果没有则报错，如果设置default则返回default的值，不会报错。

3.setattr(object, k, v)

　设置属性，设置object的属性，k为设置属性的键，v为设置属性的值。

4.delattr(object, x)

   删除属性，删除object的x属性。

方法示例：

#!/usr/bin/env python
# -*- coding: utf-8 -*-

class House:
    def __init__(self,length,width):
        self.length = length
        self.width = width

    def Area(self):
        return "房子的面积为%s平方米" %(self.length * self.width)


h1 = House(10,20)
#打印h1的属性字典
print(h1.__dict__)
#判断是否有length属性(返回bool值)
print(hasattr(h1,'length')) #切记length属性是字符串类型******
#获取length属性（返回获取到的值，default默认是不存在，获取不到返回"不存在"）
print(getattr(h1,'lengtha','不存在'))
#设置属性
print(setattr(h1,'height','30'))
#设置完查看
print(h1.__dict__)
#删除属性(删除不存在的会报错，AttributeError)
delattr(h1,'length')
#删除完查看
print(h1.__dict__)

结果：

{'length': 10, 'width': 20}
True
不存在
None
{'length': 10, 'width': 20, 'height': '30'}
{'width': 20, 'height': '30'}

1.3 为什么用反射

可以事先定义好接口，接口只有在被完成后才会真正执行，这实现了即插即用，这其实是一种‘后期绑定’，什么意思？即你可以事先把主要的逻辑写好（只定义接口），然后后期再去实现接口的功能。

实现可插拔机制

示例：

A程序员

#!/usr/bin/env python
# -*- coding: utf-8 -*-

#A程序员写文件的方法，有读写操作，但目前只写了读的方法。
class File:
    def read(self):
        print("读操作")

    # def write(self):
    #     print("写操作")

B程序员(B程序员不用关心A程序员是否写write方法，利用反射判断属性并执行，效率高)

#!/usr/bin/env python
# -*- coding: utf-8 -*-

from test import File

f1 = File()

if hasattr(f1,'write'):
    f1 = hasattr(f1,'write')
    f1()
else:
    print("属性不存在继续写逻辑") 

2.类的特殊方法

2.1 对象的属性操作

__setattr__   添加/修改属性会触发它的执行

# __setattr__   添加/修改属性会触发它的执行
class Foo:
    x=1
    def __init__(self,y):
        self.y=y

    def __setattr__(self, key, value):
        print('----> from setattr')
        #以下模拟了给对象添加属性的原理，重写了对象添加属性。
        # self.key=value #模拟添加属性，这样做会导致递归。
        self.__dict__[key]=value #这样做不会递归

f1=Foo(10) #实例化等于添加self.y属性
print(f1.__dict__) #查看其实并未添加，因为当前的__setattr__覆盖了系统的，以上加了self.__dict__[key]=value，才进行了属性的添加
f1.x = 20  #为对象手动添加属性
print(f1.__dict__)

结果：

----> from setattr
{'y': 10}
----> from setattr
{'x': 20, 'y': 10}

__delattr__   删除属性的时候会触发

# __delattr__   删除属性的时候会触发

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

    def __delattr__(self, item):
        print('----> from delattr')
        print('----> %s' %item) #item为删除的值
        # del self.item #这样做会无限递归
        self.__dict__.pop(item) #操作属性字典删除

f1 = Foo(10)
print(f1.__dict__)
del f1.y #删除属性y
print(f1.__dict__)

结果：

{'y': 10}
----> from delattr
----> y
{}

__getattr__   只有在使用点调用属性且属性不存在的时候才会触发

# __getattr__   只有在使用点调用属性且属性不存在的时候才会触发

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

    def __getattr__(self, item):
        print('----> from getattr:你找的属性不存在')

f1 = Foo(10)

print(f1.y) #属性存在的时候不会触发
print(f1.z) #属性不存在的时候会触发

结果：

10
----> from getattr:你找的属性不存在
None

__getattribute__ 不管属性是否存在都会调用

# __getattribute__ 在使用点调用属性就会执行

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

    def __getattribute__(self, item):
        print('from------>__getattribute__')

f1=Foo(10)
#__getattribute__与__getattr__不同的是，不管属性是否存在都会调用。
f1.x
f1.yyy

结果：

from------>__getattribute__
from------>__getattribute__

__getattribute__ 与__getattr__ 同时出现

# __getattr__与__getattribute__共存

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

    def __getattr__(self, item):
        print('from------>__getattr__')

    def __getattribute__(self, item):
        print('from ------>__getattribute__')
        #raise AttributeError('没有这个属性')

f1=Foo(10)
f1.x  #共存调用有的x属性执行__getattribute__
f1.yyy #共存调用没有的yyy属性也执行__getattribute__

#总结：当__getattribute__与__getattr__同时存在,只会执行__getattrbute__,除非__getattribute__在执行过程中抛出异常AttributeError

__getitem__:obj['属性'] 时触发

# __getitem__:obj['属性'] 时触发

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

    def __getitem__(self, item):
        print('from ----->__getitem__')
        print(self.__dict__[item])

f1 = Foo(10)

print(f1['y'])

结果：

from ----->__getitem__
10
None

__setitem__:obj['属性']=属性的值 时触发

# __setitem__:obj['属性']=属性的值 时触发
class Foo:
    x=1
    def __init__(self,y):
        self.y=y

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

f1=Foo(10)
print(f1.__dict__)
f1['z'] = 30
print(f1.__dict__)

结果：

{'y': 10}
from ------>__setitem__
{'z': 30, 'y': 10}

__delitem__:del obj['属性'] 时触发

# __delitem__:del obj['属性'] 时触发
class Foo:
    x=1
    def __init__(self,y):
        self.y=y

    def __delitem__(self, key):
        print('from ------>__delitem__')
        self.__dict__.pop(key)

f1=Foo(10)
print(f1.__dict__)
del f1['y']
print(f1.__dict__)

结果：

1 {'y': 10}
2 from ------>__delitem__
3 {}

2.2 检查对象和子类

isinstance语法：isinstance(obj,cls)

功能：检查对象obj是否是类cls的实例

class Foo(object):
    pass

obj = Foo()
print(isinstance(obj, Foo)) #判断obj是否是Foo的实例

issubclass语法：issubclass(sub,super)

功能：检查sub类是否是super类的派生类

class Foo(object):
    pass

class Bar(Foo):
    pass

print(issubclass(Bar,Foo)) #判断Bar是否是Foo的子类

2.3 __str__与__repr__

__str__与__repr__是控制输出的，__str__是控制print输出的，__repr__是控制控制台输出的

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

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

注意：必须以return结尾，并且return的值只能是字符串

class Foo:
    def __init__(self,name,age):
        self.name = name
        self.age = age
    #自定义str
    def __str__(self):
        return "name is %s,age is %s" %(self.name,self.age)

f1 = Foo('zhangsan',23)

print(f1) #str(f1)--->f1.__str__() #print调用顺序
# 这里不定义__str__会显示<__main__.Foo object at 0x0000025B3895B668>
# 定制str会显示
# name is zhangsan,age is 23

class Foo:
    def __init__(self,name,age):
        self.name = name
        self.age = age
    #自定义repr
    def __repr__(self):
        return "name is %s,age is %s" %(self.name,self.age)

f1 = Foo('zhangsan',23)

print(f1) #repr(f1)--->f1.__repr__() #调用顺序

###############控制台示例#####################
>>>
>>> class Foo:
...     def __init__(self,name,age):
...         self.name = name
...         self.age = age
...     def __repr__(self):
...         return "name is %s,age is %s" %(self.name,self.age)
...
>>> f1 = Foo('zhangsan',23)
>>> f1
name is zhangsan,age is 23
>>>

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

    def __str__(self):
        return ("from---->str")

    def __repr__(self):
        return "name is %s,age is %s" %(self.name,self.age)

f1 = Foo('zhangsan',23)

print(f1) # 共存调用顺序，str(f1)--->f1.__str__()--->f1.__repr__()

2.4自定制format

format_dic = {
    'ymd':'{0.year} {0.month} {0.day}',
    'y-m-d':'{0.year}-{0.month}-{0.day}',
    'm:d:y':'{0.month}:{0.day}:{0.year}',
    'd/m/y':'{0.day}/{0.month}/{0.year}',
}

class Date:
    def __init__(self,year,month,day):
        self.year = year
        self.month = month
        self.day = day

    def __format__(self, 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)
        # return format_dic[format_spec].format(self) #整合


d1 = Date('2017','07','07')
x = format(d1,'ymd')
y = format(d1,'y-m-d')
z = format(d1,'d/m/y')
print(x)
print(y)
print(z)

##############结果##############
2017 07 07
2017-07-07
07/07/2017

2.5__slots__

什么是__slots__?

定义：__slots__是一个类变量,变量值可以是列表,元祖,或者可迭代对象,也可以是一个字符串(意味着所有实例只有一个数据属性)

为什么使用__slots__?

• 前面学过不管是访问类的属性还是实例的属性其实都是对属性字典__dict__来做操作，但是类的属性字典是共享的，实例的属性字典是独立的；如果一个类属性很少，会占用一个字典，而这个类生成的多个实例会生成多个字典，字典一多，就会占用大量的内存，为了节省内存，可以使用__slots__来代替__dict__,这样所有实例的属性字典就会是一个__slots__,减少了内存的占用。

使用__slots__的优缺点。

• 优点：节省内存空间。
• 缺点：不能给实例添加新的属性，如果添加，只能在定义__slots__里面定义。

__slots__应该用在哪？

• __slots__的很多特性都依赖于普通的基于字典的实现。另外,定义了__slots__后的类不再支持一些普通类特性了,比如多继承。大多数情况下,你应该只在那些经常被使用到的用作数据结构的类上定义__slots__比如在程序中需要创建某个类的几百万个实例对象 。

__slots__使用误区

• 关于__slots__的一个常见误区是它可以作为一个封装工具来防止用户给实例增加新的属性。尽管使用__slots__可以达到这样的目的,但是这个并不是它的初衷。更多的是用来作为一个内存优化工具。

class Foo:
    __slots__ = 'name' #定义单个属性，没有定义后面就不能添加。
    # __slots__ = ['name','age'] #定义多个属性，没有定义后面就不能添加。

f1 = Foo()
f1.name = 'zhangsan'
#print(f1.__dict__) #当使用__slots__的时候，就没有属性字典了，这里会报错，(AttributeError: 'Foo' object has no attribute '__dict__')
print(f1.__slots__) # name
#f1.age = 23  #如果__slots__没有这个属性，这里会报错（AttributeError: 'Foo' object has no attribute 'age'）


f2 = Foo()
f2.name = 'lisi'
print(f2.__dict__) #当使用__slots__的时候，就没有属性字典了，这里会报错，(AttributeError: 'Foo' object has no attribute '__dict__')
print(f2.__slots__) #name

#总结：f1与f2都没有属性字典__dict__了,统一归__slots__管,节省内存

2.6__doc__

__doc__就是文档描述符，用来描述类或方法的作用，可以任意定义，自己能看懂就好。

特点：无法继承

class Foo:
    '我是描述信息'
    pass

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

2.7__module__和__class__

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

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

创建test/test.py

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

导入test.py模块

from test.test import Foo

obj = Foo()
print obj.__module__     #输出 test.test，即：输出模块
print obj.__class__        #输出 test.test.Foo，即：输出类

2.8__del__ 析构方法

• 定义：析构方法，当对象在内存中被释放时，自动触发执行。

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

    def __del__(self):
        print("from ------>__del__")

f1 = Foo('zhangsan')
print('--------------程序执行完------------>')


#结果
--------------程序执行完------------>
from ------>__del__

#结果可以看出程序执行完毕，触发析构函数。

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

    def __del__(self):
        print("from ------>__del__")

f1 = Foo('zhangsan')
del f1
print('--------------程序执行完------------>')

#结果
from ------>__del__
--------------程序执行完------------>

#以上可以看出，删除f1实例，触发析构函数，然后程序执行完毕。

注：此方法一般无须定义，因为Python是一门高级语言，程序员在使用时无需关心内存的分配和释放，因为此工作都是交给Python解释器来执行，所以，析构函数的调用是由解释器在进行垃圾回收时自动触发执行的。

2.9 __call__

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

#!/usr/bin/env python
# -*- coding: utf-8 -*-

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

    def __call__(self, *args, **kwargs):
        print('from------>__call__')

f1 = Foo('zhangsan')


f1() #执行Foo下的__call__方法
Foo('zhangsan')() #等同于f1(),执行Foo下的__call__方法
Foo('zhangsan')   #例如Foo()触发执行的是abc下的__call__方法。

结果#
from------>__call__
from------>__call__

注：构造方法的执行是由创建对象触发的，即：对象 = 类名() ；而对于 __call__ 方法的执行是由对象后加括号触发的，即：对象() 或者 类()()

2.10 __next__和__iter__实现迭代器协议

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

    def __iter__(self):
        return self

    def __next__(self):
        n=self.x
        self.x+=1
        return self.x

f=Foo(3)
for i in f:
    print(i)

#1.首先要有__iter__,生成迭代器对象的时候会调用
#2.要有__next__方法，因为可以被next()或__next__()函数调用并不断返回下一个值（直到没有数据时抛出StopIteration错误）的对象称为迭代器
#3.强大的for循环遇到StopIteration会自动停止，并且不会报错。

class Foo:
    def __init__(self):
        self.x = 1
        self.y = 1

    def __iter__(self):
        return self

    def __next__(self):
        self.x,self.y  = self.y,self.x + self.y
        if self.x > 20:
            raise StopIteration('异常了。。。')
        return self.x

f1 = Foo()

# print(f1.__next__())
# print(f1.__next__())
# print(f1.__next__())
# print(f1.__next__())
# print(f1.__next__())
# print(f1.__next__())
# print(f1.__next__())
# print(f1.__next__())

for i in f1:
    print(i)

3.描述符

1.描述符是什么？

• 描述符本质就是一个新式类,在这个新式类中,至少实现了__get__(),__set__(),__delete__()中的一个,这也被称为描述符协议；python描述符是一个“绑定行为”的对象属性，在描述符协议中，它可以通过方法重写属性的访问。如果__get__(),__set__(),__delete__()被定义在一个对象中，这个对象就是一个描述符。
• 定义描述符

class Foo: #在python3中Foo是新式类,它实现了三种方法,这个类就被称作一个描述符(实现任意一个都被称作描述符)
    def __get__(self, instance, owner):
        pass
    def __set__(self, instance, value):
        pass
    def __delete__(self, instance):
        pass

2.描述符是做什么的？

• 描述符的作用是用来代理另外一个类的属性的(注意：必须把描述符定义成这个类的类属性，不能定义到构造函数中)

　　为什么说是代理属性呢？

class Foo:
    def __get__(self, instance, owner):
        print('触发get')
    def __set__(self, instance, value):
        print('触发set')
    def __delete__(self, instance):
        print('触发delete')

#包含这三个方法的新式类称为描述符,由这个类产生的实例进行属性的调用/赋值/删除,并不会触发这三个方法
f1=Foo()
f1.name='zhangsan'
f1.name
del f1.name

#描述符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()  #Str描述符用在这里
    age=Int()   #Int描述符用在这里
    def __init__(self,name,age): #name被Str类代理,age被Int类代理
        self.name=name
        self.age=age

#实例化的时候会调用，zhangsan--->name(因为name被Str代理)--->Str--->触发Str下的__set__方法(因为实例化本身就是把zhangsan赋值给name，是设置操作)
#age和name相同只不过是被Int代理。
p1=People('zhangsan',23)
#被代理的属性(name和age，在示例本身属性字典里查不到)
print(p1.__dict__)
#实例name属性被Str代理,调用/赋值/删除会触发Str描述符的方法
print('------>描述符Str的使用')
p1.name
p1.name='zhangsan'
#因为name被代理，所以代理里面没有操作，属性字典为空
print(p1.__dict__)
del p1.name
#实例age属性被Int代理,调用/赋值/删除会触发Int描述符的方法
print('------>描述符Int的使用')
p1.age
p1.age=23
#因为name被代理，所以代理里面没有操作，属性字典为空
print(p1.__dict__)
del p1.age
print(type(p1))

Str设置...
Int设置...
{}
------>描述符Str的使用
Str调用...
Str设置...
{}
Str删除...
------>描述符Int的使用
Int调用...
Int设置...
{}
Int删除...

总结：描述符就是来代理其他的类的属性操作的。

3.描述符的种类

描述符分为两种

1.数据描述符:至少实现了__get__()和__set__()

class Foo:
    def __set__(self, instance, value):
        print('set')
    def __get__(self, instance, owner):
        print('get')

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

class Foo:
    def __get__(self, instance, owner):
        print('get')

4.使用描述符要注意的事项*****

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

2.必须把描述符定义成这个类的类属性，不能为定义到构造函数中(__init__())***

3. 要严格遵循该优先级,优先级由高到底分别是

　　1) 类属性
　　2) 数据描述符
　　3) 实例属性
　　4) 非数据描述符
　　5) 找不到的属性触发__getattr__()

#描述符Str，因为至少包含了__get__和__set__，所以具体可以称为数据描述符。
class Str:
    def __get__(self, instance, owner):
        print('Str调用...')
    def __set__(self, instance, value):
        print('Str设置...')
    def __delete__(self, instance):
        print('Str删除...')

class People:
    name=Str()
    def __init__(self,name,age): #name被Str类代理,age被Int类代理
        self.name=name
        self.age=age

#基于上面的演示,我们已经知道,在一个类中定义描述符它就是一个类属性,存在于类的属性字典中,而不是实例的属性字典
#那既然描述符被定义成了一个类属性,直接通过类名也一定可以调用吧,这里做下实验。
People.name #测试通过，可以调用。但是本质就是在调用描述符Str,触发了__get__()，但并不能证明类(属性>数据描述符)
#再来看赋值和删除
People.name = 'zhangsan' #没有触发__set__方法
del People.name          #没有触发__delete__方法

'''
结论:从类对属性的赋值和删除的时候，并没有触发__set__和__delete__方法，说明类对属性的操作要高于描述符。
'''

类属性>数据描述符

#描述符Str，因为至少包含了__get__和__set__，所以具体可以称为数据描述符。
class Str:
    def __get__(self, instance, owner):
        print('Str调用...')
    def __set__(self, instance, value):
        print('Str设置...')
    def __delete__(self, instance):
        print('Str删除...')

class People:
    name=Str()
    def __init__(self,name,age): #name被Str类代理
        self.name=name
        self.age=age

#这里定义一个实例
p1=People('zhangsan',23)

#这里用实例对属性的调用/赋值/删除来判断实例属性和数据描述符的优先级
print("开始测试......")
p1.name
p1.name='lisi'
del p1.name
'''
结果:
Str设置...
开始测试......
Str调用...
Str设置...
Str删除...

结论:数据描述符>实例属性
'''

#描述符Str，因没有__set__方法，所以具体可以称为非数据描述符。
class Str:
    def __get__(self, instance, owner):
        print('Str调用...')

class People:
    name=Str()
    def __init__(self,name,age): #name被Str类代理
        self.name=name
        self.age=age

#这里定义一个实例
p1=People('zhangsan',23)

#这里用调用示例属性的方式来判断实例属性和非数据描述符的优先级
p1.name #并没有触发Str的__get__方法。
print(p1.name) #可以找到，说明调用的是实例的属性字典。

'''
结果:zhangsan
结论:实例属性>非数据描述符
'''

5.描述符的使用

python是弱类型语言，即参数的赋值没有类型限制，下面我们通过描述符机制来实现类型限制功能

class Typed:
    def __init__(self,name,expected_type):
        self.name=name
        self.expected_type=expected_type

    def __get__(self, instance, owner):
        if instance is None:
            return self
        return instance.__dict__[self.name]

    def __set__(self, instance, value):
        if not isinstance(value,self.expected_type):
            raise TypeError('当前类型是:%s 需要改为:%s' %(type(value),str(self.expected_type)))
        instance.__dict__[self.name]=value

    def __delete__(self, instance):
        instance.__dict__.pop(self.name)

class People:
    name=Typed('name',str)
    age=Typed('age',int)
    salary=Typed('name',float)
    def __init__(self,name,age,salary):
        self.name=name
        self.age=age
        self.salary=salary

#p1=People(123,18,3333.3)
#p1=People('zhangsan','18',3333.3)
#p1=People('zhangsan',18,3333)

以上Typed属于调用重复的代码，这里可以用类的装饰器实现

类的装饰器分类:

def decorate(cls):
    print('类的装饰器开始运行啦------>')
    return cls

@decorate #无参:People=decorate(People)
class People:
    def __init__(self,name,age,salary):
        self.name=name
        self.age=age
        self.salary=salary

p1=People('zhangsan',23,3333.3)

def typeassert(**kwargs):
    def decorate(cls):
        print('类的装饰器开始运行啦------>',kwargs)
        return cls
    return decorate
@typeassert(name=str,age=int,salary=float) #有参:1.运行typeassert(...)返回结果是decorate,此时参数都传给kwargs 2.People=decorate(People)
class People:
    def __init__(self,name,age,salary):
        self.name=name
        self.age=age
        self.salary=salary

p1=People('zhangsan',23,3333.3)

class Typed:
    def __init__(self,name,expected_type):
        self.name=name
        self.expected_type=expected_type
    def __get__(self, instance, owner):
        print('get--->',instance,owner)
        if instance is None:
            return self
        return instance.__dict__[self.name]

    def __set__(self, instance, value):
        print('set--->',instance,value)
        if not isinstance(value,self.expected_type):
            raise TypeError('Expected %s' %str(self.expected_type))
        instance.__dict__[self.name]=value
    def __delete__(self, instance):
        print('delete--->',instance)
        instance.__dict__.pop(self.name)

def typeassert(**kwargs):
    def decorate(cls):
        print('类的装饰器开始运行啦------>',kwargs)
        for name,expected_type in kwargs.items():
            setattr(cls,name,Typed(name,expected_type))
        return cls
    return decorate
@typeassert(name=str,age=int,salary=float) #有参:1.运行typeassert(...)返回结果是decorate,此时参数都传给kwargs 2.People=decorate(People)
class People:
    def __init__(self,name,age,salary):
        self.name=name
        self.age=age
        self.salary=salary

print(People.__dict__)
p1=People('zhangsan',23,3333.3)

6.描述符实战

6.1 自制@property

class Lazyproperty:
    def __init__(self,func):
        self.func=func
    def __get__(self, instance, owner):
        print('这是我们自己定制的静态属性,r1.area实际是要执行r1.area()')
        if instance is None:
            return self
        return self.func(instance) #此时你应该明白,到底是谁在为你做自动传递self的事情

class Room:
    def __init__(self,name,width,length):
        self.name=name
        self.width=width
        self.length=length

    @Lazyproperty #area=Lazyproperty(area) 相当于定义了一个类属性,即描述符
    def area(self):
        return self.width * self.length

r1=Room('alex',1,1)
print(r1.area)

class Lazyproperty:
    def __init__(self,func):
        self.func=func
    def __get__(self, instance, owner):
        print('这是我们自己定制的静态属性,r1.area实际是要执行r1.area()')
        if instance is None:
            return self
        else:
            print('--->')
            value=self.func(instance)
            setattr(instance,self.func.__name__,value) #计算一次就缓存到实例的属性字典中
            return value

class Room:
    def __init__(self,name,width,length):
        self.name=name
        self.width=width
        self.length=length

    @Lazyproperty #area=Lazyproperty(area) 相当于'定义了一个类属性,即描述符'
    def area(self):
        return self.width * self.length

r1=Room('alex',1,1)
print(r1.area) #先从自己的属性字典找,没有再去类的中找,然后出发了area的__get__方法
print(r1.area) #先从自己的属性字典找,找到了,是上次计算的结果,这样就不用每执行一次都去计算

6.2 自制@classmethod

class ClassMethod:
    def __init__(self,func):
        self.func=func

    def __get__(self, instance, owner): #类来调用,instance为None,owner为类本身,实例来调用,instance为实例,owner为类本身,
        def feedback():
            print('在这里添加功能...')
            return self.func(owner)
        return feedback

class People:
    name='lisi'
    @ClassMethod # say_hi=ClassMethod(say_hi)
    def say_hi(cls):
        print('你好 %s' %cls.name)

People.say_hi()

p1=People()
p1.say_hi()
#疑问,类方法如果有参数呢

class ClassMethod:
    def __init__(self,func):
        self.func=func

    def __get__(self, instance, owner): #类来调用,instance为None,owner为类本身,实例来调用,instance为实例,owner为类本身,
        def feedback(*args,**kwargs):
            print('在这里添加功能...')
            return self.func(owner,*args,**kwargs)
        return feedback

class People:
    name='lisi'
    @ClassMethod # say_hi=ClassMethod(say_hi)
    def say_hi(cls,msg):
        print('你好 %s %s' %(cls.name,msg))

People.say_hi('见到你很高兴')

p1=People()
p1.say_hi('见到你很高兴')

6.3 自制@staticmethod

class StaticMethod:
    def __init__(self,func):
        self.func=func

    def __get__(self, instance, owner): #类来调用,instance为None,owner为类本身,实例来调用,instance为实例,owner为类本身,
        def feedback(*args,**kwargs):
            print('在这里可以加功能啊...')
            return self.func(*args,**kwargs)
        return feedback

class People:
    @StaticMethod# say_hi=StaticMethod(say_hi)
    def say_hi(x,y,z):
        print('------>',x,y,z)

People.say_hi(1,2,3)

p1=People()
p1.say_hi(4,5,6)

7.描述符总结

描述符是可以实现大部分python类特性中的底层魔法,包括@classmethod,@staticmethd,@property甚至是__slots__属性

描述父是很多高级库和框架的重要工具之一,描述符通常是使用到装饰器或者元类的大型框架中的一个组件.

4.上下文管理器

4.1 什么是上下文管理器?

在使用Python编程中，可以会经常碰到这种情况：有一个特殊的语句块，在执行这个语句块之前需要先执行一些准备动作；当语句块执行完成后，需要继续执行一些收尾动作。这就是上下文管理器。

4.2 为什么要使用？用在哪？

示例1：

当需要操作文件或数据库的时候，首先需要获取文件句柄或者数据库连接对象，当执行完相应的操作后，需要执行释放文件句柄或者关闭数据库连接的动作。

示例2：

当多线程程序需要访问临界资源的时候，线程首先需要获取互斥锁，当执行完成并准备退出临界区的时候，需要释放互斥锁。

对于这些情况，Python中提供了上下文管理器（Context Manager）的概念，可以通过上下文管理器来定义/控制代码块执行前的准备动作，以及执行后的收尾动作。

4.3 上下文管理协议又是什么？

当我们需要创建一个上下文管理器类型的时候

必须要实现：

__enter__方法(上文)

__exit__方法(下文)

这对方法就称为上下文管理协议（Context Manager Protocol），定义了一种运行时上下文环境。

4.4 如何使用上下文管理？

这里利用文件操作with open 来理解上下文管理的用法。

我们在操作文件对象的时候可以这可写，如下

with open('a.txt') as f:
　　'代码块'

这里的with open('a.txt')代表的意思是打开一个文件句柄，as f的意思是赋值给f,这个过程就是上下文管理协议。

这里来模拟with open的实现，来理解如何使用。

'''
with obj as f 做的是f = obj.__enter__(),with obj 是触发obj.__enter__拿到返回值，as f是赋值给f
执行代码块：
1.没有异常的情况，整个代码块执行完成后触发__exit__方法，它的三个参数都为None
2.有异常的情况，会从异常出现的位置直接触发__exit__的运行、
  a:如果__exit__的返回值为True，代表吞掉异常
  b:如果__exit__的返回值不为True，代表吐出异常
  c:__exit__的运行完毕就代表了整个with语句的执行完毕。

'''
#没有异常
class Open1:

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

    def __enter__(self):
        print("执行enter")
        return self

    def __exit__(self, exc_type, exc_val, exc_tb):
        print("执行exit")
        print("参数开始------------------>")
        print(exc_type)
        print(exc_val)
        print(exc_tb)
        print("参数结束------------------>")

with Open1('a.txt') as f:
    pass

print('='*50)

#有异常
class Open:

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

    def __enter__(self):
        print("执行enter")
        return self

    def __exit__(self, exc_type, exc_val, exc_tb):
        print("执行exit")
        print("参数开始------------------>")
        print(exc_type)
        print(exc_val)
        print(exc_tb)
        print("参数结束------------------>")
        #return True  #这里代表吞掉异常。开启就会吞掉异常

with Open('a.txt') as f:
    raise AttributeError("出错了。。。")
print('执行结束。。。。。。。。。。。。。') #如果吞掉异常，这里会执行，如果吐出异常这里不会执行

模拟with open的实现过程

class Open:
    def __init__(self,filepath,mode='r',encoding='utf-8'):
        self.filepath=filepath
        self.mode=mode
        self.encoding=encoding

    def __enter__(self):
        # print('enter')
        self.f=open(self.filepath,mode=self.mode,encoding=self.encoding)
        return self.f

    def __exit__(self, exc_type, exc_val, exc_tb):
        # print('exit')
        self.f.close()
        return True
    def __getattr__(self, item):
        return getattr(self.f,item)

with Open('a.txt','w') as f:
    print(f)
    f.write('aaaaaa')
    f.asdfsdf #抛出异常，交给__exit__处理

5.元类（metaclass）