什么是实现描述符的正确方法？

Question

考虑此代码：运行 on python 3.6

Bar 赋值给描述符实例

Bat 将值分配给包含 class 的实例。

我见过的代码示例（并且习惯了我无尽的挫败感）使用 Bar 示例。比如这个site

来自 python docs

从使用 Bar 示例的输出可以看出，class 的两个实例不能使用相同的描述符。

还是我遗漏了什么？

class DescriptorA(object):
    value = None
    def __get__(self, instance, owner):
        return self.value

    def __set__(self, instance, value):
        self.value = value

class DescriptorB(object):
    _value = None
    def __get__(self, instance, owner):
        return instance._value

    def __set__(self, instance, value):
        instance._value = value


class Bar(object):
    foo = DescriptorA()
    def __init__(self, foo):
        self.foo = foo

class Bat(object):
    foo = DescriptorB()
    def __init__(self, foo):
        self.foo = foo


print('BAR')
a = Bar(1)
print('a', a.foo)

b = Bar(2)
print('b', b.foo)
print('Checking a')
print('a', a.foo)

print('BAT')
c = Bat(3)
print('c', c.foo)

d = Bat(4)
print('d', d.foo)
print('Checking c')
print('c', c.foo)

输出

BAR
a 1
b 2
Checking a
a 2
BAT
c 3
d 4
Checking c
c 3

更新

只是想补充一下。为了回应好的答案。当不使用描述符，但仍然使用 class 属性时。我们得到不同的行为。这就是为什么我犯了使用 DescriptorA 的错误。

class Bar(object):
    foo = None
    def __init__(self, foo):
        self.foo = foo

class Bat(object):
    foo = None
    def __init__(self, foo):
        self.foo = foo


print('BAR')
a = Bar(1)
print('a', a.foo)

b = Bar(2)
print('b', b.foo)
print('Checking a')
print('a', a.foo)

print('BAT')
c = Bat(3)
print('c', c.foo)

d = Bat(4)
print('d', d.foo)
print('Checking c')
print('c', c.foo)

BAR
a 1
b 2
Checking a
a 1
BAT
c 3
d 4
Checking c
c 3

Answer 1

一个描述符在 class 级别定义，并且在 class 中只有该描述符的一个实例。因此，在第一个描述符中，即 DescriptorA，您将值作为变量存储在描述符上，而不是 instance 对象上。显然，当您实例化另一个实例时，该值将被覆盖。

您在描述符中存储的任何值对于分配给描述符的 class 的所有实例都将保持不变。这就是 DescriptorB 起作用的原因，并且是使用描述符而不是第一个描述符的正确方法，除非您的用例需要变量，这些变量应该在各个实例中保持不变。

Answer 2

描述符是 class 属性（它们必须是描述符协议才能工作）。作为 class 属性意味着 class 的所有实例共享一个描述符实例（并且它是子 classes），所以你观察到 class Bar 和 DescriptorA 是预期的行为。

这并不意味着 "two instances of a class can't use the same descriptor (instance)" - 他们确实这样做了，这就是为什么你有这种行为 - 但你不能在你的描述符实例上存储每个实例的值，至少不是那么简单。

一个可能的解决方案是在您的描述符中维护一个 id(instance):instance_value 映射，即：

class DescriptorA(object):
    def __init__(self, default=None):
        self._values = {}
        self._default = default
    def __get__(self, instance, cls):
        if instance is None:
            return self
        return self._values.get(id(instance), self._default)
    def __set__(self, instance, value):
        self._values[id(instance)] = value

但这有很多缺点，第一个明显的缺点是当实例被垃圾收集时，您的 _values dict 不会被清除。它可能最终会在一个漫长的运行过程中吃掉相当多的 ram...

编辑：更新中的代码是 而不是 使用 class 属性。具有同名 class 属性在这里无关紧要 - 初始化程序设置了一个 value instance 属性，它隐藏了 class 级别的属性（实际上从来没有在您的代码片段中使用）。

如果你想要一个具有 class 属性的有意义的例子，使用一个可变对象并改变它而不是创建一个实例属性：

>>> class Foo(object):
...    bar = []
...    def __init__(self, baaz):
...        self.baaz = baaz
...        self.bar.append(baaz)
... 
>>> f1 = Foo("foo1")
>>> f1.baaz
'foo1'
>>> f1.bar
['foo1']
>>> f2 = Foo("foo2")
>>> f1.baaz
'foo1'
>>> f2.baaz
'foo2'
>>> f1.bar
['foo1', 'foo2']
>>> f2.bar
['foo1', 'foo2']
>>>

Answer 3

这实际上取决于您的用例如何存储变量。

我们有 4 个对象，每个对象都有自己的一组变量：

描述符class
描述符的实例
正常class
正常实例class

通常描述符实例存储在 "normal class" 中，因为在实例中存储描述符时不会调用描述符协议。您还可以 "go meta" 并在 metaclasses 上使用描述符或在描述符中使用描述符，但为了保持简短和理智，让我们忽略这些（这并不难，但可能有点太宽泛了）。

因此，如果您 DescriptorA 您存储：

value = None 描述符 class
value = ?在描述符实例中（至少在调用__set__之后至少一次
foo = descriptor instance 正常 class
class 实例中没有任何内容

在 DescriptorB 的情况下，您存储：

_value = None 描述符 class
描述符实例中没有任何内容
foo = descriptor instance 正常 class
_value = ? 在你正常的实例中 class

看出区别了吗？在第一种情况下，正常 class 的不同实例访问相同的描述符实例，因此所有内容都是共享的。在第二种情况下，您将所有内容都存储在 class 的实例中，而在描述符实例中没有任何内容，因此不会共享任何内容。

请注意，您的 DescriptorB 看起来很奇怪，为什么在您从不使用它的情况下将 _value = None 存储在描述符 class 中？请记住，您访问的是普通 class 实例的 _value，而不是 __get__!

中描述符实例的 _value

正如我之前所说，选择哪种方法取决于您的用例。通常您希望拥有一些共享属性和一些实例属性。但是您也可以在描述符的所有实例之间共享属性，并且假设您还可以在 __get__ 中访问普通 class 实例的类型并在 __set__ 中使用 type(instance) 你还可以修改 class 普通 class.

的属性

例如 Python 文档中的示例：

class RevealAccess(object):
    """A data descriptor that sets and returns values
       normally and prints a message logging their access.
    """

    def __init__(self, initval=None, name='var'):
        self.val = initval
        self.name = name

    def __get__(self, obj, objtype):
        print('Retrieving', self.name)
        return self.val

    def __set__(self, obj, val):
        print('Updating', self.name)
        self.val = val

>>> class MyClass(object):
...     x = RevealAccess(10, 'var "x"')
...     y = 5
...

他们故意为 class 变量 创建了一个描述符。在那种情况下，就没有 "instance" 并且它是否被共享并不重要，因为默认情况下 class 变量将由实例共享。这意味着即使您在一个实例上设置变量，它也会为所有其他实例发生变化。

因此，如果您不想共享描述符实例变量，则不应真正使用它。但是，您应该将它们用于应该共享的所有内容（例如属性的 name 等）。

可能也很有趣的是 "way" Python 查找属性。我通常会发现这张来自 this blog 的图片非常有用：

什么是实现描述符的正确方法？

Whats the correct way to implement a descriptor?

python

descriptor