何时以及如何在 python 中使用内置函数 property()

Question

在我看来，除了一点语法糖，property() 并没有什么好处。

当然，能够写成 a.b=2 而不是 a.setB(2) 是件好事，但隐藏 ab=2 不是一个简单的赋值这一事实似乎是个麻烦事，因为可能会发生一些意想不到的结果，例如a.b=2 实际上导致a.b 为1。或引发异常。或者性能问题。或者只是令人困惑。

你能给我一个具体的例子来很好地使用它吗？ （用它来修补有问题的代码不算数;-)

Answer 1

在依赖于 getter 和 setter 的语言中，例如 Java，除了返回逻辑属性 @ 的当前值之外，如果 x.getB() 做了任何事情，那将是惊人的。 987654322@，或者如果x.setB(2) 做了任何事情，但需要进行少量内部工作以使x.getB() 返回2。

但是，对于这种预期行为，没有语言强加的保证，即编译器对名称以get 或set 开头的方法体的约束：相反，它是留给常识、社会习俗、“风格指南”和测试。

x.b 访问和赋值（例如 x.b = 2）在具有属性的语言（包括但不限于 Python 的一组语言）中的行为完全相同相同至于 Java 中的 getter 和 setter 方法：同样的期望，同样缺乏语言强制保证。

属性的第一个优势是语法和可读性。必须写，例如，

x.setB(x.getB() + 1)

而不是显而易见的

x.b += 1

呼喊着向众神报仇。在支持属性的语言中，绝对没有充分的理由强迫该类的用户经历这种拜占庭样板的旋转，从而影响他们代码的可读性而没有任何好处。

特别是在 Python 中，使用属性（或其他描述符）代替 getter 和 setter 还有一个很大的好处：如果并且当您重新组织类以便不再需要底层的 setter 和 getter 时，您可以（无需破坏类的已发布 API）简单地消除这些方法和依赖于它们的属性，使 b 成为 x 类的正常“存储”属性，而不是通过计算获得和设置的“逻辑”属性。

在 Python 中，直接（可行时）而不是通过方法执行操作是一项重要的优化，系统地使用属性使您能够在可行的情况下执行此优化（始终直接公开“正常存储的属性”，并且只公开那些确实需要的属性）通过方法和属性访问和/或设置时计算）。

因此，如果您使用 getter 和 setter 而不是属性，除了影响用户代码的可读性之外，您也无缘无故地浪费机器周期（以及在这些过程中进入计算机的能量）循环;-)，再次没有任何充分的理由。

您反对属性的唯一论据是例如“外部用户通常不会期望由于分配而产生任何副作用”；但是您错过了这样一个事实，即同一用户（在诸如 Java 之类的 getter 和 setter 普遍存在的语言中）也不会期望（可观察到的）“副作用”作为调用 setter 的结果（对于 getter 来说甚至更少） ;-)。它们是合理的期望，作为课程作者，您可以尝试适应它们——无论您的 setter 和 getter 是直接使用还是通过属性使用，都没有区别。如果您的方法具有可观察到的重要副作用，请不要将它们命名为 getThis、setThat，并且不要通过属性使用它们。

属性“隐藏实现”的抱怨是完全没有道理的：OOP 的大部分所有都是关于实现信息隐藏——让一个类负责向外部世界呈现一个逻辑接口并实现它内部尽可能。 Getter 和 setter 就像属性一样，是实现这一目标的工具。属性只是在这方面做得更好（在支持它们的语言中；-）。

Answer 2

这个想法是让您避免在真正需要之前编写 getter 和 setter。

所以，开始你写：

class MyClass(object):
    def __init__(self):
        self.myval = 4

显然你现在可以写myobj.myval = 5。

但后来，您决定确实需要一个二传手，因为您想同时做一些聪明的事情。但是您不想更改使用您的类的所有代码 - 因此您将 setter 包装在 @property 装饰器中，一切正常。

Answer 3

但隐藏 a.b=2 不是 a 简单的分配看起来像一个食谱 找麻烦

不过，你并没有隐瞒这个事实；这个事实从一开始就没有。这是python——一种高级语言；不是组装。其中很少有“简单”语句可以归结为单个 CPU 指令。将简单读入作业中，就是读懂不存在的东西。

当您说 x.b = c 时，您可能只想到“无论刚刚发生什么，x.b 现在应该是 c”。

Answer 4

一个基本的原因就是它看起来更好。它更pythonic。特别是对于图书馆。 something.getValue() 看起来不如 something.value 好

在 plone（一个相当大的 CMS）中，您曾经拥有 document.setTitle()，它会做很多事情，例如存储值、再次索引它等等。只是做 document.title = 'something' 更好。无论如何，您都知道幕后发生了很多事情。

Answer 5

你是对的，它只是语法糖。根据您对有问题的代码的定义，它可能没有很好的用途。

假设您有一个在您的应用程序中广泛使用的类 Foo。现在这个应用程序已经变得相当大了，可以说它是一个非常流行的网络应用程序。

您发现 Foo 导致了瓶颈。也许可以向 Foo 添加一些缓存以加快速度。使用属性可以让您在不更改 Foo 之外的任何代码或测试的情况下做到这一点。

是的，当然这是有问题的代码，但您只是节省了很多 $$ 快速修复它。

如果 Foo 在您拥有成百上千用户的库中怎么办？好吧，当他们升级到 Foo 的最新版本时，您不必告诉他们进行昂贵的重构。

发行说明有一个关于 Foo 的项目，而不是段落移植指南。

经验丰富的 Python 程序员除了 a.b==2 之外，对 a.b=2 的期望并不高，但他们知道即使这样也可能不是真的。课堂内发生的事情是它自己的事情。

Answer 6

这是我的一个老例子。我包装了一个 C 库，它具有“void dt_setcharge(int atom_handle, int new_charge)”和“int dt_getcharge(int atom_handle)”等功能。我想在 Python 级别执行“atom.charge = atom.charge + 1”。

“属性”装饰器让这一切变得简单。比如：

class Atom(object):
    def __init__(self, handle):
        self.handle = handle
    def _get_charge(self):
        return dt_getcharge(self.handle)
    def _set_charge(self, charge):
        dt_setcharge(self.handle, charge)
    charge = property(_get_charge, _set_charge)

10 年前，当我编写这个包时，我不得不使用 __getattr__ 和 __setattr__ 这使得它成为可能，但实现起来更容易出错。

class Atom:
    def __init__(self, handle):
        self.handle = handle
    def __getattr__(self, name):
        if name == "charge":
            return dt_getcharge(self.handle)
        raise AttributeError(name)
    def __setattr__(self, name, value):
        if name == "charge":
            dt_setcharge(self.handle, value)
        else:
            self.__dict__[name] = value

Answer 7

getter 和 setter 有很多用途，它们非常有用，因为它们对代码是透明的。让对象 Something 具有属性 height，您将值分配为 Something.height = 10，但如果 height 具有 getter 和 setter，那么在您分配该值时，您可以在过程中做很多事情，例如验证最小值或最大值值，例如因为高度变化而触发事件，根据新的高度值自动设置其他值，所有这些都可能在分配Something.height值的那一刻发生。请记住，您不需要在代码中调用它们，它们会在您读取或写入属性值时自动执行。在某些方面，它们类似于事件过程，当属性 X 更改值以及读取属性 X 值时。

Answer 8

当您尝试在重构中用委托替换继承时，它很有用。以下是一个玩具示例。 Stack 是 Vector 中的子类。

class Vector:
    def __init__(self, data):
        self.data = data

    @staticmethod
    def get_model_with_dict():
        return Vector([0, 1])


class Stack:
    def __init__(self):
        self.model = Vector.get_model_with_dict()
        self.data = self.model.data


class NewStack:
    def __init__(self):
        self.model = Vector.get_model_with_dict()

    @property
    def data(self):
        return self.model.data

    @data.setter
    def data(self, value):
        self.model.data = value


if __name__ == '__main__':
    c = Stack()
    print(f'init: {c.data}') #init: [0, 1]

    c.data = [0, 1, 2, 3]
    print(f'data in model: {c.model.data} vs data in controller: {c.data}') 
    #data in model: [0, 1] vs data in controller: [0, 1, 2, 3]

    c_n = NewStack()
    c_n.data = [0, 1, 2, 3]
    print(f'data in model: {c_n.model.data} vs data in controller: {c_n.data}') 
    #data in model: [0, 1, 2, 3] vs data in controller: [0, 1, 2, 3]

请注意，如果您确实使用直接访问而不是属性，self.model.data 不等于 self.data，这超出了我们的预期。

您可以将代码 before __name__=='__main__' 作为库。