我试图了解 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()
为什么我需要描述符类？
什么是instance和owner这里？（在__get__）。这些参数的目的是什么？
我将如何调用/使用这个例子？
描述符是 Python 的property类型是如何实现的。描述符简单地实现__get__,__set__等，然后在其定义中添加到另一个类（就像您在上面对 Temperature 类所做的那样）。例如：
temp=Temperature()
temp.celsius #calls celsius.__get__
访问您将描述符分配给的属性（celsius在上面的示例中）调用适当的描述符方法。
instancein__get__是类的实例（所以上面__get__会收到temp，owner而是带有描述符的类（所以它会Temperature）。
您需要使用描述符类来封装支持它的逻辑。这样，如果描述符用于缓存一些昂贵的操作（例如），它可以将值存储在自身而不是其类上。
可以在此处找到有关描述符的文章。
编辑：正如 jchl 在评论中指出的那样，如果你只是尝试Temperature.celsius，instance将会是None.
为什么我需要描述符类？
它使您可以额外控制属性的工作方式。例如，如果您习惯于 Java 中的 getter 和 setter，那么这是 Python 的做法。一个优点是它在用户看来就像一个属性（语法没有变化）。所以你可以从一个普通的属性开始，然后，当你需要做一些花哨的事情时，切换到一个描述符。
属性只是一个可变值。描述符允许您在读取或设置（或删除）值时执行任意代码。因此，您可以想象使用它将属性映射到数据库中的字段，例如——一种 ORM。
另一种用途可能是通过抛出异常来拒绝接受新值__set__——有效地使“属性”只读。
什么是
instance和owner这里？（在__get__）。这些参数的目的是什么？
这是非常微妙的（也是我在这里写一个新答案的原因 - 我在想同样的事情时发现了这个问题并且没有找到很好的现有答案）。
描述符是在类上定义的，但通常是从实例中调用的。当它从一个实例调用instance并被owner设置时（你可以从中解决owner，instance所以看起来有点毫无意义）。但是当从一个类中调用时，onlyowner被设置——这就是它存在的原因。
这是唯一需要的，__get__因为它是唯一可以在类上调用的。如果设置类值，则设置描述符本身。同样用于删除。这就是为什么owner那里不需要。
我将如何调用/使用这个例子？
好吧，这是使用类似类的一个很酷的技巧：
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.0and / 9.0）。这给出了：
100.0
32.0
现在还有其他可以说更好的方法在 python 中实现相同的效果（例如，如果 celsius 是一个属性，这是相同的基本机制，但将所有源放在 Temperature 类中），但这表明可以做什么......
我试图了解 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普通表达式、赋值或删除中的点查找（例如）的结果。
函数/方法、绑定方法、、property等都使用这些特殊方法来控制如何通过点分查找来访问它们。classmethodstaticmethod
数据描述符，如property，可以允许基于对象的更简单状态对属性进行延迟评估，与预先计算每个可能的属性相比，允许实例使用更少的内存。
另一个数据描述符由.member_descriptor创建，通过__slots__让类将数据存储在类似元组的可变数据结构中而不是更灵活但占用空间的__dict__.
非数据描述符、实例和类方法从它们的非数据描述符方法中获取它们的隐式第一个参数（通常分别命名为self和） ，这就是静态方法知道没有隐式第一个参数的方式。cls__get__
大多数 Python 用户只需要学习描述符的高级用法，不需要进一步学习或理解描述符的实现。
但是了解描述符的工作原理可以让人们对自己掌握 Python 更有信心。
描述符是具有以下任何方法（ 、 或 ）的对象__get__，__set__旨在__delete__通过点查找来使用，就好像它是实例的典型属性一样。对于所有者对象，obj_instance，带有descriptor对象：
obj_instance.descriptor调用
descriptor.__get__(self, obj_instance, owner_class)返回 avalue
这是所有方法和geton 属性的工作方式。
obj_instance.descriptor = value调用
descriptor.__set__(self, obj_instance, value)返回None
这就是setteron 属性的工作方式。
del obj_instance.descriptor调用
descriptor.__delete__(self, obj_instance)返回None
这就是deleteron 属性的工作方式。
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))
classmethodstaticmethodproperty我们可以看到，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)
property然而，property是一个数据描述符：
>>> is_data_descriptor(property)
True
>>> has_descriptor_attrs(property)
set(['__set__', '__get__', '__delete__'])
这些是重要的区别，因为它们会影响点查找的查找顺序。
obj_instance.attribute
obj_instance's__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()
- 为什么我需要描述符类？
您的描述符确保您始终拥有此类属性的浮点数Temperature，并且您不能使用它del来删除该属性：
>>> t1 = Temperature()
>>> del t1.celsius
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
AttributeError: __delete__
否则，您的描述符会忽略所有者的所有者类和实例，而是将状态存储在描述符中。您可以使用简单的类属性轻松地在所有实例之间共享状态（只要您始终将其设置为类的浮点数并且从不删除它，或者对您的代码的用户这样做感到满意）：
class Temperature(object):
celsius = 0.0
这使您的行为与您的示例完全相同（请参阅下面对问题 3 的回复），但使用 Pythons 内置函数 ( property)，并且会被认为更惯用：
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 程序员实现此结果的预期方式是使用property装饰器，它在底层使用相同的描述符，但将行为带入所有者类的实现中（再次，如上定义）：
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 中的属性查找是如何工作的可能很重要。这假设该类没有元类并且它使用默认实现__getattribute__（两者都可以用于“自定义”行为）。
在这种情况下，属性查找（在 Python 3.x 中或对于 Python 2.x 中的新型类）的最佳说明来自Understanding Python metaclasses（ionel's codelog）。该图像:用作“不可自定义的属性查找”的替代品。
这表示在offoobar上查找属性：instanceClass
这里有两个重要的条件：
instance具有属性名称的条目并且具有__get__和__set__。instance没有属性名称条目，但类有一个并且它有__get__.这就是描述符进入它的地方：
__get__和的数据描述符__set__。__get__. _在这两种情况下，返回的值都会__get__以实例作为第一个参数，类作为第二个参数进行调用。
类属性查找的查找更加复杂（参见例如类属性查找（在上述博客中））。
让我们转到您的具体问题：
为什么我需要描述符类？
在大多数情况下，您不需要编写描述符类！但是，您可能是一个非常普通的最终用户。例如函数。函数是描述符，这就是函数可以用作self隐式传递作为第一个参数的方法的方式。
def test_function(self):
return self
class TestClass(object):
def test_method(self):
...
如果你查看test_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 ...>
请注意，我没有提供任何参数，并且该函数确实返回了我绑定的实例！
函数是非数据描述符！
数据描述符的一些内置示例是property. 忽略getter,setter和描述deleter符property（来自Descriptor HowTo Guide “Properties”）：
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)
因为它是一个数据描述符，每当您查找 的“名称”时都会调用它property，它只是委托给用 、 和 （如果存在）装饰@property的@name.setter函数@name.deleter。
staticmethod标准库中还有其他几个描述符，例如classmethod.
描述符的要点很简单（尽管您很少需要它们）：用于属性访问的抽象公共代码。property是实例变量访问function的抽象，为方法staticmethod提供抽象，为不需要实例访问classmethod的方法提供抽象，为需要类访问而不是实例访问的方法提供抽象（这有点简化）。
另一个例子是类属性。
一个有趣的例子（使用__set_name__Python 3.6）也可以是只允许特定类型的属性：
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
在这些情况下，将逻辑移动到一个通用描述符中可能是有意义的，但是也可以通过其他方式解决它们（但可能需要重复一些代码）。
什么是
instance和owner这里？（在__get__）。这些参数的目的是什么？
这取决于您如何查找属性。如果您在实例上查找属性，则：
如果您在类上查找属性（假设描述符是在类上定义的）：
None因此，如果您想在进行类级别查找时自定义行为（因为instanceis None），那么基本上第三个参数是必要的。
我将如何调用/使用这个例子？
您的示例基本上是一个属性，它只允许可以转换为float并且在类的所有实例之间共享的值（以及在类上 - 尽管只能在类上使用“读取”访问权限，否则您将替换描述符实例):
>>> 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) 来存储值以避免共享它的原因。然而，在某些情况下，可能需要在实例之间共享一个值（尽管我现在想不出一个场景）。然而，对于温度等级的摄氏度属性几乎没有任何意义......除了可能是纯粹的学术练习。
为什么我需要描述符类？
灵感来自Buciano Ramalho的Fluent Python
想象你有这样的课
class LineItem:
price = 10.9
weight = 2.1
def __init__(self, name, price, weight):
self.name = name
self.price = price
self.weight = weight
item = LineItem("apple", 2.9, 2.1)
item.price = -0.9 # it's price is negative, you need to refund to your customer even you delivered the apple :(
item.weight = -0.8 # negative weight, it doesn't make sense
我们应该验证权重和价格以避免给它们分配负数，如果我们使用描述符作为代理，我们可以编写更少的代码，因为这样
class Quantity(object):
__index = 0
def __init__(self):
self.__index = self.__class__.__index
self._storage_name = "quantity#{}".format(self.__index)
self.__class__.__index += 1
def __set__(self, instance, value):
if value > 0:
setattr(instance, self._storage_name, value)
else:
raise ValueError('value should >0')
def __get__(self, instance, owner):
return getattr(instance, self._storage_name)
然后像这样定义类 LineItem ：
class LineItem(object):
weight = Quantity()
price = Quantity()
def __init__(self, name, weight, price):
self.name = name
self.weight = weight
self.price = price
我们可以扩展 Quantity 类来做更常见的验证
__get__ & __set__ & __call__ 课堂上的解释，什么是Owner, Instance？__get__ __set__被称为类的描述符来工作/保存它们的内部属性，即：（__name__类/所有者类的名称），变量 -__dict__等等。我稍后会解释什么是所有者class Method:
def __init__(self, name):
self.name = name
def __call__(self, instance, arg1, arg2):
print(f"{self.name}: {instance} called with {arg1} and {arg2}")
class MyClass:
method = Method("Internal call")
instance = MyClass()
instance.method("first", "second")
# Prints:TypeError: __call__() missing 1 required positional argument: 'arg2'
因此，当instance.method("first", "second")被调用时，__call__从 Method 类调用方法（调用方法使类对象像函数一样可调用 - 每当调用类实例时都会被实例__call__化），并分配以下参数: instance: "first", arg1: "second"，最后一个 arg2 被省略，这会打印出错误：TypeError: __call__() missing 1 required positional argument: 'arg2'
由于作为第__call__一个instance参数（实例，arg1，arg2），但是instance什么？
Instance是调用描述符类（方法）的主类（MyClass）的实例。那么，instance = MyClass()是instance，所以谁是owner？持有描述符类的类 - MyClass，但是，我们的描述符类中没有方法(Method)可以将其识别为instance. 这就是我们需要__get__ 方法的地方。再次考虑下面的代码：
from types import MethodType
class Method:
def __init__(self, name):
self.name = name
def __call__(self, instance, arg1, arg2):
print(f"{self.name}: {instance} called with {arg1} and {arg2}")
def __set__(self, instance, value):
self.value = value
instance.__dict__["method"] = value
def __get__(self, instance, owner):
if instance is None:
return self
print (instance, owner)
return MethodType(self, instance)
class MyClass:
method = Method("Internal call")
instance = MyClass()
instance.method("first", "second")
# Prints: Internal call: <__main__.MyClass object at 0x7fb7dd989690> called with first and second
根据文档暂时忘记设置：
__get__“调用以获取所有者类的属性（类属性访问）或该类的实例（实例属性访问）。”如果你这样做：instance.method.__get__(instance)
Prints:<__main__.MyClass object at 0x7fb7dd9eab90> <class '__main__.MyClass'>
这意味着实例：它的对象MyClassisinstance
和OwnerisMyClass本身
__set__、说明：__set__用于在类__dict__对象中设置一些值（假设使用命令行）。用于设置set内部值的命令是：instance.descriptor = 'value'#method在这种情况下，描述符是（instance.__dict__["method"] = value在代码中只是更新__dict__描述符的对象）
这样做：instance.method = 'value'现在检查是否在方法value = 'value'中设置了__set__我们可以访问__dict__描述符的对象method。做：
instance.method.__dict__打印：{'_name': 'Internal call', 'value': 'value'}
或者您可以使用
prints检查__dict__值：
我希望现在一切都清楚了:)vars(instance.method){'name': 'Internal call', 'value': 'value'}
你会看到https://docs.python.org/3/howto/descriptor.html#properties
class Property(object):
"Emulate PyProperty_Type() in Objects/descrobject.c"
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)
def getter(self, fget):
return type(self)(fget, self.fset, self.fdel, self.__doc__)
def setter(self, fset):
return type(self)(self.fget, fset, self.fdel, self.__doc__)
def deleter(self, fdel):
return type(self)(self.fget, self.fset, fdel, self.__doc__)
我尝试了（按照建议进行了细微更改）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
使用 3 之前的 Python，请确保您从 object 子类化，这将使描述符正常工作，因为get魔法不适用于旧式类。