PythonI/O进阶学习笔记_7.python动态属性，__new__和__init__和元类编程（上）

content：

上：

1.property动态属性

2.__getattr__和__setattr__的区别和在属性查找中的作用

3.属性描述符 和属性查找过程

4.__new__和__init__的区别

下：

5.什么是元类和自定义元类

6.用元类实现orm

=============================

一.property动态属性

1.什么是property？

　　在面向对象编程中，我们一般把名词性的东西映射成属性，动词性的东西映射成方法。在python中他们对应的分别是属性self.xxx和类方法。

但是有时候，我们需要对传递进来的属性进行限制、检测等操作，  此时如果直接使用属性方法处理，可能会导致数据不同步，就可以用@property方法来动态创建类属性。

2.property的作用

a. 拦截类的创建

b. 拦截下后，进行修改

c. 修改完后，返回修改后的类

3.property的简单应用

一个User类生成的user对象，需要实现传递进去的参数为年月日而计算得到age属性。

 1 from datetime import date,datetime
 2 class User:
 3     def __init__(self,name,birthday):
 4         self.name=name
 5         self.birthday=birthday
 6         self._age=0
 7         self._age2=0
 8     def get_age(self):
 9         return datetime.now()-self.birthday.year
10     @property
11     def age(self):
12         return datetime.now().year-self.birthday.year
13     @age.setter
14     def age(self,value):
15         self._age,self.age2=value
16         #return self._age
17 user=User("tanrgong",date(year=1996,month=12,day=25))
18 print(user.age)
19 user.age=(1,2)
20 print(user.age)
21 print(user._age)
22 print(user._age2)

output：
23
23
1
2

 

二.__getattr__和__setattr__的区别和在属性查找中的作用

1.__getattr__

　　_getattr__在查找不到属性的时候调用。 __getattr__在当前主流的Python版本中都可用，重载__getattr__方法对类及其实例未定义的属性有效。也就是说，如果访问的属性存在，就不会调用__getattr__方法。这个属性的存在，包括类属性和实例属性。

当调用一个类不存在的属性的时候，报错输出为AtttibuteError：

 在自己重新定义了__getattr__方法后：

 打印了我们定义的字符串,返回了None。如果将print改为return，则会直接返回字符串。

 

简单应用：

    比如说，我们现在用户有更加详细的信息。用来维护一个dict。将dict的访问方式变为对象属性访问方式。

2.__getattribute__

　　__getattribute__仅在新式类中可用，重载__getattrbute__方法对类实例的每个属性访问都有效。不管访问什么属性，都会调用这个入口。 __getattribute__是所有属性入口被调用的函数。能不重写就不去覆盖。

代码示例：

class ClassA:
    x = 'a'
    def __init__(self):
        self.y = 'b'
    def __getattribute__(self, item):
        return '__getattribute__'


if __name__ == '__main__':
    a = ClassA()
    # 使用实例直接访问存在的类属性时,会调用__getattribute__方法
    # 输出结果 __getattribute__
    print(a.x)
    # 使用实例直接访问实例存在的实例属性时,会调用__getattribute__方法
    # 输出结果 __getattribute__
    print(a.y)
    # 使用实例直接访问实例不存在的实例属性时,也会调用__getattribute__方法
    # 输出结果 __getattribute__
    print(a.z)

output：

__getattribute__
__getattribute__
__getattribute__

 

3.__getattr__和__getattribute__定义时的注意事项

当同时定义__getattribute__和__getattr__时，__getattr__方法不会再被调用，除非显示调用__getattr__方法或引发AttributeError异常。

  示例代码（同时定义时，只调用__getattribute__）：

class ClassA:
    def __getattr__(self, item):
        print('__getattr__')
    def __getattribute__(self, item):
        print('__getatttribute__')
if __name__ == '__main__':
    a = ClassA()
    a.x
 
output：
__getatttribute__

由于__getattr__只针对未定义属性的调用，所以它可以在自己的代码中自由地获取其他属性，而__getattribute__针对所有的属性运行，因此要十分注意避免在访问其他属性时，再次调用自身的递归循环。

当在__getattribute__代码块中，再次执行属性的获取操作时，会再次触发__getattribute__方法的调用，代码将会陷入无限递归，直到Python递归深度限制（重载__setter__方法也会有这个问题）。

 

示例代码（无限递归）：

class ClassA:
 
x = 'a'
 
def __getattribute__(self, item):
　　print('__getattribute__')
　　return self.item
 
if __name__ == '__main__':
　　a = ClassA()
　　a.x

会报错：ecursionError: maximum recursion depth exceeded

那如何避免这种无限递归呢？--》指向更高超类的获取属性的方法。

修改代码（避免无限递归循环）：

class ClassA:
　　x = 'a'
　　def __getattribute__(self, item):
　　　　print('__getattribute__')
　　　　return super().__getattribute__(self, item)
　　if __name__ == '__main__':
　　　　a = ClassA()
　　　　print(a.x)

output：
__getattribute__
a                                            

 

三.属性描述符 和属性查找过程

1.什么是属性描述符？

之前有讲到用property去控制属性获取和设置的过程。在初始化的时候的代码：

此时，我需要对name和email都做属性的一种限制，比如都为字符串，并且对长度做限制，对_age做int类型的限制，如果用动态属性装饰器@property就需要一个属性写一个对应的方法。这样在动不动就十多个列的数据表中是不现实的。所以我们可以创建属性描述符，来对相同的属性进行直接设置。

应用：

将一个对象理解成数据库中的一张表（在python的web框架中常用）

我们需要对每个字段的类型进行设置，需要对属性进行检查类型。实现属性描述符。

 

a.数据描述符

如何实现属性描述符？

实现__get__\__set__\__delete__任何一个魔法方法，就可以实现属性描述符。

例：对user中的age属性进行int限制，否则raise一个"Int number need"

from datetime import date,datetime
class IntField:
    def __get__(self, instance, owner):
        pass
    def __set__(self, instance, value):

　　　　if not isinstance(value,numbers.Integral):
    　　　　raise ValueError("Need Int")
　　　　if value<0:
    　　　　raise ValueError("Need >0")
　　　　self.value=value

　　def __del__(self): 
　　　　pass 
class User: 
　　age=IntField() 
　　u=User() 
　　u.age="a" 
　　print(u.age)

##output:

Traceback (most recent call last):

  File "D:/TR/项目/learning_python_io/chapter_6/property.py", line 21, in

    u.age="a"

  File "D:/TR/项目/learning_python_io/chapter_6/property.py", line 10, in __set__

    raise ValueError("Need Int")

ValueError: Need Int

如果是满足了传递的value为int类型：

 

b.非数据描述符

如果只是实现了__get_()那么就是非数据属性描述符。

 

2.以getattr来更加详细了解python类中属性查找的过程

如果user是某个类的实例，那么user.age等同于使用getattr(user,'age')。

首先调用__getattribute__，如果定义了__getattr__方法，那么在__getattribute__抛出AtrributeError的时候会调用__getattr__。面对描述符(__get__)的调用，是发生在__getattribute__内部的。具体顺序如下：

 

 

四.__new__和__init__的区别

内容整理至https://www.cnblogs.com/shenxiaolin/p/9307496.html

 

1.__new__和__init__的简介

【同】

　　二者均是Python面向对象语言中的函数，__new__比较少用，__init__则用的比较多。

【异】

• __new__是在实例创建之前被调用的，因为它的任务就是创建实例然后返回该实例对象，是个静态方法。
• __init__是当实例对象创建完成后被调用的，然后设置对象属性的一些初始值，通常用在初始化一个类实例的时候。是一个实例方法。

ps.__new__是在__init__之前，并没有生成对象。 __new__的返回值（实例）将传递给__init__方法的第一个参数，然后__init__给这个实例设置一些参数。

 

 注意：

• 继承自object的新式类才有__new__
• __new__至少要有一个参数cls，代表当前类，此参数在实例化时由Python解释器自动识别
• __new__必须要有返回值，返回实例化出来的实例，这点在自己实现__new__时要特别注意，可以return父类（通过super(当前类名, cls)）__new__出来的实例，或者直接是object的__new__出来的实例
• __init__有一个参数self，就是这个__new__返回的实例，__init__在__new__的基础上可以完成一些其它初始化的动作，__init__不需要返回值
• 如果__new__创建的是当前类的实例，会自动调用__init__函数，通过return语句里面调用的__new__函数的第一个参数是 cls 来保证是当前类实例，如果是其他类的类名，；那么实际创建返回的就是其他类的实例，其实就不会调用当前类的__init__函数，也不会调用其他类的__init__函数。
• 在定义子类时没有重新定义__new__()时，Python默认是调用该类的直接父类的__new__()方法来构造该类的实例，如果该类的父类也没有重写__new__()，那么将一直按此规矩追溯至object的__new__()方法，因为object是所有新式类的基类。
• 而如果子类中重写了__new__()方法，那么你可以自由选择任意一个的其他的新式类（必定要是新式类，只有新式类必定都有__new__()，因为所有新式类都是object的后代，而经典类则没有__new__()方法）的__new__()方法来制造实例，包括这个新式类的所有前代类和后代类，只要它们不会造成递归死循环。反正肯定不能调用自己的__new__，这肯定是死循环。
• 对于子类的__init__，其调用规则跟__new__是一致的，当然如果子类和父类的__init__函数都想调用，可以在子类的__init__函数中加入对父类__init__函数的调用。
• 我们在使用时，尽量使用__init__函数，不要去自定义__new__函数，因为这两者在继承派生时的特性还是很不一样的。

 

2.__new__的简单应用

依照Python官方文档的说法，__new__方法主要是当你继承一些不可变的class时(比如int, str, tuple)， 提供给你一个自定义这些类的实例化过程的途径。还有就是实现自定义的metaclass。

首先我们来看一下第一个功能，具体我们可以用int来作为一个例子：

假如我们需要一个永远都是正数的整数类型，通过集成 int，我们可能会写出这样的代码。

但运行后会发现，结果根本不是我们想的那样，我们任然得到了-3。这是因为对于int这种 不可变的对象，我们只有重载它的__new__方法才能起到自定义的作用。

这是修改后的代码：  

通过重载__new__方法，我们实现了需要的功能。

当然，应用__new__这种更多的还是在各大框架里的应用。下篇会简要实现在django中，用元类编程，__new__来实现orm。