Python成长之路【第十篇】：Python基础之面向对象进阶

一、反射

什么是反射？

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

四个可以实现自省的函数

下列方法适用于类和对象

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

获取object中的属性，如果不写default值，找不到报错，设置之后，找不到则返回default值，不报错

设置object中name的值，有则修改，没有则创建

删除object中name属性，存在则删除，不存在则报错

class BlackMedium:
    face = "ugly"
    def __init__(self,name,addr):
        self.name = name
        self.addr = addr

    def sell_houres(self):
        print("[%s]正在卖房子" %self.name)

    def rent_houres(self):
        print("[%s]正在租房子" % self.name)

b1 = BlackMedium("万称质地","田璐元")

# 检测是否含有某属性
print(hasattr(b1,"name"))  # 有为True
print(hasattr(b1,"nam1564165e"))  # 没有为False

# 获取属性
print(getattr(b1,"name"))  # 有则打印属性
# print(getattr(b1,"name56+"))  # 没有则报错
print(getattr(b1,"nam456456e","没有这个属性"))  # 可以设置找不到的提示，不会报错

# 设置属性
setattr(b1,"qwe",123)  # 没有则创建
print(b1.__dict__)
setattr(b1,"addr","sss")  # 有则修改
print(b1.__dict__)

# 删除属性
delattr(b1,"addr")  # 有则删除
# delattr(b1,"nam4156456e")  # 没有则报错
print(b1.__dict__)

# 补充：也可以增加函数属性

setattr(b1,"func",lambda x:x+1)
print(b1.__dict__)
print(b1.func(10))
setattr(b1,"func1",lambda self:self.name+"444")
print(b1.__dict__)
print(b1.func1(b1))

 反射补充：

# 观点：一切皆对象

# 需求：
# 利用自省（反射）检测模块中的属性，就是py文件中的属性

import sys
x = 1
y = 2
obj = sys.modules[__name__]  # 拿到当前模块（文件）这个对象
print(hasattr(obj,"x"))

为什么要用反射呢？

有俩程序员，一个小明，一个小刚，额。。名字有点水，不过不用在意细节，小明在写程序的时候需要用到小刚所写的类，但是小刚和女朋友去度蜜月去了，还没有完成他写的类，小明想到了反射，使用了反射机制的小明可以继续完成自己的代码，等

小刚度蜜月回来之后再继续完成类的定义，并且去实现小明想要的功能

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

class Ftpclient:
    "ftp客户端，但是还没有实现具体的功能"
    def __init__(self,addr):
        print("正在连接服务器[%s]" %addr)
        self.addr = addr

from ftp import Ftpclient

f1 = Ftpclient("192.168.1.1")

if hasattr(f1,"get"):
    func_get = getattr(f1,"get")
    func_get()
else:
    print("--->不存在此方法")
    print("处理其他逻辑")

class Ftpclient:
    "ftp客户端，但是还没有实现具体的功能"
    def __init__(self,addr):
        print("正在连接服务器[%s]" %addr)
        self.addr = addr
    def get(self):
        print("正在上传")

 这时候我们定义完get方法之后，再来运行一下小明的程序

动态导入模块

# print("------>")
# def test1():
#     print("test1")
# def _test2():
#     print("test2")

# 将上方代码写入目录为 m1/t.py
# 然后再写一个与m1同级的.py文件，下方全部为此文件内容

# 第一种：
a = __import__("m1.t")  # 这行代码一旦执行，就会执行t.py文件
print(a)
# 这时候我们发现只拿到了顶级的模块，也只能拿到这个最顶级的
# 那我们想要执行t.py文件内的test1函数怎么办呢
a.t.test1()
# 这样就执行了，需要通过两次.的方式，因为我们只拿到了顶级的模块

# 第二种：
from m1.t import *
test1()
# test2()  # 报错
# _test2()  # 报错
# 因为import * 不能导入隐藏属性，也就是变量名前有下划线的属性

# 那我们换一种方法试试
from m1.t import test1,_test2

test1()
_test2()
# 成功，Python并没有真正的限制

# 第三种：
import importlib
a = importlib.import_module("m1.t")
print(a)
# 这时候我们就会发现，我们定位到了t.py模块这一级别
# 这样我们就可以直接用a来调用方法了
a.test1()
a._test2()  # 注意！下划线开头的变量名，只是在 import * 的时候不能被导入

 二、__getattr__、__setattr__、__delattr__

# __getattr__

class Foo:
    x = 1
    def __init__(self,y):
        self.y = y
    def __getattr__(self, item):
        print("执行__getattr__")

f1 = Foo(10)
print(f1.y)
print(getattr(f1,"y"))
f1.ssssss  # 找不到属性的时候将会执行内置函数__getattr__

# __setattr__

class Foo:
    x = 1
    def __init__(self,y):
        self.y = y
    def __setattr__(self, key, value):
        print("执行__setattr__")
        # self.key = value  # 报错，因为进入了无限递归
        self.__dict__[key] = value
        # 因为设置属性底层就是操作的字典，所以我们直接操作字典就行了，这样就解决了无限递归
f1 = Foo(10)
print(f1.__dict__)
f1.a = 1
print(f1.__dict__)

# __delattr__

class Foo:
    x = 1
    def __init__(self,y):
        self.y = y
    def __delattr__(self, item):
        print("执行__delattr__")

f1 = Foo(10)
del f1.x  # 此行代码一旦运行，便会运行内置函数__delattr__
del f1.y  # 此行代码一旦运行，便会运行内置函数__delattr__

 补充：这三个是给类的实例去用的

三、__getattribute__

class Foo:
    y = 1
    def __init__(self,x):
        self.x = x
    def __getattr__(self, item):
        print("执行__getattr__")
    def __getattribute__(self, item):
        print("执行__getattribute__")
        raise AttributeError("抛出异常啦")

f1 = Foo(10)
f1.x  # 可以找到x属性，会执行__getattribute__方法
f1.xxxxx  # 不可以找到y属性，也会执行__getattribute__方法

# 当__getattribute__和__getattr__ 同时存在，无论找得到还是找不到属性，
# 都会执行__getattribute__，
# 但只要__getattribute__抛出AttributeError的异常，就会执行__getattr__

　　

四、isinstance(obj,cls) 和 issubclass(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 Bar(Foo):
    pass

print(issubclass(Bar,Foo))
# True

　　

五、二次加工标准类型（包装）

包装：Python为大家提供了标准数据类型，以及丰富的内置方法。其实在很多场景下我们都需要基于标准数据类型来定制我们自己的数据类型，新增或者改写方法，这就用到了我们刚学的继承和派生知识，（其他的标准类型均可以通过下面的方式进行二次加工）

# 需求：
# 做一个列表的添加方法，注意：只能添加字符串

class List(list):
    def append(self, object):
        if type(object) is str:
            super().append(object)
        else:
            print("只能添加字符串")
l1 = List("hello world")
print(l1)
l1.append(1111)
l1.append("2222")
print(l1)

# 需求：
# 显示列表中间的元素

class List(list):
    def show_middle(self):
        mid_index = int(len(self)/2)
        return self[mid_index]

l1 = List("albert")
print(l1.show_middle())

授权：授权是包装的一个特性，包装一个类型通常是对已存在的一些类型进行定制，这种做法可以新建，修改或删除原有产品的功能。其他的则保持原样。授权的过程，即是所有更新的功能都是由新类的某部分来处理的，但已存在的功能就授权给对象的默认属性

实现授权的关键点就是覆盖__getattr__方法

# 授权
# 一、自己定义一个文件处理类

class FileHandle:
    def __init__(self,filename,mode = "r",encoding = "utf8"):
        self.file = open(filename,mode,encoding = encoding)
        self.mode = mode
        self.encoding = encoding

    def __getattr__(self, item):
        return getattr(self.file,item)
f1 = FileHandle("a.txt","w+")
f1.write("111")
f1.seek(0)
print(f1.read())

import time
class FileHandle:
    def __init__(self,filename,mode = "r",encoding = "utf8"):
        self.file = open(filename,mode,encoding = encoding)
        self.mode = mode
        self.encoding = encoding
    def write(self,line):
        t = time.strftime("%Y-%m-%d %X")
        self.file.write("%s %s" %(t,line))
    def __getattr__(self, item):
        return getattr(self.file,item)
f1 = FileHandle("a.txt","w+")
f1.write("111
")
f1.write("222
")
f1.write("333
")
f1.write("444
")

六、__getitem__、__setitem__、__delitem

这三个内置方法是什么时候，怎么触发的呢？请点击查看代码

class Foo:
    def __getitem__(self, item):
        print("getitem")
    def __setitem__(self, key, value):
        print("setitem")
    def __delitem__(self, key):
        print("delitem")

f1 = Foo()

f1["name"]
# 一旦通过字典的形式，对f1字典的键值对进行查找，就会触发__getitem__方法

f1["name"] = "albert"
# 一旦通过字典的形式，对f1字典的键值对进行设置，就会触发__setitem__方法

del f1["name"]
# 一旦通过字典的形式，对f1字典的键值对进行删除，就会触发__delitem__方法

# 但是，你会发现，这三个方法中除了打印，就没有别的操作了
# 并没有真正的查找，设置，删除

那如何让我们自己写的这些方法有意义呢？请点击下方的查看代码

class Foo:
    def __init__(self,name):
        self.name = name
    def __getitem__(self, item):
        print("getitem")
        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("albert")

print(f1["name"])
# getitem
# albert

f1["name"] = "123"
print(f1.__dict__)
# setitem
# {'name': '123'}

del f1["name"]
print(f1.__dict__)
# delitem
# {}

# 这样咱们自己重新定义的内置方法就变得有意义了

注意：只能通过字典的方式查找，设置，删除才会触发item系列， 不能用（.），（.）是触发attr系列的

七、__str__、__repr__、__format__

改变对象的字符串显示__str__、__repr__

自定制格式化字符串__format__

# __str__

# 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("albert",18)
# print(f1) # str(f1)--> f1.__str__()
#
# x = str(f1)  # 看结果
# print(x)
#
# y = f1.__str__()  # 看结果
# print(y)




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

    def __repr__(self):
        return "名字是%s 年龄是%s" %(self.name,self.age)

f1 = Foo("albert",18)
print(f1)  # 找不到__str__就会找__repr__ 相当于__str__的替代品
# 如果__str__和__repr__同时存在，就会执行__str__


"""
str函数或者print函数--->obj.__str__()
repr或者交互式解释器--->obj.__repr__()
如果__str__没有被定义，那么就会使用__repr__来代替输出
注意：这俩方法的返回值必须是字符串，否则抛出异常
"""

# 格式库
format_dic = {
    "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):
        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("2018","05","04")

print(format(d1))  # 如果没指定格式，会使用默认，if已决定

print(format(d1,"y:m:d"))

print(format(d1,"456465465456"))  # 如果格式不存在，会使用默认，if已决定

 八、__slots__

"""
1.__slots__是什么：
是一个类变量，变量值可以是列表，元组或者可迭代对象，也可以是一个字符串（意味着所有实例只有一个数据属性）

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

3.为何使用__slots__：
字典会占用大量内存，如果你有一个属性很少的类，但是有很多实例，为了节省内存可以使用__slots__取代实例的__dict__

当你定义__slots__后，__slots__就会为实例使用一种更加紧凑的内部表示。实例通过一个很小的固定大小的数组来构建，而不是为每个实例定义一个

字典，这跟元组或列表很类似。在__slots__中列出属性名在内部被映射到这个数组的指定小标上，使用__slots__一个不好的地方就是我们不能再给实例添加新的属性了，只能使用在__slots__中定义的那些属性名

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

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

更多的是用来作为一个内存优化工具

注意：不推荐使用__slots__
"""

class Foo:
    __slots__ = "name"

f1 = Foo()
f1.name = "albert"
# f1.age = 18  # 报错，不能再添加
print(f1.name)
print(f1.__dict__)  # 报错，现在，每个实例对象已经没有字典

 九、__doc__

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

print(Foo.__doc__)

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

print(Foo.__doc__)
# 我是描述信息

class Bar(Foo):
    pass

print(Bar.__doc__)
# None

十、__module__、__class__

先在libaa.py的目录

class C:
    def __init__(self):
        self.name = "albert"

然后在与lib同级的目录下写一个index.py文件

from lib.aa import C

c1 = C()

print(c1.name)
# albert

print(c1.__module__)  # 判断c1这个实例来自哪个模块
# lib.aa

print(c1.__class__)  # 判断c1这个实例来自哪个类
# <class 'lib.aa.C'>

十一、__del__

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

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

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

    def __del__(self):
        print("我执行了")

f1 = Foo("albert")
del f1
print("---------->")
# 总结1：f1这个实例被删除的时候会执行__del__

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

    def __del__(self):
        print("我执行了")

f1 = Foo("albert")
del f1.name
print("---------->")
# 总结2：大家看打印的执行顺序
# 删除f1实例内的属性，不会执行__del__，而是最后执行的__del__
# 那没有删除f1这个实例为什么还是执行__del
# 请看用法3

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

    def __del__(self):
        print("我执行了")

f1 = Foo("albert")
# del f1.name
print("---------->")

# 咦~怎么什么都不做还是执行__del__呢？
# 其实，程序执行完后就会执行__del__
# 那这又是为什么，因为程序执行完之后
# f1这个实例自动就被Python解释器回收掉了
# 也就是删除了
# 总结3：
# 其实，__del__执行的原则就是：
# 当f1这个实例被删除后，就会执行__del__

 十二、__call__

对象后边加括号，触发执行

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

class Foo:
    def __call__(self, *args, **kwargs):
        print("__call__执行了")

f1 = Foo()
f1()  # 当一个实例对象加上括号()之后就会执行他的类中的__call__方法

# 我们在实例对象的时候回用一个变量名来接收一个类名加上括号()
# 就像上边的f1 = Foo()
# 那么基于Python中一切皆对象的原则
# Foo这个类也是一个对象，那么这个Foo加上括号()，也就是在执行Foo这个实例对象他的类中的__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)
# print(next(f1))
# print(next(f1))
# print(next(f1))
# print(next(f1))  # 报错，检测得到StopIteration异常

for i in f1:  # for 循环可以捕捉到StopIteration异常，所以没报错
    print(i)

class Fib:
    def __init__(self,x):
        self._a = 0   # 定义初始值
        self._b = 1   # 定义初始值
        self.x = x    # 定义终止值
    def __iter__(self):
        return self
    def __next__(self):
        if self._a > self.x:
            raise StopIteration
        self._a,self._b = self._b,self._a + self._b
        return self._a

f1 = Fib(100)  # 传入终止值
print(next(f1))
print(next(f1))
print(next(f1))
print(next(f1))
print(next(f1))
print("---------")
for i in f1:
    print(i)

 十四、描述符（__get__、__set__、__delete__）

1、描述符是什么：描述符本质就是一个新式类，在这个新式类中，至少实现了__get__、__set__、__delete__中的任何一个方法，这也被称为描述符协议

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

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

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

 

class Foo:
    def __get__(self, instance, owner):
        print("__get__")
    def __set__(self, instance, value):
        print("__set__")
    def __delete__(self, instance):
        print("__delete__")

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 = "albert"
f1.name
del f1.name

class Foo:
    def __get__(self, instance, owner):
        print("__get__")
    def __set__(self, instance, value):
        print("__set__")
    def __delete__(self, instance):
        print("__delete__")
class Bar:
    # 何地？
    x = Foo()   # Foo()为描述符，描述x
    def __init__(self,n):
        self.n = n
# 何时？
b1 = Bar(10)

b1.x
# __get__

b1.x = 10
# __set__

del b1.x
# __delete__

# 一旦对x进行操作，那么就会去Foo去找__get__、__set__、__delete__

3、描述符分两种：

一、数据描述符：至少实现了__get__和__set__

class Foo:
    def __get__(self, instance, owner):
        print("__get__")
    def __set__(self, instance, value):
        print("__set__")

二、非数据描述符：没有实现__set__

class Bar:
    def __get__(self, instance, owner):
        print("__get__")

4、注意事项：

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

二、必须把描述符定义成这个类的类属性，不能定义到构造函数中

三、要严格遵循该优先级，优先级由高到低的顺序是：

　　1.类属性

　　2.数据描述符

　　3.实例属性

　　4.非数据描述符

　　5.找不到的属性触发__getattr__（这个有点瑕疵）

#描述符Str
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


#基于上面的演示,我们已经知道,在一个类中定义描述符它就是一个类属性,存在于类的属性字典中,而不是实例的属性字典

#那既然描述符被定义成了一个类属性,直接通过类名也一定可以调用吧,没错
People.name #恩,调用类属性name,本质就是在调用描述符Str,触发了__get__()

People.name='albert' #那赋值呢,我去,并没有触发__set__()
del People.name #赶紧试试del,我去,也没有触发__delete__()
#结论:描述符对类没有作用-------->傻逼到家的结论

'''
原因:描述符在使用时被定义成另外一个类的类属性,因而类属性比二次加工的描述符伪装而来的类属性有更高的优先级
People.name #恩,调用类属性name,找不到就去找描述符伪装的类属性name,触发了__get__()

People.name='egon' #那赋值呢,直接赋值了一个类属性,它拥有更高的优先级,相当于覆盖了描述符,肯定不会触发描述符的__set__()
del People.name #同上
'''

#描述符Str
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('albert',18)

#如果描述符是一个数据描述符(即有__get__又有__set__),那么p1.name的调用与赋值都是触发描述符的操作,于p1本身无关了,相当于覆盖了实例的属性
p1.name='asdsds'
p1.name
print(p1.__dict__)#实例的属性字典中没有name,因为name是一个数据描述符,优先级高于实例属性,查看/赋值/删除都是跟描述符有关,与实例无关了
del p1.name

5、描述符的应用

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

需求：在初始化类的时候，必须按照，name为字符串类型，age为整型类型，salary为浮点型类型

part1

我们先简单的写一个框架

class Typed:
    def __get__(self, instance, owner):
        print("__get__")
        print("instance的参数是【%s】" %instance)
        print("owner的参数是【%s】" %owner)
    def __set__(self, instance, value):
        print("__set__")
        print("instance的参数是【%s】" %instance)
        print("value的参数是【%s】" %value)
    def __delete__(self, instance):
        print("__delete__")
        print("instance的参数是【%s】" %instance)

class People:
    name = Typed()
    def __init__(self,name,age,salary):
        self.name = name
        self.age = age
        self.salary = salary

p1 = People("albert",18,13.1)

p1.name
print(p1.__dict__)

part2

然后为第一个参数（name）进行类型限制设置

class Typed:
    def __init__(self,x):
        self.x = x
    def __get__(self, instance, owner):
        print("__get__")
        # print("instance的参数是【%s】" %instance)
        # print("owner的参数是【%s】" %owner)
    def __set__(self, instance, value):
        print("__set__")
        # print("instance的参数是【%s】" %instance)
        # print("value的参数是【%s】" %value)
        if not isinstance(value,str):  # 检测value是否为str实例
            raise TypeError("输入类型错误")
        instance.__dict__[self.x] = value
    def __delete__(self, instance):
        print("__delete__")
        # print("instance的参数是【%s】" %instance)

class People:
    name = Typed("name")
    def __init__(self,name,age,salary):
        self.name = name
        self.age = age
        self.salary = salary

# p1 = People(123,18,13.1)  # 报错，因为第一个参数不是字符串类型
p1 = People("albert",18,13.1)
print(p1.__dict__)

part3

最后，对所有的参数进行类型限制，在这，我写了两个版本

有什么区别呢？

其一是：我自己的版本，通过老师的讲解，我自己的想法是定义了两个字典来实现报错信息的其中内容

其二是：老师讲解的版本，直接将类型当参数传入，然后当做报错信息的其中内容

为什么我非要写自己的版本？

只是为了练习！！！

class Typed:
    type_0 = {
        "name":"str",
        "age":"int",
        "salary":"float"
    }
    wrong = {
        "name": "输入的内容不是字符串",
        "age": "输入的内容不是整型",
        "salary": "输入的内容不是浮点型"
    }
    def __init__(self,x):
        self.x = x
    def __get__(self, instance, owner):
        print("__get__")
        # print("instance的参数是【%s】" %instance)
        # print("owner的参数是【%s】" %owner)
    def __set__(self, instance, value):
        print("__set__")
        # print("instance的参数是【%s】" %instance)
        # print("value的参数是【%s】" %value)
        if not isinstance(value,eval(self.type_0[self.x])):  # 检测类型
            raise TypeError("%s %s" %(self.x,self.wrong[self.x]))
        instance.__dict__[self.x] = value
    def __delete__(self, instance):
        print("__delete__")
        # print("instance的参数是【%s】" %instance)

class People:
    name = Typed("name")
    age = Typed("age")
    salary = Typed("salary")
    def __init__(self,name,age,salary):
        self.name = name
        self.age = age
        self.salary = salary

p1 = People("albert",18,13.1)  # 测试，可将本行代码复制，改其中参数的类型，查看报错信息
print(p1.__dict__)

class Typed:
    def __init__(self,x,y):
        self.x = x
        self.y = y
    def __get__(self, instance, owner):
        print("__get__")
        # print("instance的参数是【%s】" %instance)
        # print("owner的参数是【%s】" %owner)
    def __set__(self, instance, value):
        print("__set__")
        # print("instance的参数是【%s】" %instance)
        # print("value的参数是【%s】" %value)
        if not isinstance(value,self.y):  # 检测类型
            raise TypeError("%s 输入的内容不是 %s" %(self.x,self.y))
        instance.__dict__[self.x] = value
    def __delete__(self, instance):
        print("__delete__")
        # print("instance的参数是【%s】" %instance)

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

p1 = People("albert",18,13.1)  # 测试，可将本行代码复制，改其中参数的类型，查看报错信息
print(p1.__dict__)

目前我们已经实现功能了，但是问题是，如果我们的类有很多属性呢，你仍然采用在定义一堆属性的方式实现？low，这时，我们来用装饰器试试

def deco(obj):
    print("类的装饰器开始运行了————>",obj)
    return obj

@deco  # Foo = deco(Foo)
class Foo:
    def __init__(self,name,age,salary):
        self.name = name
        self.age = age
        self.salary = salary

f1 = Foo("albert",18,13.3)

def deco(**kwargs):
    def wrapper(cls):
        print('类的装饰器开始运行啦------>',kwargs)
        return cls
    return wrapper

@deco(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('albert',18,13.3)

最后！

def deco(**kwargs):
    def wraaper(obj):
        for key,val in kwargs.items():
            setattr(obj,key,Typed(key,val))

        return obj
    return wraaper

class Typed:
    def __init__(self,x,y):
        self.x = x
        self.y = y
    def __get__(self, instance, owner):
        pass
    def __set__(self, instance, value):
        if not isinstance(value,self.y):
            raise TypeError("%s 输入的内容不是 %s" %(self.x,self.y))
        instance.__dict__[self.x] = value
    def __delete__(self, instance):
        print("__delete__")

@deco(name = str,age = int)
class People:

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

p1 = People("albert",18,13.1)  # 更改参数类型进行测试

6、描述符总结

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

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

7、利用描述符原理完成一个自定制@property，实现延迟计算（本质就是把一个函数属性利用装饰器原理做成一个描述符：类的属性字典中函数名为key，value为描述符类产生的对象）

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

    @property
    def area(self):
        return self.width * self.length

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

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

    def __get__(self, instance, owner):
        res = self.func(instance)
        return res
class Room:
    def __init__(self,name,width,length):
        self.name = name
        self.width = width
        self.length = length

    @lazyproperty
    def area(self):
        return self.width * self.length

r1 = Room("cesuo",2,3)
print(r1.area)
# print(Room.area)  # 报错，AttributeError: 'NoneType' object has no attribute 'width'


# 如果我们用类名来调用area属性，就会报错，如果想定制成和Python一样怎么做呢
# 我们自己定制的lazyproperty还少一个判断，加一个判断

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

    def __get__(self, instance, owner):
        if instance is None:
            return self
        res = self.func(instance)
        return res
class Room:
    def __init__(self,name,width,length):
        self.name = name
        self.width = width
        self.length = length

    @lazyproperty
    def area(self):
        return self.width * self.length

r1 = Room("cesuo",2,3)
print(Room.area)

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

    def __get__(self, instance, owner):
        print("get")
        if instance is None:
            return self
        res = self.func(instance)
        return res
class Room:
    def __init__(self,name,width,length):
        self.name = name
        self.width = width
        self.length = length

    @lazyproperty
    def area(self):
        return self.width * self.length

r1 = Room("cesuo",2,3)
print(r1.area)
print(r1.area)
print(r1.area)
print(r1.area)
print(r1.area)
# 我们会发现每次调用都会重新计算一次，我们现在不觉得有什么问题，因为计算的过程很简单嘛
# 但是如果我们计算的过程很复杂呢，每次都执行一次，就显得不够完善了
# 那我们要怎么做呢？请把下面的代码打开


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

    def __get__(self, instance, owner):
        print("get")
        if instance is None:
            return self
        res = self.func(instance)
        setattr(instance,self.func.__name__,res)
        return res
class Room:
    def __init__(self,name,width,length):
        self.name = name
        self.width = width
        self.length = length

    @lazyproperty
    def area(self):
        return self.width * self.length

r1 = Room("cesuo",2,3)


# 在return res之前我们，将res的值加入实例的字典中
print(r1.area)
print(r1.area)
print(r1.area)
# 这时候我们发现，第二次后的调用，直接去实例的字典中去拿执行结果了，就不用再次计算了
# 为什么会直接去实例的字典，而不去描述符的get方法里呢？
# 因为优先级的问题，实例属性>非数据描述符

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

    def __get__(self, instance, owner):
        print("get")
        if instance is None:
            return self
        res = self.func(instance)
        setattr(instance,self.func.__name__,res)
        return res
    def __set__(self, instance, value):
        pass
class Room:
    def __init__(self,name,width,length):
        self.name = name
        self.width = width
        self.length = length

    @lazyproperty
    def area(self):
        return self.width * self.length

r1 = Room("cesuo",2,3)

print(r1.area)
print(r1.area)
print(r1.area)
print(r1.area)
# 缓存功能失效,每次都去找描述符了,为何
# 因为描述符实现了set方法,它由非数据描述符变成了数据描述符
# 数据描述符比实例属性有更高的优先级,因而所有的属性操作都去找描述符了

8、利用描述符原理完成一个自定制@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='linhaifeng'
    @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='Albert'
    @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('你在干嘛')

9、利用描述符原理完成一个自定制@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)

十五、再看property

一个静态属性property本质就是实现get，set，delete三种方法

class Foo:
    @property
    def AAA(self):
        print('get的时候运行我啊')

    @AAA.setter
    def AAA(self,value):
        print('set的时候运行我啊')

    @AAA.deleter
    def AAA(self):
        print('delete的时候运行我啊')

#只有在属性AAA定义property后才能定义AAA.setter,AAA.deleter
f1=Foo()
f1.AAA
f1.AAA='aaa'
del f1.AAA

class Foo:
    def get_AAA(self):
        print('get的时候运行我啊')

    def set_AAA(self,value):
        print('set的时候运行我啊')

    def delete_AAA(self):
        print('delete的时候运行我啊')
    AAA=property(get_AAA,set_AAA,delete_AAA) #内置property三个参数与get,set,delete一一对应

f1=Foo()
f1.AAA
f1.AAA='aaa'
del f1.AAA

怎么用？

class Goods:

    def __init__(self):
        # 原价
        self.original_price = 100
        # 折扣
        self.discount = 0.8

    @property
    def price(self):
        # 实际价格 = 原价 * 折扣
        new_price = self.original_price * self.discount
        return new_price

    @price.setter
    def price(self, value):
        self.original_price = value

    @price.deleter
    def price(self):
        del self.original_price


obj = Goods()
obj.price         # 获取商品价格
obj.price = 200   # 修改商品原价
print(obj.price)
del obj.price     # 删除商品原价

#实现类型检测功能

#第一关：
class People:
    def __init__(self,name):
        self.name=name

    @property
    def name(self):
        return self.name

# p1=People('alex') #property自动实现了set和get方法属于数据描述符,比实例属性优先级高,所以你这面写会触发property内置的set,抛出异常


#第二关：修订版

class People:
    def __init__(self,name):
        self.name=name #实例化就触发property

    @property
    def name(self):
        # return self.name #无限递归
        print('get------>')
        return self.DouNiWan

    @name.setter
    def name(self,value):
        print('set------>')
        self.DouNiWan=value

    @name.deleter
    def name(self):
        print('delete------>')
        del self.DouNiWan

p1=People('alex') #self.name实际是存放到self.DouNiWan里
print(p1.name)
print(p1.name)
print(p1.name)
print(p1.__dict__)

p1.name='egon'
print(p1.__dict__)

del p1.name
print(p1.__dict__)


#第三关:加上类型检查
class People:
    def __init__(self,name):
        self.name=name #实例化就触发property

    @property
    def name(self):
        # return self.name #无限递归
        print('get------>')
        return self.DouNiWan

    @name.setter
    def name(self,value):
        print('set------>')
        if not isinstance(value,str):
            raise TypeError('必须是字符串类型')
        self.DouNiWan=value

    @name.deleter
    def name(self):
        print('delete------>')
        del self.DouNiWan

p1=People('alex') #self.name实际是存放到self.DouNiWan里
# p1.name=1  # 报错,必须是字符串

注：十五 from to林海峰老师

十六、__enter__、__exit__

我们都知道在操作文件对象的时候可以这么写

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

　　

上述叫做上下文管理协议，即with语句，为了让一个对象兼容with语句，必须在这个对象的类中声明__enter__和__exit__方法

class Open:
    def __init__(self,name):
        self.name = name
    def __enter__(self):
        print("出现with语句，对象__enter__被触发，有返回值则赋值给as声明的变量")
        return self
    def __exit__(self, exc_type, exc_val, exc_tb):
        print("with语句中代码块执行完毕后执行我啊")

with Open("a.txt") as f:
    print("代码块")
    print("代码块")
    print("代码块")
    print("代码块")
    print("代码块")
    print(f)  # 这里可以看到f就是实例

# 总结：
# with Open("a.txt) 执行后，自动去执行了__enter__去了，有返回值则给as声明的变量
# __exit__是在with 语句中的代码块执行完之后才会执行

__exit__中的三个参数分别代表异常类型，异常值和追溯信息，with语句中代码块出现异常，则异常后边的代码都无法执行

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

    def __enter__(self):
        print('出现with语句,对象的__enter__被触发,有返回值则赋值给as声明的变量')

    def __exit__(self, exc_type, exc_val, exc_tb):
        print('with中代码块执行完毕时执行我啊')
        print(exc_type)  # 异常类
        print(exc_val)  # 异常值
        print(exc_tb)  # 追溯信息



with Open('a.txt') as f:
    print('=====>执行代码块')
    raise AttributeError('***着火啦,救火啊***')
print('0'*100) #------------------------------->不会执行

如果__exit__的返回值为True，那么异常会被清空，就好像什么都没发生一样，直接跳出with代码块，直接执行后边的代码，因为执行了__exit__嘛

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

    def __enter__(self):
        print('出现with语句,对象的__enter__被触发,有返回值则赋值给as声明的变量')

    def __exit__(self, exc_type, exc_val, exc_tb):
        print('with中代码块执行完毕时执行我啊')
        print(exc_type)
        print(exc_val)
        print(exc_tb)
        return True



with Open('a.txt') as f:
    print('=====>执行代码块')
    raise AttributeError('***着火啦,救火啊***')
    print("**********")   # 这里不会执行，因为已经执行了__exit__
print('0'*100) #------------------------------->会执行

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.wasdf #抛出异常，交给__exit__处理

用途或者说好处：

1、使用with语句的目的就是把代码块放在with中执行，with结束后，自动完成清理工作，无需手动干预

2、在需要管理一些资源比如文件，网络连接和锁的编程环境中，可以再__exit__中定制自动释放内存的机制，你无需再去关心这个问题，这将大有用处

　　

十七、元类

1、引子

class Foo:
    pass

f1 = Foo()  # f1是通过Foo类实例化的对象

python中一切皆对象，类本身也是一个对象，当使用关键字class的时候，Python解释器在加载class的时候就会创建一个对象（这里的对象指的是类而非类的实例）

上例可以看出f1是由Foo这个类产生的对象，而Foo本身也是对象，那它又是那个类产生的呢？

class Foo:
    pass

f1 = Foo()  # f1是通过Foo类实例化的对象

# type函数可以查看类型，也可以用来查看对象的类，两者是一样的
print(type(f1))  # 输出：<class '__main__.Foo'>  表示f1对象有Foo类创建
print(type(Foo))  # 输出：<class 'type'>

　　

2、什么是元类？

元类是类的类，是类的模板

元类是用来控制如何创建类的，正如类是创建对象的模板一样

元类的实例为类，正如类的实例为对象（f1对象是Foo类的一个实例，Foo类是type类的一个实例）

3、创建类的两种方式

方式一：

class Foo:
    def func(self):
        print("from func")

方式二：

def func1(self):
    print("from func1")
x = 2
Foo = type("Foo",(object,),{"func1":func1,"x":x})
print(Foo.x)

　　

4、一个类没有声明自己的元类，默认它的元类就是type，除了使用元类type，用户也可以通过继承type来自定义元类（顺便我们也可以瞅瞅元类如何控制类的创建，工作流程是什么）

class MyType(type):
    def __init__(self,a,b,c):
        print("开始执行元类的构造函数")
        print(a)
        print(b)
        print(c)

class Foo(metaclass = MyType):  # Foo = MyType(Foo,"Foo",(object),{})
    def __init__(self,name):
        self.name = name

f1 = Foo("albert")

为什么Foo("albert")就能自动执行__init__呢,必然是有一个地方定义好了的啊
请看下面代码

class MyType(type):
    def __init__(self,a,b,c):
        print("开始执行元类的构造函数")
        print(a)
        print(b)
        print(c)
    def __call__(self, *args, **kwargs):
        print("--->")
        print(args)
        print(kwargs)
        obj = object.__new__(self)  # 因为所有类继承的都是object
        self.__init__(obj,*args,**kwargs)  # Foo.__init__(f1,*args,**kwargs)
        return obj  # 这里如果不return，那么f1的值会为None
class Foo(metaclass = MyType):  # Foo = MyType(Foo,"Foo",(object),{})
    def __init__(self,name):
        self.name = name  # f1.name = name

f1 = Foo("albert")
# Foo("albert") 执行就是在执行他的call方法，为什么以前学到的是自动执行__init__呢
# 因为，这是call搞的鬼，让我们看似直接执行的__init__
# 本质上是先执行__call__然后执行的__init__
print(f1)
print(f1.__dict__)
print(Foo.__dict__)

class MyType(type):
    def __init__(self,a,b,c):
        print("开始执行元类的构造函数")
    def __call__(self, *args, **kwargs):
        obj = object.__new__(self)
        self.__init__(obj,*args,**kwargs)
        return obj
class Foo(metaclass = MyType):
    def __init__(self,name):
        self.name = name
f1 = Foo("albert")
print(f1)
# print(f1.__dict__)
# print(Foo.__dict__)

十八、补充

异常的简单了解

-end-