属性描述符

迈不过友情╰ 2022-04-06 08:28 262阅读 0赞

# 属性描述符 #

### 文章目录 ###

*  属性描述符
 *   *  描述符
     *  描述符协议
     *  示例
     *  资料描述符与非资料描述符
     *  描述符的陷阱
     *   *  第一点：描述符必须在类的层次上（类属性）
         *  第二点：确保实例属性属于实例本身
     *  感谢

018.12.4

## 描述符 ##

在Python中，描述符作为一个用语言描述起来会有些抽象的概念。其定义有如下说法：

> 一般来说，描述符是一个具有绑定行为的对象属性，其属性的访问被描述符协议方法覆写。这些方法是\_\_get\_\_()、 **set**()和\_\_delete\_\_()，一个对象中只要包含了这三个方法（译者注：包含至少一个），就称它为描述符。

而我认为，如果可以通俗地去解释 **“为什么需要描述符”**，会让初学者更易接受这个概念。

--------------------

如果你知道Python中的property——也可能不曾听过，但你可以看我的[@property][property]——就会晓得我们可以对实例属性操作时做一些限制，比方说陌生人的姓名必须得字符串类型（这里当然会有些不严谨，因为Python中如`"512"`也是字符串类型），如果不是，就抛异常**TypeError**。代码可以如下：

class Stranger(object):
        def __init__(self, name):
            self._name = name
    
        @property
        def name(self):
            return self._name
        
        @name.setter
        def name(self, value):
            if not isinstance(value, str):
                raise TypeError("我期待一个字符串")
            else:
               self._name = value
    
    if __name__ == "__main__":
        stger = Stranger("Ying")
        stger.name = 512

运行结果如下：  
![在这里插入图片描述][20181209003814146.png]  
乍一看，上述代码似乎满足了我们的需求。其实不然，存在两个缺点。

其一，当我们初始化一个对象，就给name传int类型的参数，程序会默然允许：

if __name__ == "__main__":
        stger = Stranger(512)
        print(type(stger.name))
    
    # 输出：
    # <class 'int'>

其二，当我们需要限制的属性较多时：

class Stranger(object):
        def __init__(self, name, age, hobbies, addr, school):
            self._name = name
            self._age = age
            self._hobbies = hobbies
            ...

为了一一限制，便不得不对应的去定义 **@name.setter**，**@age.setter** … 代码怎么不优雅了？

--------------------

Python的代码需要优雅，这就是引进描述符的原因。你也可以认为描述符是property的升级版。

## 描述符协议 ##

描述符协议包含：

*  `__get__` 用于访问属性的值。当请求的属性不存在时，抛出`AttributeError`
 *  `__set__` 设置操作
 *  `__delete__` 删除操作

一个对象中只要包含了这三个方法中的一个，就称它为描述符。

## 示例 ##

import numbers
    
    
    class InterField(object):
        def __get__(self, instance, owner):
            return self.value
    
        def __set__(self, instance, value):
            if not isinstance(value, numbers.Integral):
                raise ValueError("期待一个整数")
            else:
                self.value = value
    
    
    class CharField(object):
        def __get__(self, instance, owner):
            return self.value
    
        def __set__(self, instance, value):
            if not isinstance(value, str):
                raise ValueError("期待一个字符串")
            else:
                self.value = value
    
    
    class Stranger(object):
        name = CharField()
        age = InterField()
        hobbies = CharField()
        addr = CharField()
        school = CharField()
    
        def __init__(self, name, age, hobbies, addr, school):
            self.name = name
            self.age = age
            self.hobbies = hobbies
            self.addr = addr
            self.school = school
    
    
    if __name__ == "__main__":
        stger = Stranger("Ying", 22, "music", "chengdu", "XHU")
        print(stger.name, stger.age, stger.hobbies)
    
    # 输出：
    # Ying 22 music

此时

stger = Stranger("Ying", "22", "music", "chengdu", "XHU")

![在这里插入图片描述][20181209003917266.png]  
或者

stger = Stranger("Ying", 22, "music", "chengdu", "XHU")
    stger.name = 512

![在这里插入图片描述][20181209003931495.png]

## 资料描述符与非资料描述符 ##

认为，如果一个描述符只定义了`__get__`方法，则为**非资料描述符**；如果同时定义了`__get__`和`__set__`，为**资料描述符**：

*  资料描述符：当类属性与实例属性同名时，**优先访问类属性**

class CharField(object):
        def __init__(self, value):
            self.value = value
    
        def __get__(self, instance, owner):
            return self.value
    
        # 此时，我甚至不需要对__set__添加任何逻辑
        def __set__(self, instance, value):
            pass
    
    
    class Stranger(object):
        # 这是一个资料描述符
        name = CharField("Guan")
    
        def __init__(self):
            self.name = "Ying"
    
    
    if __name__ == "__main__":
        stger = Stranger()
        print(stger.name)
    
    # 输出：
    # Guan

*  非资料描述符：当类属性与实例属性同名时，**优先访问实例属性**

class CharField(object):
        def __init__(self, value):
            self.value = value
    
        def __get__(self, instance, owner):
            return self.value
    
    
    class Stranger(object):
        # 这是一个非资料描述符
        name = CharField("Guan")
    
        def __init__(self):
            self.name = "Ying"
    
    
    if __name__ == "__main__":
        stger = Stranger()
        print(stger.name)
    
    # 输出：
    # Ying

## 描述符的陷阱 ##

### 第一点：描述符必须在类的层次上（类属性） ###

...
    class Stranger(object):
        def __init__(self):
            self.name = CharField("Guan")
    
    if __name__ == "__main__":
        stger = Stranger()
        print(stger.name)
    
    # 输出：
    # <__main__.CharField object at 0x7ff3178f1cc0>

**这是因为：只有类层次上的描述符才会默认调用\_\_get\_\_**。

### 第二点：确保实例属性属于实例本身 ###

事实上类属性是该类实例对象共有的，可参看我的[类属性与实例属性][Link 1]。所以很可能出现 **“一荣俱荣，一损俱损”** 的现象：

class CharField(object):
        def __get__(self, instance, owner):
            return self.value
    
        def __set__(self, instance, value):
            self.value = value
    
    class Stranger(object):
        name = CharField()
    
    if __name__ == "__main__":
        g = Stranger()
        g.name = "Guan"
        print(g.name)  # 输出： Guan
    
        y = Stranger()
        y.name = "Ying"
        print(g.name)  # 输出： Ying
        print(y.name)  # 输出： Ying

--------------------

**解决方案：**  
在描述符类中维护一个字典，将每个实例对象作为字典的key，而类属性对应的值作为字典的value：

class CharField(object):
        def __init__(self):
            # 一些实例使用的WeakKeyDictionary()类型字典
            # 暂时我并不能明白为什么
            self.data = dict()
    
        def __get__(self, instance, owner):
            return self.data.get(instance)
        
        # 当y.name时，instance == y
        # 当g.name时，instance == g
        def __set__(self, instance, value):
            self.data[instance] = value

这样做的缺点是，也许会碰到不可以被hash的实例，那就不能作为字典的key。常用的解决方案是：**为描述符增加标签，并通过这个标签，把本来应该访问类属性这一过程，“偷偷地”转化成访问实例属性的过程**：

class CharField(object):
        def __init__(self, label):
            self.label = label
    
        def __get__(self, instance, owner):
            return instance.__dict__.get(self.label)
    
        def __set__(self, instance, value):
    	    instance.__dict__[self.label] = value
    
    class MyList(list):
        name = CharField("NAME")

这种做的缺点是，**你可能会在没有察觉的情况下修改了name值**：

mylist = MyList()
    mylist.name = "Guan"  # 这里是name
    print(mylist.name)  # 输出： Guan
    
    mylist.NAME = "Ying"  # 这里是NAME
    print(mylist.name)  # 输出：Ying

**建议标签名最好与描述符对象的名字相同**。

--------------------

最后可以利用元类来简化这个过程：

class LabelType(type):
        def __new__(cls, name, bases, attrs):
            for k, v in attrs.items():
                if isinstance(v, CharField):
                    v.label = k  # 为描述符增加label
            return super().__new__(cls, name, bases, attrs)
    
    class CharField(object):
        def __get__(self, instance, owner):
            return instance.__dict__.get(self.label)
    
        def __set__(self, instance, value):
            instance.__dict__[self.label] = value
    
    class MyList(list, metaclass=LabelType):
        name = CharField()

如果你对元类不熟悉，不妨参看我的[元类][Link 2]。

## 感谢 ##

*  参考 [Python描述符简介][Python]
 *  参考 [【译】Python描述符指南][Python 1]
 *  参考 [解密 Python 的描述符（descriptor）][Python _descriptor]

[property]: https://blog.csdn.net/qq_41359051/article/details/82939655
[20181209003814146.png]: /images/20220406/24941e2189bf416a82725230eb8d8702.png
[20181209003917266.png]: /images/20220406/e89b1695abc848b6abf4c63a96c447f5.png
[20181209003931495.png]: /images/20220406/8b347ab5cd384bccad2684665bcc2fc1.png
[Link 1]: https://blog.csdn.net/qq_41359051/article/details/84901074
[Link 2]: https://blog.csdn.net/qq_41359051/article/details/82944905
[Python]: https://www.ibm.com/developerworks/cn/opensource/os-pythondescriptors/index.html
[Python 1]: https://harveyqing.gitbooks.io/python-read-and-write/content/python_advance/python_descriptor.html#descriptor-protocol
[Python _descriptor]: http://python.jobbole.com/81899/