理解 __get__ 和 __set__ 以及 Python 描述符

Question

我试图了解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()

1. 为什么我需要描述符类？

2. 这里的实例和所有者是什么？ （在__get__中）。这些参数的用途是什么？

3. 我如何调用/使用这个例子？

Answer 1

描述符是 Python 的 property 类型的实现方式。描述符只需实现__get__、__set__等，然后添加到其定义中的另一个类中（就像上面对Temperature类所做的那样）。例如：

temp=Temperature()
temp.celsius #calls celsius.__get__

访问您为其分配描述符的属性（上例中的celsius）会调用适当的描述符方法。

__get__ 中的 instance 是类的实例（因此上面的 __get__ 将接收 temp，而 Owner 是具有描述符的类（因此它是 Temperature）。

您需要使用描述符类来封装支持它的逻辑，这样，如果描述符用于。缓存一些昂贵的操作（例如），它可以将值存储在其自身上而不是其类上。

官方Python文档包含一个关于描述符的文章，更详细地介绍了它们的工作原理，包括几个示例：

编辑：正如 jchl 在评论中指出的，如果您只是尝试 Temperature.celsius，实例将为无。

Answer 2

为什么我需要描述符类？

它使您可以额外控制属性的工作方式。例如，如果您习惯了 Java 中的 getter 和 setter，那么 Python 就是这样做的。一个优点是它对用户来说就像一个属性（语法没有变化）。因此，您可以从普通属性开始，然后当您需要做一些奇特的事情时，切换到描述符。

属性只是一个可变值。描述符允许您在读取或设置（或删除）值时执行任意代码。因此，您可以想象使用它来将属性映射到数据库中的字段，例如，一种 ORM。

另一种用途可能是通过在 __set__ 中抛出异常来拒绝接受新值 - 有效地使“属性”只读。

这里的实例和所有者是什么？ （在__get__中）。这些参数的目的是什么？

这是非常微妙的（也是我在这里写一个新答案的原因 - 我在想知道同样的事情时发现了这个问题，但没有发现现有的答案那么好）。

描述符在类上定义，但通常从实例调用。当从实例调用它时，instance 和 owner 都会被设置（并且您可以从 instance 计算出 owner，因此似乎有点毫无意义）。但是当从类中调用时，只有 owner 被设置 - 这就是它存在的原因。

只有 __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.0 和 / 9.0）。这给出了：

100.0
32.0

现在还有其他可以说更好的方法来在 python 中实现相同的效果（例如，如果 celsius 是一个属性，这是相同的基本机制，但将所有源放在Temperature类中），但这显示了可以做什么...

Answer 3

我试图了解 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）的结果。

函数/方法、绑定方法、属性、类方法和静态方法都使用这些特殊方法来控制如何通过点查找来访问它们。

数据描述符，例如属性，可以允许基于对象的更简单状态对属性进行惰性评估，从而允许实例使用比预先计算每个可能的属性更少的内存。

另一个数据描述符，由__slots__创建的member_descriptor ，通过让类将数据存储在可变的类似元组的数据结构中，而不是更灵活但占用空间的 __dict__ 中，可以节省内存（并加快查找速度）。

非数据描述符、实例和类方法从其非数据描述符方法 __get__ 获取其隐式第一个参数（通常分别命名为 self 和 cls） - 这就是静态方法知道没有隐式第一个参数的方式。

大多数Python用户只需要学习描述符的高级用法，而无需进一步学习或理解描述符的实现。

但了解描述符的工作原理可以让人们对自己掌握 Python 更有信心。

深入：什么是描述符？

描述符是具有以下任何方法（__get__、__set__ 或 __delete__）的对象，旨在通过点式查找用作如果它是一个实例的典型属性。对于具有 descriptor 对象的所有者对象 obj_instance：

• obj_instance.descriptor 调用
  descriptor.__get__(self, obj_instance, Owner_class) 返回一个值
  这就是属性上的所有方法和 get 的工作方式。

• obj_instance.descriptor = value 调用
  descriptor.__set__(self, obj_instance, value) 返回None
  这就是属性上的 setter 的工作原理。

• del obj_instance.descriptor 调用
  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))

A 数据描述符有一个__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
• property
• 一般

非数据描述

函数我们可以看到 classmethod 和 < code>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

1. 首先，上面查看该属性是否是实例类上的数据描述符，
2. 如果不是，则查看该属性是否在 obj_instance 的 __dict__，然后
3. 它最终回到非数据描述符。

这种查找顺序的结果是像函数/方法这样的非数据描述符可以被实例覆盖。

回顾和后续步骤

我们已经了解到，描述符是具有 __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()

1. 为什么需要描述符类？

您的描述符确保 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 的回复），但使用 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)

这里的实例和所有者是什么？ （在获取中）。这些参数的用途是什么？

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

结论

我们已经介绍了定义描述符的属性，数据描述符和非数据描述符之间的差异，使用它们的内置对象，以及有关使用的具体问题。

那么，您将如何使用问题的示例？我希望你不会。我希望您从我的第一个建议（一个简单的类属性）开始，如果您认为有必要，请继续讨论第二个建议（属性装饰器）。

Answer 4

在深入了解描述符的详细信息之前，了解 Python 中的属性查找如何工作可能很重要。这假设该类没有元类，并且它使用 __getattribute__ 的默认实现（两者都可以用于“自定义”行为）。

在这种情况下，属性查找（在 Python 3.x 中或 Python 2.x 中的新式类）的最佳说明来自 了解 Python 元类（ionel 的代码日志）。该图像使用 : 代替“不可自定义的属性查找”。

这表示在 Class 的 实例 上查找属性 foobar：

这里有两个条件很重要：

• 如果instance 的类有一个属性名称条目，它有 __get__ 和 __set__。
• 如果实例没有属性名称条目，但类有一个并且具有__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 ...>

请注意，我没有提供任何参数，并且该函数确实返回了我绑定的实例！

函数是非数据描述符！

数据描述符的一些内置示例是属性。忽略 getter、setter 和 deleter，property 描述符是（来自 描述符操作指南“属性”）：

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)

由于它是一个数据描述符，因此每当您查找 < 的“名称”时都会调用它code>property 并且它只是委托给用 @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'>

或者“懒惰” property”：

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 的值，并且在该类的所有实例之间共享（以及在该类上 - 尽管只能在该类上使用“读取”访问权限）类，否则您将替换描述符实例）：

>>> 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

这就是描述符通常使用第二个参数（实例）来存储值以避免共享它的原因。然而，在某些情况下，可能需要在实例之间共享值（尽管我目前无法想到场景）。然而，对于温度类别中的摄氏属性来说，它实际上没有任何意义……除非作为纯粹的学术练习。

Answer 5

为什么我需要描述符类？

受到 Buciano Ramalho

Imaging 的 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 类来执行更常见的验证

Answer 6

您会看到 https://docs.python.org/3/howto/描述符.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__)

Answer 7

易于理解（带有示例）__get__ & 的解释__设置__ & __call__ 在类中，什么是Owner、Instance？

在深入研究之前需要先了解一下：

1. __get__ __set__ 被称为类的描述符工作/保存它们的内部属性，即：__name__（类/所有者类的名称），变量-__dict__等。稍后我将解释什么是所有者。
2. 设计中使用了描述符更常见的是，例如，使用装饰器（将事物抽象出来）。您可以认为它更常用于软件架构设计中，以减少冗余并提高可读性（似乎很讽刺）。因此遵守 SOLID 和 DRY 原则。
3. 如果您设计的软件不应该遵守 SOLID 和 DRY 原则，您可能不需要它们，但理解它们总是明智的。

1. 考虑这段代码：

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") 时，会从 Method 类调用 __call__ 方法（call 方法使一个像函数一样可调用的类对象 - 每当类实例被调用时 __call__ 就会被实例化），并分配以下参数：instance: "first", arg1: "second"，并且最后一个arg2被省略，这会打印出错误：TypeError: __call__()missing 1 requiredpositional argument: 'arg2'

2.如何解决它？

• 由于__call__采用instance作为第一个参数（instance、arg1、arg2），但是instance是什么？

• Instance 是调用描述符类（Method）的主类（MyClass）的实例。那么，instance = MyClass() 是实例，那么谁是所有者？持有描述符类的类 - MyClass，但是，我们的描述符类 (Method) 中没有方法将其识别为实例。这就是我们需要 __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

根据文档，暂时忘记 set：

__get__ “调用以获取所有者类的属性（类属性访问）或该类的实例（实例属性访问）。”

如果您这样做： instance.method.__get__(instance)

Prints:<__main__.MyClass object at 0x7fb7dd9eab90> <类'__main__.MyClass'>

这意味着实例：MyClass 的对象，即instance
并且 Owner 是 MyClass 本身

3. __set__ 说明：

__set__ 用于设置类中的一些值 >__dict__ 对象（假设使用命令行）。设置 set 内部值的命令是： instance.descriptor = 'value' # 在本例中，描述符是 method

• < em>(代码中的instance.__dict__["method"] = value只是更新描述符的__dict__对象)

• 所以这样做： instance.method = 'value' 现在检查 value = 'value' 是否在我们可以访问 的 __set__ 方法中设置描述符方法的__dict__对象。
  做：
  instance.method.__dict__ 打印：{'_name': 'Internal call', 'value': 'value'}

• 或者你可以检查 使用 vars(instance.method) 的 __dict__ 值
prints: {'name': '内部调用', 'value': 'value'}
我希望现在事情已经清楚了:)

  


Answer 8

我尝试了安德鲁·库克答案中的代码（按照建议进行了微小的更改）。 （我正在运行 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 之前的版本，请确保从对象进行子类化，这将使描述符正常工作，因为 get 魔法对旧样式类不起作用。