Python属性函数

引言

  • Python中我们对于自己设置的类，尽量要使其属性私有化，获得更好的封装性。
  • 如果要访问和修改私有属性，要为其设置set和get方法。

  • Python中，可以使用特殊的装饰器将set和get方法属性化，这样就能够使用更简洁的语法去调用这些方法。

    使用案例

    ```python class Person: def init(self, name, age):

    1.   self.__name = name
    2.   self.__age = age

    这里以 age 为例

    @property def age(self):

    1.   return self.__age

    @age.setter def age(self, age):

    1.   if age < 0:
    2.       self.__age = age
    3.   elif age > 120:
    4.       self.__age = 120
    5.   else:
    6.       self.__age = age

me = Person(“MetaTian”, 20)

print(me.age) # 直接作为属性进行调用，get方法 me.age += 1 # get 和 set 方法同时使用 print(me.age) # get 方法

result:

20

21

  1. <a name="0a8d4341"></a>
  2. # 魔法函数__getattr__()和__getattribute__()
  3. <a name="e4568847"></a>
  4. ## 引言
  6. - 这两个函数是解释器在查找对象属性时要进行调用的
  7. - 如果没找到代码需要的属性，则会调用`__getattr__()`
  8. - 如果实现了`__getattribute__()`，则不管请求什么属性都会**先调用**这个魔法函数
  9. <a name="568d18bd"></a>
  10. ## 使用案例
  11. ```python
  12. """
  13. 如果没有实现 __getattr__()，调用未定义的属性后，会报错
  14. """
  15. class Person:
  16.     pass
  18. me = Person()
  19. print(me.age)
  20. # result:
  21. # AttributeError: 'Person' object has no attribute 'age'
  1. class Person:
  2.     # attr 是代码请求的属性
  3.     def __getattr__(self, attr):
  4.         return "{0} dose not exist".format(attr)
  6. me = Person()
  7. print(me.age)
  8. print(me.name)
  10. # result:
  11. # age dose not exist
  12. # name dose not exist
  1. """
  2. 实现了__getattribute__()魔法函数
  3. 不论请求什么属性，都返回同样的值
  4. """
  5. class Person:
  6.     def __init__(self, name, age):
  7.         self.name = name
  8.         self.age = age
  10.     def __getattribute__(self, attr):
  11.         return "value"
  13. me = Person("MetaTian", 19)
  14. print(me.age, me.name, me.gender)
  16. # result:
  17. # value value value

属性描述符

引言

  • 描述符是对多个属性运用相同的逻辑来进行存取的一种方式，它是实现了特定魔法函数的一个类。
  • 只要实现了__get__()，__set__()，__delete__()三个魔法函数中的任意一个，这个类就是描述符。

  • property最大的缺点就是它修饰属性的过程不能重复使用，如果要对多个属性进行非负检查(>=0)，那必须对每个属性的set方法分别包装。描述符就是可以重用的属性。

    使用案例

    ```python “”” 定义了一个 “非负的” 描述符 “”” class NonNegative: def init(self, label):

    1.   self.label = label    # 存储描述符在对象级别的名称

    def get(self, instance, owner):

    1.   # 当进行属性调用时，obj.p
    2.   # instance = obj
    3.   # owner = type(obj)
    4.   return instance.__dict__.get(self.label)        # 给实例添加属性

    def set(self, instance, value):

    1.   # 当进行属性调用时，obj.p = val
    2.   # instance = obj
    3.   # value = val
    4.   if not isinstance(value, int):
    5.       raise ValueError("Int value allowed")
    6.   if value < 0:
    7.       raise ValueError("Negative value not allowed: %s" % value)
    8.   instance.__dict__[self.label] = value    # 把通过检验的属性值反向设置给调用对象

    def delete(self, instance):

    1.   pass

    “”” 使用描述符的一个类 “”” class Person:

    定义为类的属性，而不是实例属性，才能触发后面的属性检查

    age = NonNegative(“age”) # label

    def init(self, name, age):

    1.   self.name = name
    2.   self.age = age    # 描述符会起作用，自动调用get和set魔法函数

me = Person(“MetaTian”, “21”)

result:

ValueError: Int value allowed

him = Person(“Rity”, -18)

result:

ValueError: Negative value not allowed: -21

me = Person(“MetaTian”, 21) him = Person(“Rity”, 21)

him.age += 1 me.age -= 1 print(him.age, me.age)

result:

22 20

  1. <a name="5db9fd7c"></a>
  2. ## 小结
  3. **描述符**其实是目标**类**的一个属性，也就是说目标类中有一个**描述符实例**。当目标类的实例准备操作自身属性时，会首先将它交给类的个**描述符实例**进行管理（`__get__(), __set__(), __delete__()`），然后由它把属性设置到实例中（`obj.__dict__[label]`）。
  4. <a name="81107be0"></a>
  5. # 属性调用顺序
  6. <a name="e4568847"></a>
  7. ## 引言
  9. - `Python`的描述符有两种类型：**数据描述符**和**非数据描述符**。
  10. - 数据描述符：实现了`__get__()`和`__set__()`魔法函数。
  11. - 非数据描述符：只实现了`__get__()`魔法函数。
  12. - 使用不同的描述符，属性查找的过程是不一样的。
  13. <a name="1f0a3a1c"></a>
  14. ## 详细
  15. 在使用`me.age`操作属性的时候，解释器对属性`age`的查找顺序是怎么样的呢？
  17. 如果`me`是某个对象的实例，那么对于`me.age`或与其等价的`getattr(me, "age")`属性操作方式，会首先调用`__getattribute__()`，如果调用过程中抛出了**AttributeError**，这时就会调用`__getattr__()`
  19. 如果`age`是一个**属性描述符**，则相关属性操作操作会委托给`__get__()`魔法函数，这个过程发生在`__getattribute__()`内部
  21. 此时，`age`属性的调用顺序如下：
  23. - **如果**`age`出现在`Person`或其基类的`__dict__`中，而且`age`是一个**数据描述符**，那么直接调用`__get__()`方法
  24. - **如果**`age`出现在`me`的`__dict__`中，那么直接返回`me.__dict__['age']`
  25. - **如果**`age`出现在`Person`或其基类的`__dict__`中：
  26.    - 如果`age`是**非数据描述符**，那么就调用`__get__`
  27.    - 否则返回`Person.__dict__['age']`
  28. - **如果**定义了`__getattr__()`，则调用`__getattr__()`
  29. - **否则**，抛出**AttributeError**
  30. <a name="9e8945fc"></a>
  31. # __new __和 __init __的区别
  32. <a name="e4568847"></a>
  33. ## 引言
  35. - `__new__()`允许我们在**类**的生成过程中加入自己的逻辑，是一个静态方法。
  36. - `__init__()`可以在生成**对象**之后加入自己的逻辑，一般是初始化属性。
  37. - `__init__()`的调用在`__new__()`之后。
  38. <a name="568d18bd"></a>
  39. ## 使用案例
  40. ```python
  41. """
  42. new 用来控制对象的生成过程，在对象生成之前起作用
  43. init 用来完善生成的对象，在对象生成之后调用
  44. 如果 new 中没有返回生成的对象，则 init 方法不会调用
  45. """
  46. def Person:
  47.     def __new__(cls, *args, **kwargs):
  48.         print("---in new---")
  49.         return super.__new__(cls)
  51.     def __init__(self, name):
  52.         print("---in init---")
  53.         self.name = name
  55. me = Person("MetaTian")
  57. # result:
  58. # ---in new---
  59. # ---in init---

自定义元类

引言

  • 前面介绍过，Python中一切皆对象，类也是一个对象，在Java中想要动态生成一个类，似乎并不容易，但是对于动态语言Python，这是比较容易实现和理解的。 ```python def create_cls(name): if name = “User”: # 动态生成的 User 类
    1.   class User:
    2.       def __str__(self):
    3.           return "user"
    4.   return User
    elif name = “Person”: # 动态生成的 Person 类
    1.   class Person:
    2.       def __str__(self):
    3.           return "person"
    4.   return Person

ClsUser, ClsPson = create_cls(“User”), create_cls(“Person”) user, person = ClsUser(), ClsPson() print(user, person)

result:

user person

  2. - 使用`type`动态地创建类会更加简洁。
  3. - 但是实际使用，往往很少直接使用`type`，而是用自己定义的**元类**。
  4. <a name="568d18bd"></a>
  5. ## 使用案例
  6. ```python
  7. """
  8. class type(name, bases, dict)
  9. name: str, 要创建类的名称
  10. bases: tuple, 创建类要继承的基类
  11. dict: 创建类的属性集合
  12. """
  13. # 必须有 self 作为参数
  14. def say(self):
  15.     print("I am a person")
  17. Person = type("Person", (), {"name":"MetaTian", "say":say})
  18. me = Person()
  20. print(me.name)
  21. me.say()
  23. # result:
  24. # MetaTian
  25. # I am a person

Python中类的创建过程中，会首先寻找metaclass，通过metaclass去创建这个类，如果没有找到metaclass，则向上找基类，使用它们的meataclass，如果都没有，再直接调用type来创建这个类。

  1. # 这是我们自己定义的一个元类
  2. class MetaClass(type):
  3.     def __new__(cls, *args, **kwargs):
  4.         # 这里不加入其它逻辑，只构建一个框架，委托给 type 进行类的构建
  5.         return super().__new__(cls, *args, **kwargs)    # 这里需要传递参数
  7. # 用我们自己定义的元类来控制 Person 类的构建
  8. class Person(metaclass=MetaClass):
  9.     def __init__(self, name):
  10.         self.name = name
  11.     def __str__(self):
  12.         return "I am {name}".format(name=self.name)
  14. me = Person("MetaTian")
  15. print(me)
  17. # result:
  18. # I am MetaTian

通过元类实现ORM

引言

  • 什么是ORM

    使用案例

    ```python “”” 需求 我们想构建出一个 Person 类，构造其一个实例后 通过obj.save()方法，就可以将它存储在数据库中 “”” class Person:

    这里的属性对应数据库表中的每一项

    在表中的哪一列，这一列数据的约束条件是什么

    name = CharField(db_colunm=None, max_length=None)

    Person 类中，定义了另外一个类，用来存放其他的一些信息

    class Meta:

    1.   db_table = "person"     # 这里存放了对象对应的数据库表名，用来后面拼凑 sql 语句

me = Person(“MetaTian”) me.save() # 在数据库中插入一条记录

  2. 首先，我们来构建**数据描述符**，数据的存储以及类型检查都委托给它来完成，把简单的调用方式暴露出来即可。这里不仅仅要处理需存储的数据，数据在数据库中的一些属性也要进行处理，比如所在的`column`和存储格式限制。
  4. ```python
  5. """
  6. 分析
  7. 类中的属性要采用描述符的方式，在存取数据的时候要进行类型检查
  8. 不仅要保存属性值的信息，还要存储属性在数据库表中的信息（max_length, db_column）
  9. """
  10. class CharField:
  11.     def __init__(self, max_length=None, db_column=None):
  12.         self.db_column = dbcolumn
  13.         self.max_length = max_length
  14.         self._value = None      # 描述符初始化的时候不给默认值，一般由用户在后面赋值
  16.         # 将这两个属性设置为必填项
  17.         if max_length is None:
  18.             raise ValueError("max_length info required")
  19.         if db_column is None:
  20.             raise ValueError("db_column info required")
  22.     # 返回值
  23.     def __get__(self, instance, owner):
  24.         return self._value
  26.     # 设置值
  27.     def __set__(self, instance, value):
  28.         if not isinstance(value, str):
  29.             raise ValueError("String value required")
  30.         if len(value) > self.max_length:
  31.             raise ValueError("valuen length invalid")
  33.         self._value = value     # 通过检查后，赋值保存
  1. """
  2. 现在我们有了如下结构：
  3. 还需要自己定义的一个元类来控制 Person 类的生成
  4. """
  5. class CharField:
  6.     pass
  8. class Person:
  9.     name = CharField(max_length=10, db_colunm="name")   # name 属性的存取检查已经完成
  11.     class Meta:
  12.         db_table = "person"     # 这个类对象和 person 这个数据库表对应

自定义的元类，要修改__new__()方法，在类的创建过程中加入一些我们自己的逻辑。

  1. class ModelMetaClass(type):
  2.     """
  3.     这里对参数元组进行了拆解，便于更好的观察
  4.     name: 要构建类对象的名称
  5.     bases: 继承的基类
  6.     attrs: 构建类对象中的属性，我们要从中提取出和业务逻辑有关的属性进行另外存储
  7.     """
  8.     def __new__(cls, name, bases, attrs, **kwargs):
  9.         for k, v in attrs.items():
  10.             print("{key}:{val}".format(key=k, val=v))
  11.         return super().__new__(cls, name, bases, attrs, **kwargs)
  13. # result:
  14. # __qualname__:Person
  15. # __module__:__main__
  16. # Meta:<class '__main__.Person.Meta'>   # 这是我们在 Person 中定义的类，存放信息
  17. # name:<__main__.CharField object at 0x00000226B18B4F28>    # 这是我们需要的
  1. class ModelMetaClass(type):
  2.     def __new__(cls, name, bases, attrs, **kwargs):
  4.         # 抽离出数据
  5.         fields = {}
  6.         for k, v in attrs.items():
  7.             if isinstance(v, CharField):    # 数据域
  8.                 fields[k] = v
  10.         for k in fields:
  11.             del attrs[k]        # 清空原来的数据
  13.         # 抽离出表名称
  14.         attrs_meta = attrs.get("Meta", None)    # 关于字典 get 方法的使用，前面讲过
  15.         db_table = name.lower()     # 数据库表名默认是类的小写形式
  16.         if attrs_meta:      # 如果类存储了表信息，用类中定义的
  17.             db_table = getattr(attrs_meta, "db_table")
  19.         del attrs["Meta"]   # 表名称信息已经获得，这里就不需要了
  21.         # 重组 attrs 参数
  22.         _meta = {"db_table":db_table}
  23.         attrs["_meta"] = _meta
  24.         attrs["fields"] = fields
  26.         for k, v in attrs.items():
  27.             print("{key}:{val}".format(key=k, val=v))
  29.         # 最后委托给 type ，完成类的创建
  30.         return super().__new__(cls, name, bases, attrs, **kwargs)
  32. # result:
  33. # __module__:__main__
  34. # fields:{'name': <__main__.CharField object at 0x000001AFCD994F98>}
  35. # __qualname__:Person
  36. # _meta:{'db_table': 'person'}
  1. """
  2. 现在我们有了如下结构：
  3. """
  4. # 控制类的生成
  5. class ModelMetaClass(type):
  6.     pass
  8. # 检查属性存取
  9. class CharField:
  10.     pass
  12. class Person(metaclass=ModelMetaClass):
  13.     name = CharField(max_length=10, db_colunm="name")   # name 属性的存取检查已经完成
  15.     class Meta:
  16.         db_table = "person"     # 这个类对象和 person 这个数据库表对应

最后，还要在Person类中添加我们需要的逻辑，比如初始化操作、写入数据库操作、查询操作等。因此要为每一个逻辑添加一个方法加入类中，但是会让这个类显得十分臃肿。我们构建这个类的目的就是希望它能和数据库的表结构尽量一一对应，简化我们的操作。同时，不同类的操作需求可能是一样的，都需要往数据库中插入一条新记录。因此，可以考虑将这些操作逻辑抽象成一个父类。

  1. class BaseModel(metaclass=ModelMetaClass):
  2.     # 便于通用，这里要约定初始化的一种方式
  3.     def __init__(self, *args, **kwargs):
  4.         for k, v in kwargs.items():
  5.             setattr(self, k, v)
  6.         super.__init__()
  8.     def save(self):
  9.         fields, values = [], []
  10.         for k, v in self.fields.items():
  11.             fields.append(v.db_column)
  12.             values.append(str(getattr(self, k)))    # 把所有的值都变成字符串，便于后面拼接
  14.         sql = "insert {table}({fields}) value({values})".format(table=self._meta["db_table"], fields=",".join(fields), values=",".join(values))
  16.         print(sql)
  17.         # todo 和数据库连接有关的逻辑
  19. class Person(BaseModel):
  20.     name = CharField(max_length=10, db_colunm="name")   # name
  22.     class Meta:
  23.         db_table = "person"     # 这个类对象和 person 这个数据库表对应
  25. me = Person(name="MetaTian")
  26. me.save()

完整的代码

  1. class CharField:
  2.     def __init__(self, max_length=None, db_column=None):
  3.         self.db_column = db_column
  4.         self.max_length = max_length
  5.         self._value = None
  7.         if max_length is None:
  8.             raise ValueError("max_length info required")
  9.         if db_column is None:
  10.             raise ValueError("db_column info required")
  12.     def __get__(self, instance, owner):
  13.         return self._value
  14.     def __set__(self, instance, value):
  15.         if not isinstance(value, str):
  16.             raise ValueError("String value required")
  17.         if len(value) > self.max_length:
  18.             raise ValueError("valuen length invalid")
  20.         self._value = value
  23. class ModelMetaClass(type):
  24.     def __new__(cls, name, bases, attrs, **kwargs):
  25.         # BaseModel和其子类都要通过这个元类来进行创建
  26.         # 子类才有相关的 Meta 信息，进行信息重组，这里进行过滤
  27.         if name == "BaseModel":
  28.             return super().__new__(cls, name, bases, attrs, **kwargs)
  29.         # 抽离出数据
  30.         fields = {}
  31.         for k, v in attrs.items():
  32.             if isinstance(v, CharField):
  33.                 fields[k] = v
  34.         for k in fields:
  35.             del attrs[k]
  37.         # 抽离出表名称
  38.         attrs_meta = attrs.get("Meta", None)    # 关于字典 get 方法的使用，前面讲过
  39.         db_table = name.lower()     # 数据库表名默认是类的小写形式
  40.         if attrs_meta:      # 如果类存储了表信息，用类中定义的
  41.             db_table = getattr(attrs_meta, "db_table")
  43.         # 重组 attrs 参数
  44.         _meta = {"db_table":db_table}
  45.         attrs["_meta"] = _meta
  46.         attrs["fields"] = fields
  47.         del attrs["Meta"]   # 表名称信息已经获得，这里就不需要了
  49.         # 最后委托给 type ，完成类的创建
  50.         return super().__new__(cls, name, bases, attrs, **kwargs)
  53. class BaseModel(metaclass=ModelMetaClass):
  54.     # 便于通用，这里要约定初始化的一种方式
  55.     def __init__(self, *args, **kwargs):
  56.         for k, v in kwargs.items():
  57.             setattr(self, k, v)
  58.         super().__init__()
  60.     def save(self):
  61.         fields, values = [], []
  62.         for k, v in self.fields.items():
  63.             fields.append(v.db_column)
  64.             values.append(str(getattr(self, k, None)))    # 把所有的值都变成字符串，便于后面拼接
  66.         sql = "insert {table}({fields}) value({values})".format(table=self._meta["db_table"], fields=",".join(fields), values=",".join(values))
  68.         # todo 和数据库有关的逻辑
  69.         print(sql)
  71. class Person(BaseModel):
  72.     name = CharField(max_length=10, db_column="name")   # name 属性的存取检查已经完成
  74.     class Meta:
  75.         db_table = "person"     # 这个类对象和 person 这个数据库表对应
  77. me = Person(name="MetaTian")
  78. me.save()
  80. # result:
  81. # insert person(name) value(MetaTian)