装饰器、元类、元编程，基础概念分析。

前面写过一次，但对于类的元编程也就是元类，其实掌握的并不彻底，虽然装饰器基本能完成元类的工作。但了解了元类可以对与OOP的学习有更深的认识。

废话不多，开始了。

首先这次参考的是书籍是《Python学习笔记》第九章，也是一个超级大神的书。

所谓的元编程将程序当做数据，或在运行期完成编译期的工作。

在利用装饰器(decorator)，可在不侵入内部实现，甚至在不知道的情况下，插入扩展逻辑。

装饰器的本质是一个函数，一般普通的装饰器也返回一个函数，原理的使用中调用了闭包，因为传入的参数为非全局变量。

def log(fn):
    # 内部的装饰器函数
    def wrap(*args, **kwargs):
        print(f"log: {args},  {kwargs}")
        # 间接调用原函数
        return fn(*args, **kwargs)

    # 返回包装函数代替原函数
    return wrap


@log
def add(x, y):
    return x + y

if __name__ == '__main__':
    add(1, 2)
    

log: (1, 2),  {}

 @是Python的语法糖，其实每条@log执行的是xxx =log(xxx) xxx为被装饰的函数。所以其应用于多个目标函数没有问题。

因此任何可调用的对象都可以用来做装饰器

相比与函数，使用类可以创建更加复杂的装饰器。

class Log2:

    def __init__(self,func):
        # print('__int__')
        # 其实运行了这个装饰器，实际就是self = wraps(func)(self)
        wraps(func)(self)

    def __call__(self, *args, **kwargs):
        print(f"log: {args},  {kwargs}")
        # 其实直接执行self也可以调用被装饰的函数，self()默认也是执行func()，但直接执行self，会调用self的__call__陷入死循环
        return self.__wrapped__(*args, **kwargs)

    # 定义了__get__改对象在类实例化过程中会被当做非数据型描述符，对该属性读取时，会首先被调用
    def __get__(self, instance, owner):
        # 这个可以判断是否时在类里面被调用
        # print(instance, owner)
        if instance is None:
            return self
        else:
            # 如果是直接将self绑定给instance，其实也可以将self.__wrapped__通过types.MethodType绑定到instance上面
            return types.MethodType(self, instance)

class X:
    @Log2
    def test(self):
        print('my name is test')

上面的 类装饰在执行过程中，在X实例过程中，将test函数通过wraps变成自身，后续实例调用test方式的时候，再通过__get__将该函数绑定到实例上面。

上面我写的一个类装饰器，可以装饰函数与方法，本书中没有重写描述符协议，这个写法是从cookbook中看来，应该这里来看明显普通的函数装饰器更加适合写方法。

因为函数对象默认实现了描述符协议和绑定的规则。

嵌套使用多个装饰器

----> 1 @a
      2 @b
      3 def test():...



In [4]: test = a(b(test))   

 上面演示了多个装饰器时候的实际情况，装饰器结构的是前一个装饰器的返回值，该返回值可能是包装对象，或是原函数。如此，就必须注意排列顺序，因为每个装饰器的返回值并不相同。

我们必须确保类型方法的装饰器是最外面的一个，因为无法确定内层装饰器如何实现。

 [5]: class X: 
   ...:      
   ...:     @classmethod 
   ...:     @log 
   ...:     def test(cls):... 
   ...:                        

参数，除被装饰的目录外，还可向装饰器传递其他参数，以实现更多定制特性。

这个相对比较好理解，我不抄书了，有些书上面定义为装饰器工厂

可以在用装饰器的时候，在@log(xxx)的时候给内部装饰器带去参数xxx，已实现不同的逻辑功能。

属性

我们应该让包装函数更像原函数一些，比如拥有某些相同的属性。

In [6]: import functools                                                                                                                                           

In [7]: def log(fn): 
   ...:      
   ...:     @functools.wraps(fn) 
   ...:     def wrap(*args, **kwargs): 
   ...:         return fu(*args, **kwargs) 
   ...:     print(f'wrap:{id(wrap)}, func:{id(fn)}') 
   ...:     return wrap 
   ...:                                                                                                                                                            

In [8]: @log 
   ...: def add(x: int, y: int) -> int: 
   ...:     return x + y 
   ...:                                                                                                                                                            
wrap:4372788576, func:4372788864

In [9]: add.__name__                                                                                                                                               
Out[9]: 'add'

In [10]: add.__annotations__                                                                                                                                       
Out[10]: {'x': int, 'y': int, 'return': int}

In [11]: id(add), id(add.__wrapped__)                                                                                                                              
Out[11]: (4372788576, 4372788864)

In [12]: def log(fn): 
    ...:      
    ...:      
    ...:     def wrap(*args, **kwargs): 
    ...:         return fu(*args, **kwargs) 
    ...:     print(f'wrap:{id(wrap)}, func:{id(fn)}') 
    ...:     wrap=functools.wraps(fn)(wrap) 
    ...:     return wrap 
    ...:      
    ...:                                                                                                                                                           

In [13]: @log 
    ...: def add(x: int, y: int) -> int: 
    ...:     return x + y 
    ...:                                                                                                                                                           
wrap:4405430896, func:4405430176

In [14]: id(add), id(add.__wrapped__)                                                                                                                              
Out[14]: (4405430896, 4405430176)

In [15]:  

 functools.wrap将原函数的__module__，__name__,__doc__,__annotations__等属性复制到包装函数，还用__wrapped__存储原始函数或上一装饰器返回值。

可据此然开装饰器对单元测试的干扰，从代码中明显看到，functools.wraps是一个装饰器工厂。

类型装饰器

装饰器同样可用于类型，这里的区别无非是接收的参数为类型对象而已

def log(cls):

    class wrapper:

        def __init__(self, *args, **kwargs):
            # 将cls实例返回给wrapper实例的属性inst
            self.__dict__['inst'] = cls(*args, **kwargs)

        def __getattr__(self, item):
            value = getattr(self.inst, item)
            print(f'get: {item} = {value}')
            return value

        def __setattr__(self, key, value):
            print(f'set: {key} = {value}')
            setattr(self.inst, key, value)
    # 返回类本身
    return wrapper

@log
class X:
    ...

x = X()
x.a=1
print(x.a)

 上面通过装饰器内部定义一个类，装饰一个类，将被装饰的类的实例装饰成装饰器内部类实例的一个属性，完成被装饰的功能。

前面的使用包装类比较麻烦，可以直接使用函数，间接调用目标构建方法创建实例。

Press ENTER to continue...                                                                                                                                         
In [16]: def log(cls): 
    ...:     functools.wraps(cls) 
    ...:     def wrap(*args,**kwargs): 
    ...:         o = cls(*args, **kwargs) 
    ...:         print(f'log: {o}') 
    ...:         return o 
    ...:     return wrap 
    ...:                                                                                                                                                           

In [17]: @log 
    ...: class X:...                                                                                                                                               

In [18]:                                                                                                                                                           

In [18]: X()                                                                                                                                                       
log: <__main__.X object at 0x106a8f590>
Out[18]: <__main__.X at 0x106a8f590>

In [19]:                                    

 这个直接就返回了实例化的对象。

应用

利用装饰器功能，我们可以编写各种辅助开发工具，完成诸如调用跟踪、性能测试、内存检测等任务。当然更多的时候用于模型设计，改善代码结构。

调用跟踪

记录目标调用参数、返回值，以及执行次数和执行时间等信息

In [19]: def call_count(fn): 
    ...:      
    ...:     def counter(*args, **kwargs): 
    ...:         counter.__count__ += 1 
    ...:         return fn(*args, **kwargs)
　　　　　　　　# 给函数属性复制，保持状态 
    ...:     counter.__count__ = 0 
    ...:     return counter 
    ...:                                                                                                                                                           

In [20]: @call_count 
    ...: def a():...                                                                                                                                               

In [21]: @call_count 
    ...: def b():...                                                                                                                                               

In [22]:                                                                                                                                                           

In [22]: a();a();a.__count__                                                                                                                                       
Out[22]: 2

In [23]: b();b();b();b.__count__                                                                                                                                   
Out[23]: 3

In [24]: a();a.__count__                                                                                                                                           
Out[24]: 3

In [25]:  

 通过闭包的查看

In [25]: a.__closure__                                                                                                                                             
Out[25]: 
(<cell at 0x106f92510: function object at 0x107035950>,
 <cell at 0x106f92450: function object at 0x107035a70>)

In [26]: a.__closure__[0].cell_contents                                                                                                                            
Out[26]: <function __main__.call_count.<locals>.counter(*args, **kwargs)>

In [27]: a.__closure__[1].cell_contents                                                                                                                            
Out[27]: <function __main__.a()>

In [28]:      

 a里面有两个闭包元素，一个传入的函数，还有一个就是counter函数，因为counter函数有了属性的赋值。

根据本书中闭包的定义，是指函数离开生成环境后，依然可记住，并持续引用语法作用域里的外部变量。

这里有两个，一个是外部传入函数，一个是定义的函数的属性，都在函数离开生成环境后，依然可记住。

在标准库中有类似的应用，通过缓存结果减少目标执行次数。

@functools.lru_cache

这个我用的很少，暂时就记一笔

属性管理

给目标添加额外属性

In [43]: def pet(cls): 
    ...:     cls.dosomeing = lambda self:None 
    ...:     return cls 
    ...:                                                                                                                                                           

In [44]: @pet 
    ...: class Parrot:...                                                                                                                                          

In [45]:                                                                                                                                                           

In [45]: Parrot.__dict__                                                                                                                                           
Out[45]: 
mappingproxy({'__module__': '__main__',
              '__dict__': <attribute '__dict__' of 'Parrot' objects>,
              '__weakref__': <attribute '__weakref__' of 'Parrot' objects>,
              '__doc__': None,
              'dosomeing': <function __main__.pet.<locals>.<lambda>(self)>})

In [46]:    

 实例管理

书中写了一个单例

class Singleton:

    def __init__(self, cls):
        self.cls = cls
        self.inst = None

    def __call__(self, *args, **kwargs):
        if not self.inst:
            self.inst = self.cls(*args, **kwargs)
        return self.inst

def singleton(cls):
    inst = None
    def wrap(*args, **kwargs):
        nonlocal inst
        if not inst:
            inst = cls(*args, **kwargs)
        return inst
    return wrap

@Singleton
class My:
    ...

@singleton
class My1:
    ...

m1 = My1(); m2= My1()
m3 = My(); m4 = My()
print(m1 is m2, m3 is m4)

True True

部件注册

class App:
    def __init__(self):
        # 初始化路由表
        self.routers = {}

    def route(self, url):
        # 通过route将地址与函数对应起来,最外层接收参数，该层接收被装饰的函数，写入路由表
        def register(fn):
            self.routers[url] = fn
            return fn
        return register

app = App()

@app.route('/')
def index():
    ...

@app.route('/help')
def help():
    ...
print(index)
print(app.routers)

<function index at 0x107990290>
{'/': <function index at 0x107990290>, '/help': <function help at 0x107990320>}

描述符

函数就是一个非数据描述符，函数能够变方法就是因为__get__的作用。

描述符属性必须定义为类型成员，所以其自身不适合存储实例相关的状态。

在创建属性时，__set_name__方法被调用，并可通过参数获知目标类型(owner)，以及属性名称

定一个完整的描述符

class descriptor:

    # 前面的学习中都是通过__init__来使用初始值的赋值,__set_name__第一次接触
    # 前期流畅的Python需要通过__init__需要通过定义不同的变量名才可以，定制唯一的self.name，非常不方便
    # 这里通过__set_name可以非常方便的在一开始就传入属性复制的时候变量名，后续的操作，直接操作self.name非常方便
    # 查了一下这个是Python3.6以上才有的，难怪流畅的Python没有，用这个方便制作描述符多了
    def __set_name__(self, owner, name):
        print(f'name: {owner.__name__}-------{name}')
        # 通过__set_name__复制实例name
        self.name = f"__{name}__"

    def __get__(self, instance, owner):
        print(f"get: {instance}, {owner}")
        return getattr(instance, self.name, None)

    def __set__(self, instance, value):
        print(f"set: {instance}, {value}")
        return setattr(instance, self.name, value)

    def __delete__(self, instance):
        print(f'del: {instance}')
        raise AttributeError("delete is disabled")

class X:
    data = descriptor()
    data2 = descriptor()

x = X()
x.data=22
x.data2 = 55
print(x.data)
print(x.data2)

/usr/local/bin/python3.7 /Users/shijianzhong/study/Python学习笔记/第九章元编程/9_2.py
name: X-------data
name: X-------data2
set: <__main__.X object at 0x10b99b990>, 22
set: <__main__.X object at 0x10b99b990>, 55
get: <__main__.X object at 0x10b99b990>, <class '__main__.X'>
22
get: <__main__.X object at 0x10b99b990>, <class '__main__.X'>
55

Process finished with exit code 0

数据描述符

这个前期流畅的Python也有介绍，这里的介绍更加精简，当做回忆，前面的忘的差不多了

如果定义了__set__或__delete__方法，我们变称呼数据描述符(data descriptor)而仅有__get__的则是非数据描述符(non-data descriptor)。

这两者的区别在于，数据描述符属性的优先级高于实例名字空间中的同名成员

class descriptor2:

    def __get__(self, instance, owner):
        print('__get___')

    def __set__(self, instance, value):
        print('__set__')

class X2:
    data = descriptor2()

x = X2()
# 与描述符同名属性，如果想传入实例属性，只能通过__dict__传入
x.__dict__['data'] = 200
# setattr(x, 'data' , 200)
print(vars(x))
print(x.data)

{'data': 200}
__get___
None

class descriptor2:

    def __get__(self, instance, owner):
        print('__get___')
    #
    # def __set__(self, instance, value):
    #     print('__set__')

class X2:
    data = descriptor2()

x = X2()
# 与描述符同名属性，如果想传入实例属性，只能通过__dict__传入
x.__dict__['data'] = 200
# setattr(x, 'data' , 200)
print(vars(x))
print(x.data)

name: X-------data
name: X-------data2
{'data': 200}
200

 可以看到当仅有__get__实例属性能够覆盖非数据描述符

属性(property)是属于数据描述符，因为其定义了__get__与__set__还有__delete__

方法绑定

因为函数默认实现了描述符协议，所以当以实例或类型访问方法时，__get__首先被调用

类型和实例作为参数被传入__get__，从而截获绑定目标(__self__)，如此就将函数包装或绑定对象返回。实际被执行的，就时这个会隐藏传入第一参数的包装品

说的很精简，让我对函数有了更加充分的认识。

In [48]: class X: 
    ...:     def test(self, o): 
    ...:         print(o) 
    ...:                                                                                                                                                           

In [49]: x= X()                                                                                                                                                    

In [50]: x.test                                                                                                                                                    
Out[50]: <bound method X.test of <__main__.X object at 0x1072fa750>>

In [51]: x.test.__get__(x,X)                                                                                                                                       
Out[51]: <bound method X.test of <__main__.X object at 0x1072fa750>>

In [52]: m = x.test.__get__(x,X)                                                                                                                                   

In [53]: m.__self__, m.__func__                                                                                                                                    
Out[53]: (<__main__.X at 0x1072fa750>, <function __main__.X.test(self, o)>)

 书中说的很形象，在我们执行一个方法

比如x.test(123)

可以实际分为两步

第一步将函数包装成方法返回m = x.test.__get__(x, X)

第二步用类去执行函数X.test(m.__self__, 123)

这样的话，里面的self就自动填入，因为我的理解都时错的，以为是有了self再去找方法，其实是通过__get__找到方法，通过方法里面的__self__传入自身。

元类。

元类(metaclass)制造了所有的类型对象，并将其与逻辑上的父类关联起来。

可自定义元类，以控制类型对象的生成过程。通常自type继承，以Meta为后缀名

In [78]: class DemoMeta(type): 
    ...:     pass 
    ...:                                                                                                                                                           

In [79]: class X(metaclass=DemoMeta): 
    ...:     ... 
    ...:                                                                                                                                                           

In [80]: X.__class__                                                                                                                                               
Out[80]: __main__.DemoMeta

In [81]: x = X()                                                                                                                                                   

In [82]: x.a = 12                                                                                                                                                  

In [83]:     

 对照书中样子，写一个标准版的元类

# 本示例中的CLS为元类，self为被继承后创建的类
class DemoMeta(type):

    # 使用Python3引入的特殊方法，，这个特殊方法只在元类中有用，而且必须声明为类方法。（要使用@classmethod）
    # 解释器调用元类的__new__方法之前会先调用__prepare__返回，使用类定义体中的属性创建映射。
    # 由于为类方法,所以第一个参数必须为元类、本案例中也就是(DemoMeta)
    # 随后两个参数分别是要构建的类的名称和基类组成的元祖，返回值必须是映射。
    # 简单理解就是返回的必须是一个字典类型的，后续需要创建的类的相关属性，都装在这个字典里面。
    @classmethod
    def __prepare__(cls, name, bases):
        print(f"__prepare__: {name},{bases}")
        p_dict = OrderedDict()
        # 直接这里给后续准备创建的类对象属性里面添加了__make__属性
        p_dict['__make__'] = "Make in DemoMeta"
        return p_dict

    # __new__很多元类的相关设置都在这里操作，因为这里是创建类的地方
    # 这下一步就是__init__初始化类的属性，所以这里的操作很重要，相关条件的设置
    # 一般都可以在这里设置，是否允许创建这个类，可以根据条件修改attrs里面继承类传递过来的属性
    def __new__(cls, name, bases, attrs):
        print(f"__new__: {cls}, {name}, {bases}, {attrs}")
        return super().__new__(cls, name, bases, attrs)

    # 流畅的Python中，元类对创建类属性的调试是在__init__中操作，相对来说
    # 在这个时候，类已经创建完成，这是对继承类属性操作的最后一关了
    # 这个时候，主要是对已经创建好的类进行属性初始化，所以一般的操作在__init__完成既可
    def __init__(self, name, bases, attrs):
        print(f"__init__: {self},{name},{bases},{attrs}")
        super().__init__(name, bases, attrs)

    # 这个是在被继承类实例化的时候进行的操作，为什么类能够被实例话，就因为元类是带有__call__属性的
    # 一般元类里面很少写这个，一般不会在这里修改或者添加参数。但可以在__call__设置报错
    # 避免直接继承元类的类能够直接实现实例化
    def __call__(self, *args, **kwargs):
        print(f"__call__: {self}, {args}, {kwargs}")
        return super(DemoMeta, self).__call__(*args, **kwargs)


class X(metaclass=DemoMeta):
    data = 100

    def __init__(self, x, y):
        self.x = x
        self.y = y

    def test(self):
        ...


if __name__ == '__main__':
    x = X(1, 2)
    print(X.__dict__)
    print(vars(x))
    print(x.__make__)

也可以用函数或者其他可调用对象代替，个人觉的这是非常方便的一种简单操作方式，不必一定要去写元类，直接在函数就可以对需要创建的的类的属性进行拦截，修改。

# 质押返回的试一个类，函数也可以充当元类。也可以拦截类的产生。
# 并可以对attrs进行相关设置，我自己来看，还试函数看起来更加简单。
def demo_meta(name, bases, attrs):
    print(f"{name}, {bases}, {attrs}")
    return type(name, bases, attrs)

class X2(metaclass=demo_meta):
    data = 100

    def __init__(self, x, y):
        self.x = x
        self.y = y

    def test(self):
        ...

X2, (), {'__module__': '__main__', '__qualname__': 'X2', 'data': 100, '__init__': <function X2.__init__ at 0x108749ef0>, 'test': <function X2.test at 0x108749f80>}

参数

这里还可向元类传递参数，实现功能的定制

class Demo2Meta(type):

    def __new__(cls,name,bases,attrs, **kwargs):
        print(kwargs)
        return type.__new__(cls, name, bases, attrs)

class X3(metaclass=Demo2Meta, a=1,b=2):
    ...

{'a': 1, 'b': 2}

继承的话

可以通过metaclass显示继承，或者基类继承。

应用

基与元类，我们可以实现很多魔法，让对象拥有很高的隐式"智能"，但这会大大提升代码的复杂度。除非有必要，否则不建议这么做。

另外，元类虽然能像普通类型那样为自己的实例提供共享成员，但这里依旧要避免使用。就让元类专注与类型的创建和管理，不要掺和逻辑为好。

静态类

阻止类型创建实例对象

这里直接用__call__拦截实例的穿件就行了

class StaticClassMeta(type):
    # 一旦创建的对象实例话就报错。
    def __call__(self, *args, **kwargs):
        raise RuntimeError("can't create object for static class")

class X4(metaclass=StaticClassMeta):
    ...

x= X4()

Traceback (most recent call last):
  File "/Users/shijianzhong/study/Python学习笔记/第九章元编程/9_3.py", line 93, in <module>
    x= X4()
  File "/Users/shijianzhong/study/Python学习笔记/第九章元编程/9_3.py", line 89, in __call__
    raise RuntimeError("can't create object for static class")
RuntimeError: can't create object for static class

密封圈

阻止类型被继承

class SealedClassMeta(type):
    # 设置类属性，一个集合
    types = set()
    def __init__(self, name, bases, attrs):
        if self.types & set(bases):
            raise RuntimeError("can't create object for sealed class")
        # 首相将第一个制作的类放入集合，第二个被继承的类就不行了
        self.types.add(self)

class A(metaclass=SealedClassMeta):
    ...

class B(A):
    ...

注解

注解（annotation）为函数参数、返回值，以及模块和类型属性添加额外的元数据

In [96]: def add(x:int,y:int)->int: 
    ...:     return x+y 
    ...:                                                                                                                                                           

In [97]: add.__annotations__                                                                                                                                       
Out[97]: {'x': int, 'y': int, 'return': int}

In [98]:  

 其本质上仅是一种可编程和可执行的注释，在编译期被提取，并与对象相关联。

在运行期间，其对解释器执行没有任何影响与约束

In [98]: add([1],[2])                                                                                                                                              
Out[98]: [1, 2]

In [99]:           

 简单来说，这个东西就是拿来看的，一种比较高大上的注释

注释内容可以是任何对象或表达式。其可用于变量，但不能用于lambda函数

In [101]: x: int =12                                                                                                                                               

In [102]: x                                                                                                                                                        
Out[102]: 12

In [103]: __annotations__                                                                                                                                          
Out[103]: {'x': int}

In [104]: def test(x:{'type':int, 'range':(0,10)}=5): 
     ...:     pass 
     ...:                                                                                                                                                          

In [105]: test.__annotations__                                                                                                                                     
Out[105]: {'x': {'type': int, 'range': (0, 10)}}

In [106]: test.__defaults__                                                                                                                                        
Out[106]: (5,)

In [107]: class X: 
     ...:     data: int = 10 
     ...:     def test(self, o: str) ->str: 
     ...:         ... 
     ...:                                                                                                                                                          

In [108]: X.__annotations__                                                                                                                                        
Out[108]: {'data': int}

In [109]: X.test.__annotations__                                                                                                                                   
Out[109]: {'o': str, 'return': str}

In [110]:  

 这种注释除了lambda函数，另外的格式好像都能写。

最后，我再次拿上廖大的orm模型对元类进行最后一次的注释，希望以后能够记住了。

class Field(object):

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

    def __str__(self):
        return '<%s:%s>' % (self.__class__.__name__, self.name)

class StringField(Field):

    def __init__(self, name):
        super(StringField, self).__init__(name, 'varchar(100)')

class IntegerField(Field):

    def __init__(self, name):
        super(IntegerField, self).__init__(name, 'bigint')


# 定义元类
class ModelMetaclass(type):

    def __new__(cls, name, bases, attrs):
        # 所有继承ModelMetaclass如果制作的类的名字是Model直接无条件制作。
        if name=='Model':
            return type.__new__(cls, name, bases, attrs)
        print('Found model: %s' % name)
        mappings = dict()
        # 检查类的属性值，是不是Field的实例，是的话，放入mapping
        for k, v in attrs.items():
            if isinstance(v, Field):
                print('Found mapping: %s ==> %s' % (k, v))
                mappings[k] = v
        for k in mappings.keys():
            attrs.pop(k)
        # 重新定义属性__table__=类名，__mappings__为所有字段k，v的字典
        attrs['__mappings__'] = mappings # 保存属性和列的映射关系
        attrs['__table__'] = name # 假设表名和类名一致
        return type.__new__(cls, name, bases, attrs)

# 继承与dict可以通过=的方式进行对象实例化
class Model(dict, metaclass=ModelMetaclass):

    def __init__(self, **kw):
        super(Model, self).__init__(**kw)

    # 因为通过=的方式进行实例化，进行.读取属性的时候，会没有发现该属性，进入这里
    # 通过字典的方式读取key的方式返回属性
    def __getattr__(self, key):
        try:
            return self[key]
        except KeyError:
            raise AttributeError(r"'Model' object has no attribute '%s'" % key)

    # 定义了写入属性的方法，一定写入该属性后，会覆盖字典=号复制的属性
    def __setattr__(self, key, value):
        self[key] = value

    # 定义了保存对象，也就是执行sql语句的逻辑，这里是关键
    def save(self):
        fields = []
        params = []
        args = []
        # 读取__mappings__也就是元类中修饰以后所有的字段字段
        for k, v in self.__mappings__.items():
            # 字段名放入列表
            fields.append(v.name)
            params.append('?')
            # 就是这里读取对象的属性，如果元类不删除原丝的类属性，会优先读取类属性。
            args.append(getattr(self, k, None))
        # 拼接sql语句
        sql = 'insert into %s (%s) values (%s)' % (self.__table__, ','.join(fields), ','.join(params))
        print('SQL: %s' % sql)
        print('ARGS: %s' % str(args))


class User(Model):
    # 定义类的属性到列的映射：
    id = IntegerField('id')
    name = StringField('username')
    email = StringField('email')
    password = StringField('password')

u = User(id=12345, name='Michael', email='test@orm.org', password='my-pwd')
u.name = 'sidian'
u.save()