我试图了解Python的描述符是什么以及它们有什么用处。我明白它们是如何运作的，但我有一些疑问。考虑下面的代码:
class Celsius(object):
def __init__(self, value=0.0):
self.value = float(value)
def __get__(self, instance, owner):
return self.value
def __set__(self, instance, value):
self.value = float(value)
class Temperature(object):
celsius = Celsius()
为什么我需要描述符类? 这里的实例和所有者是什么?(在__get__)。这些参数的目的是什么? 我如何调用/使用这个例子?
当前回答
在详细介绍描述符之前，了解Python中的属性查找是如何工作的可能很重要。这假设类没有元类，并且它使用__getattribute__的默认实现(两者都可以用于“自定义”行为)。
属性查找的最佳说明(在Python 3中)。x或Python 2.x中的新风格类)在这种情况下来自理解Python元类(ionel的代码日志)。该图像使用:来代替“不可自定义属性查找”。
这表示在Class的实例上查找一个属性foobar:
这里有两个重要的条件:
如果实例类有一个属性名条目，并且它有__get__和__set__。 如果实例中没有对应属性名的条目，但类中有，并且类中有__get__。
这就是描述符的作用:
同时具有__get__和__set__的数据描述符。 只有__get__.的非数据描述符。
在这两种情况下，返回值通过__get__调用，实例作为第一个参数，类作为第二个参数。
类属性查找的查找甚至更加复杂(参见类属性查找的示例(在上面提到的博客中))。
让我们来谈谈你的具体问题:
为什么我需要描述符类?
在大多数情况下，您不需要编写描述符类!然而，你可能是一个非常普通的终端用户。例如函数。函数是描述符，这就是函数如何作为方法使用，并将自隐式作为第一个参数传递。
def test_function(self):
return self
class TestClass(object):
def test_method(self):
...
如果你在一个实例上查找test_method，你会得到一个“bound method”:
>>> instance = TestClass()
>>> instance.test_method
<bound method TestClass.test_method of <__main__.TestClass object at ...>>
类似地，你也可以通过手动调用__get__方法来绑定一个函数(不推荐，只是为了说明目的):
>>> test_function.__get__(instance, TestClass)
<bound method test_function of <__main__.TestClass object at ...>>
你甚至可以称之为“自我约束方法”:
>>> test_function.__get__(instance, TestClass)()
<__main__.TestClass at ...>
请注意，我没有提供任何参数，该函数确实返回了我绑定的实例!
函数是非数据描述符!
数据描述符的一些内置示例是属性。忽略getter、setter和delete属性描述符是(摘自描述符HowTo指南“属性”):
class Property(object):
def __init__(self, fget=None, fset=None, fdel=None, doc=None):
self.fget = fget
self.fset = fset
self.fdel = fdel
if doc is None and fget is not None:
doc = fget.__doc__
self.__doc__ = doc
def __get__(self, obj, objtype=None):
if obj is None:
return self
if self.fget is None:
raise AttributeError("unreadable attribute")
return self.fget(obj)
def __set__(self, obj, value):
if self.fset is None:
raise AttributeError("can't set attribute")
self.fset(obj, value)
def __delete__(self, obj):
if self.fdel is None:
raise AttributeError("can't delete attribute")
self.fdel(obj)
因为它是一个数据描述符，当你查找属性的“name”时，它就会被调用，它只是委托给带有@property， @name装饰的函数。Setter和@name.deleter(如果存在)。
标准库中还有其他几种描述符，例如staticmethod、classmethod。
描述符的意义很简单(尽管您很少需要它们):抽象用于属性访问的公共代码。Property是对实例变量访问的抽象，function是对方法的抽象，staticmethod是对不需要实例访问的方法的抽象，classmethod是对需要类访问而不是实例访问的方法的抽象(这有点简化)。
另一个例子是类属性。
一个有趣的例子(使用Python 3.6中的__set_name__)也可以是只允许特定类型的属性:
class TypedProperty(object):
__slots__ = ('_name', '_type')
def __init__(self, typ):
self._type = typ
def __get__(self, instance, klass=None):
if instance is None:
return self
return instance.__dict__[self._name]
def __set__(self, instance, value):
if not isinstance(value, self._type):
raise TypeError(f"Expected class {self._type}, got {type(value)}")
instance.__dict__[self._name] = value
def __delete__(self, instance):
del instance.__dict__[self._name]
def __set_name__(self, klass, name):
self._name = name
然后你可以在类中使用描述符:
class Test(object):
int_prop = TypedProperty(int)
和它玩了一会儿:
>>> t = Test()
>>> t.int_prop = 10
>>> t.int_prop
10
>>> t.int_prop = 20.0
TypeError: Expected class <class 'int'>, got <class 'float'>
或者一个“惰性属性”:
class LazyProperty(object):
__slots__ = ('_fget', '_name')
def __init__(self, fget):
self._fget = fget
def __get__(self, instance, klass=None):
if instance is None:
return self
try:
return instance.__dict__[self._name]
except KeyError:
value = self._fget(instance)
instance.__dict__[self._name] = value
return value
def __set_name__(self, klass, name):
self._name = name
class Test(object):
@LazyProperty
def lazy(self):
print('calculating')
return 10
>>> t = Test()
>>> t.lazy
calculating
10
>>> t.lazy
10
在这些情况下，将逻辑移到公共描述符中可能是有意义的，但是也可以用其他方法解决这些问题(但可能会重复一些代码)。
这里的实例和所有者是什么?(在__get__)。这些参数的目的是什么?
这取决于您如何查找属性。如果你在一个实例上查找属性，那么:
第二个参数是用于查找属性的实例 第三个参数是实例的类
如果你在类上查找属性(假设描述符是在类上定义的):
第二个参数是None 第三个参数是用于查找属性的类
因此，如果您想在进行类级查找时自定义行为(因为实例为None)，那么基本上第三个参数是必要的。
我如何调用/使用这个例子?
你的例子基本上是一个属性，它只允许可以转换为float的值，并且在类的所有实例之间共享(并且在类上-尽管只能在类上使用“read”访问，否则你将替换描述符实例):
>>> t1 = Temperature()
>>> t2 = Temperature()
>>> t1.celsius = 20 # setting it on one instance
>>> t2.celsius # looking it up on another instance
20.0
>>> Temperature.celsius # looking it up on the class
20.0
这就是为什么描述符通常使用第二个参数(instance)来存储值，以避免共享它。然而，在某些情况下，可能需要在实例之间共享值(尽管目前我想不出具体的场景)。然而，对于温度类的celsius属性来说，这几乎没有任何意义。除了纯粹的学术练习。
其他回答
我试图理解Python的描述符是什么以及它们可以用于什么。
描述符是类名称空间中的对象，用于管理实例属性(如插槽、属性或方法)。例如:
class HasDescriptors:
__slots__ = 'a_slot' # creates a descriptor
def a_method(self): # creates a descriptor
"a regular method"
@staticmethod # creates a descriptor
def a_static_method():
"a static method"
@classmethod # creates a descriptor
def a_class_method(cls):
"a class method"
@property # creates a descriptor
def a_property(self):
"a property"
# even a regular function:
def a_function(some_obj_or_self): # creates a descriptor
"create a function suitable for monkey patching"
HasDescriptors.a_function = a_function # (but we usually don't do this)
从学理上讲，描述符是具有以下任何特殊方法的对象，这些方法可以称为“描述符方法”:
__get__:非数据描述符方法，例如在方法/函数上 __set__:数据描述符方法，例如在属性实例或插槽上 __delete__:数据描述符方法，同样由属性或插槽使用
这些描述符对象是其他对象类名称空间中的属性。也就是说，它们存在于类对象的__dict__中。
描述符对象以编程方式管理普通表达式、赋值或删除中的点查找(例如foo.descriptor)的结果。
函数/方法、绑定方法、属性、类方法和staticmethod都使用这些特殊的方法来控制如何通过点查找访问它们。
数据描述符(如属性)允许基于更简单的对象状态对属性进行延迟计算，从而允许实例使用比预先计算每个可能属性更少的内存。
另一个数据描述符是由__slots__创建的member_descriptor，通过让类将数据存储在可变的元组类数据结构中，而不是更灵活但占用空间的__dict__，可以节省内存(和更快的查找)。
非数据描述符，实例和类方法，从它们的非数据描述符方法__get__中获得它们的隐式第一个参数(通常分别命名为self和cls)——这就是静态方法如何知道不要有隐式第一个参数。
大多数Python用户只需要学习描述符的高级用法，而不需要进一步学习或理解描述符的实现。
但是了解描述符的工作原理可以让人对掌握Python更有信心。
什么是描述符?
描述符是具有以下任何方法(__get__， __set__或__delete__)的对象，旨在通过点查找来使用，就像它是实例的典型属性一样。对于带有描述符对象的所有者对象obj_instance:
obj_instance.descriptor调用 描述符。__get__(self, obj_instance, owner_class)返回一个值 这就是属性上的所有方法和get的工作方式。 Obj_instance.descriptor = value调用 描述符。__set__(self, obj_instance, value)返回None 这就是属性的setter的工作方式。 Del obj_instance.descriptor调用 描述符。__delete__(self, obj_instance)返回None 这就是属性上的删除器的工作方式。
Obj_instance是其类包含描述符对象的实例的实例。Self是描述符的实例(对于obj_instance类可能只有一个)
要用代码定义，如果一个对象的属性集与任何必需的属性相交，那么它就是一个描述符:
def has_descriptor_attrs(obj):
return set(['__get__', '__set__', '__delete__']).intersection(dir(obj))
def is_descriptor(obj):
"""obj can be instance of descriptor or the descriptor class"""
return bool(has_descriptor_attrs(obj))
数据描述符有__set__和/或__delete__。 非数据描述符既没有__set__也没有__delete__。
def has_data_descriptor_attrs(obj):
return set(['__set__', '__delete__']) & set(dir(obj))
def is_data_descriptor(obj):
return bool(has_data_descriptor_attrs(obj))
内置描述符对象示例:
classmethod staticmethod 财产 一般函数
数据描述符
我们可以看到classmethod和staticmethod是非数据描述符:
>>> is_descriptor(classmethod), is_data_descriptor(classmethod)
(True, False)
>>> is_descriptor(staticmethod), is_data_descriptor(staticmethod)
(True, False)
两者都只有__get__方法:
>>> has_descriptor_attrs(classmethod), has_descriptor_attrs(staticmethod)
(set(['__get__']), set(['__get__']))
注意，所有函数都是非数据描述符:
>>> def foo(): pass
...
>>> is_descriptor(foo), is_data_descriptor(foo)
(True, False)
数据描述符，属性
然而，属性是一个数据描述符:
>>> is_data_descriptor(property)
True
>>> has_descriptor_attrs(property)
set(['__set__', '__get__', '__delete__'])
点查找顺序
这些是重要的区别，因为它们会影响点查找的查找顺序。
obj_instance.attribute
首先，上面的代码查看属性是否是实例类上的Data-Descriptor， 如果不是，它会查看该属性是否在obj_instance的__dict__中，然后 它最终会退回到非数据描述符。
这种查找顺序的结果是，像函数/方法这样的非数据描述符可以被实例覆盖。
概述和下一步
我们已经了解到，描述符是具有__get__、__set__或__delete__中的任意一个对象。这些描述符对象可以用作其他对象类定义的属性。现在，我们将以您的代码为例，看看它们是如何使用的。
从问题分析代码
下面是你的代码，后面是你的问题和答案:
class Celsius(object):
def __init__(self, value=0.0):
self.value = float(value)
def __get__(self, instance, owner):
return self.value
def __set__(self, instance, value):
self.value = float(value)
class Temperature(object):
celsius = Celsius()
为什么我需要描述符类?
你的描述符确保你总是有一个float的class属性Temperature，并且你不能使用del删除这个属性:
>>> t1 = Temperature()
>>> del t1.celsius
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
AttributeError: __delete__
否则，您的描述符将忽略所有者类和所有者的实例，而是将状态存储在描述符中。你可以通过一个简单的class属性轻松地在所有实例之间共享状态(只要你总是将它设置为类的float，并且永远不会删除它，或者你的代码的用户愿意这样做):
class Temperature(object):
celsius = 0.0
这将使您的行为与您的示例完全相同(参见下面对问题3的响应)，但使用了python的内置(属性)，并且将被认为更习惯:
class Temperature(object):
_celsius = 0.0
@property
def celsius(self):
return type(self)._celsius
@celsius.setter
def celsius(self, value):
type(self)._celsius = float(value)
这里的实例和所有者是什么?(得到)。这些参数的目的是什么?
Instance是调用描述符的所有者的实例。所有者是一个类，其中描述符对象用于管理对数据点的访问。关于更多描述性变量名，请参阅本答案第一段旁边定义描述符的特殊方法的描述。
我如何调用/使用这个例子?
下面是一个演示:
>>> t1 = Temperature()
>>> t1.celsius
0.0
>>> t1.celsius = 1
>>>
>>> t1.celsius
1.0
>>> t2 = Temperature()
>>> t2.celsius
1.0
你不能删除属性:
>>> del t2.celsius
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
AttributeError: __delete__
你不能给一个不能被转换成浮点数的变量赋值:
>>> t1.celsius = '0x02'
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
File "<stdin>", line 7, in __set__
ValueError: invalid literal for float(): 0x02
否则，您在这里拥有的是所有实例的全局状态，它通过分配给任何实例来管理。
大多数有经验的Python程序员实现这一结果的预期方式是使用属性装饰器，它在底层使用相同的描述符，但将行为带入所有者类的实现中(同样，如上所定义):
class Temperature(object):
_celsius = 0.0
@property
def celsius(self):
return type(self)._celsius
@celsius.setter
def celsius(self, value):
type(self)._celsius = float(value)
它具有与原始代码完全相同的预期行为:
>>> t1 = Temperature()
>>> t2 = Temperature()
>>> t1.celsius
0.0
>>> t1.celsius = 1.0
>>> t2.celsius
1.0
>>> del t1.celsius
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
AttributeError: can't delete attribute
>>> t1.celsius = '0x02'
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
File "<stdin>", line 8, in celsius
ValueError: invalid literal for float(): 0x02
结论
我们已经讨论了定义描述符的属性、数据描述符和非数据描述符之间的区别、使用它们的内置对象以及关于使用的特定问题。
那么，你会怎么用这个问题的例子呢?我希望你不会。我希望您从我的第一个建议(一个简单的类属性)开始，如果您认为有必要，可以转向第二个建议(属性装饰器)。
描述符是Python的属性类型是如何实现的。描述符简单地实现__get__， __set__等，然后在它的定义中添加到另一个类(就像上面对Temperature类所做的那样)。例如:
temp=Temperature()
temp.celsius #calls celsius.__get__
访问您分配给描述符的属性(在上面的例子中是celsius)将调用适当的描述符方法。
__get__中的instance是类的实例(因此在上面，__get__将接收temp，而owner是带有描述符的类(因此它将是Temperature)。
您需要使用一个描述符类来封装为其提供支持的逻辑。这样，如果描述符用于缓存一些昂贵的操作(例如)，它可以将值存储在自己而不是它的类上。
一篇关于描述符的文章可以在这里找到。
编辑:正如jchl在评论中指出的，如果您只是尝试Temperature。摄氏度，实例将为None。
为什么我需要描述符类?
它为您提供了对属性如何工作的额外控制。例如，如果你习惯了Java中的getter和setter，那么Python就是这样做的。一个优点是它看起来就像一个属性(语法上没有变化)。因此，您可以从一个普通属性开始，然后，当您需要做一些奇特的事情时，切换到一个描述符。
属性只是一个可变值。描述符允许您在读取或设置(或删除)值时执行任意代码。因此，您可以想象使用它来将一个属性映射到数据库中的一个字段，例如—一种ORM。
另一种用法可能是通过在__set__中抛出异常来拒绝接受新值——有效地使“属性”为只读。
这里的实例和所有者是什么?(在__get__)。这些参数的目的是什么?
这是非常微妙的(我在这里写一个新答案的原因是——我在想同样的事情时发现了这个问题，并没有发现现有的答案那么好)。
描述符定义在类上，但通常从实例调用。当从实例中调用它时，实例和所有者都被设置了(你可以从实例中计算出所有者，所以看起来有点毫无意义)。但是当从类中调用时，只设置了owner -这就是为什么它在那里。
这只需要__get__，因为它是唯一一个可以在类上调用的。如果你设置了类值，你就设置了描述符本身。删除也是如此。这就是为什么这里不需要所有者。
我如何调用/使用这个例子?
这里有一个使用类似类的很酷的技巧:
class Celsius:
def __get__(self, instance, owner):
return 5 * (instance.fahrenheit - 32) / 9
def __set__(self, instance, value):
instance.fahrenheit = 32 + 9 * value / 5
class Temperature:
celsius = Celsius()
def __init__(self, initial_f):
self.fahrenheit = initial_f
t = Temperature(212)
print(t.celsius)
t.celsius = 0
print(t.fahrenheit)
(我使用的是Python 3;对于python 2，你需要确保这些分区是/ 5.0和/ 9.0)。出:
100.0
32.0
现在，在python中还有其他更好的方法来实现同样的效果(例如，如果celsius是一个属性，这是相同的基本机制，但将所有源放在Temperature类中)，但这表明可以做什么…
在详细介绍描述符之前，了解Python中的属性查找是如何工作的可能很重要。这假设类没有元类，并且它使用__getattribute__的默认实现(两者都可以用于“自定义”行为)。
属性查找的最佳说明(在Python 3中)。x或Python 2.x中的新风格类)在这种情况下来自理解Python元类(ionel的代码日志)。该图像使用:来代替“不可自定义属性查找”。
这表示在Class的实例上查找一个属性foobar:
这里有两个重要的条件:
如果实例类有一个属性名条目，并且它有__get__和__set__。 如果实例中没有对应属性名的条目，但类中有，并且类中有__get__。
这就是描述符的作用:
同时具有__get__和__set__的数据描述符。 只有__get__.的非数据描述符。
在这两种情况下，返回值通过__get__调用，实例作为第一个参数，类作为第二个参数。
类属性查找的查找甚至更加复杂(参见类属性查找的示例(在上面提到的博客中))。
让我们来谈谈你的具体问题:
为什么我需要描述符类?
在大多数情况下，您不需要编写描述符类!然而，你可能是一个非常普通的终端用户。例如函数。函数是描述符，这就是函数如何作为方法使用，并将自隐式作为第一个参数传递。
def test_function(self):
return self
class TestClass(object):
def test_method(self):
...
如果你在一个实例上查找test_method，你会得到一个“bound method”:
>>> instance = TestClass()
>>> instance.test_method
<bound method TestClass.test_method of <__main__.TestClass object at ...>>
类似地，你也可以通过手动调用__get__方法来绑定一个函数(不推荐，只是为了说明目的):
>>> test_function.__get__(instance, TestClass)
<bound method test_function of <__main__.TestClass object at ...>>
你甚至可以称之为“自我约束方法”:
>>> test_function.__get__(instance, TestClass)()
<__main__.TestClass at ...>
请注意，我没有提供任何参数，该函数确实返回了我绑定的实例!
函数是非数据描述符!
数据描述符的一些内置示例是属性。忽略getter、setter和delete属性描述符是(摘自描述符HowTo指南“属性”):
class Property(object):
def __init__(self, fget=None, fset=None, fdel=None, doc=None):
self.fget = fget
self.fset = fset
self.fdel = fdel
if doc is None and fget is not None:
doc = fget.__doc__
self.__doc__ = doc
def __get__(self, obj, objtype=None):
if obj is None:
return self
if self.fget is None:
raise AttributeError("unreadable attribute")
return self.fget(obj)
def __set__(self, obj, value):
if self.fset is None:
raise AttributeError("can't set attribute")
self.fset(obj, value)
def __delete__(self, obj):
if self.fdel is None:
raise AttributeError("can't delete attribute")
self.fdel(obj)
因为它是一个数据描述符，当你查找属性的“name”时，它就会被调用，它只是委托给带有@property， @name装饰的函数。Setter和@name.deleter(如果存在)。
标准库中还有其他几种描述符，例如staticmethod、classmethod。
描述符的意义很简单(尽管您很少需要它们):抽象用于属性访问的公共代码。Property是对实例变量访问的抽象，function是对方法的抽象，staticmethod是对不需要实例访问的方法的抽象，classmethod是对需要类访问而不是实例访问的方法的抽象(这有点简化)。
另一个例子是类属性。
一个有趣的例子(使用Python 3.6中的__set_name__)也可以是只允许特定类型的属性:
class TypedProperty(object):
__slots__ = ('_name', '_type')
def __init__(self, typ):
self._type = typ
def __get__(self, instance, klass=None):
if instance is None:
return self
return instance.__dict__[self._name]
def __set__(self, instance, value):
if not isinstance(value, self._type):
raise TypeError(f"Expected class {self._type}, got {type(value)}")
instance.__dict__[self._name] = value
def __delete__(self, instance):
del instance.__dict__[self._name]
def __set_name__(self, klass, name):
self._name = name
然后你可以在类中使用描述符:
class Test(object):
int_prop = TypedProperty(int)
和它玩了一会儿:
>>> t = Test()
>>> t.int_prop = 10
>>> t.int_prop
10
>>> t.int_prop = 20.0
TypeError: Expected class <class 'int'>, got <class 'float'>
或者一个“惰性属性”:
class LazyProperty(object):
__slots__ = ('_fget', '_name')
def __init__(self, fget):
self._fget = fget
def __get__(self, instance, klass=None):
if instance is None:
return self
try:
return instance.__dict__[self._name]
except KeyError:
value = self._fget(instance)
instance.__dict__[self._name] = value
return value
def __set_name__(self, klass, name):
self._name = name
class Test(object):
@LazyProperty
def lazy(self):
print('calculating')
return 10
>>> t = Test()
>>> t.lazy
calculating
10
>>> t.lazy
10
在这些情况下，将逻辑移到公共描述符中可能是有意义的，但是也可以用其他方法解决这些问题(但可能会重复一些代码)。
这里的实例和所有者是什么?(在__get__)。这些参数的目的是什么?
这取决于您如何查找属性。如果你在一个实例上查找属性，那么:
第二个参数是用于查找属性的实例 第三个参数是实例的类
如果你在类上查找属性(假设描述符是在类上定义的):
第二个参数是None 第三个参数是用于查找属性的类
因此，如果您想在进行类级查找时自定义行为(因为实例为None)，那么基本上第三个参数是必要的。
我如何调用/使用这个例子?
你的例子基本上是一个属性，它只允许可以转换为float的值，并且在类的所有实例之间共享(并且在类上-尽管只能在类上使用“read”访问，否则你将替换描述符实例):
>>> t1 = Temperature()
>>> t2 = Temperature()
>>> t1.celsius = 20 # setting it on one instance
>>> t2.celsius # looking it up on another instance
20.0
>>> Temperature.celsius # looking it up on the class
20.0
这就是为什么描述符通常使用第二个参数(instance)来存储值，以避免共享它。然而，在某些情况下，可能需要在实例之间共享值(尽管目前我想不出具体的场景)。然而，对于温度类的celsius属性来说，这几乎没有任何意义。除了纯粹的学术练习。
我尝试了Andrew Cooke回答的代码(根据建议做了一些小修改)。(我正在运行python 2.7)。
代码:
#!/usr/bin/env python
class Celsius:
def __get__(self, instance, owner): return 9 * (instance.fahrenheit + 32) / 5.0
def __set__(self, instance, value): instance.fahrenheit = 32 + 5 * value / 9.0
class Temperature:
def __init__(self, initial_f): self.fahrenheit = initial_f
celsius = Celsius()
if __name__ == "__main__":
t = Temperature(212)
print(t.celsius)
t.celsius = 0
print(t.fahrenheit)
结果:
C:\Users\gkuhn\Desktop>python test2.py
<__main__.Celsius instance at 0x02E95A80>
212
使用Python在3之前，确保你的子类from object将使描述符正确工作，因为get魔法不适用于旧风格的类。
