类和实例属性有什么区别？

Question

之间是否有任何有意义的区别：

class A(object):
    foo = 5   # some default value

对比

class B(object):
    def __init__(self, foo=5):
        self.foo = foo

如果您正在创建大量实例，这两种样式在性能或空间要求上有什么不同吗？ 当你阅读代码时，你是否认为两种样式的含义有显着不同？

Answer 1

存在显着的语义差异（超出性能考虑）：

• 当在实例上定义属性时（这是我们通常所做的），可以引用多个对象。 每个都获得该属性的完全独立的版本。
• 当在类上定义属性时，只有一个底层对象被引用，因此如果对该类的不同实例的操作都尝试设置/（追加/扩展/插入/等）属性，则：
  • 如果属性是内置类型（如 int、float、boolean、string），对一个对象的操作将覆盖（破坏）该值
  • 如果属性是可变类型（如列表或字典），我们将获得不必要的泄漏。

例如：

>>> class A: foo = []
>>> a, b = A(), A()
>>> a.foo.append(5)
>>> b.foo
[5]
>>> class A:
...  def __init__(self): self.foo = []
>>> a, b = A(), A()
>>> a.foo.append(5)
>>> b.foo    
[]

Answer 2

不同之处在于类上的属性由所有实例共享。 实例上的属性对该实例是唯一的。

如果来自 C++，类的属性更像是静态成员变量。

Answer 3

这是一个很好的帖子，总结如下。

class Bar(object):
    ## No need for dot syntax
    class_var = 1

    def __init__(self, i_var):
        self.i_var = i_var

## Need dot syntax as we've left scope of class namespace
Bar.class_var
## 1
foo = MyClass(2)

## Finds i_var in foo's instance namespace
foo.i_var
## 2

## Doesn't find class_var in instance namespace…
## So look's in class namespace (Bar.__dict__)
foo.class_var
## 1

并以视觉形式

类属性赋值

• 如果通过访问类设置类属性，它将覆盖所有实例的值

  foo = Bar(2) foo.class_var ## 1 Bar.class_var = 2 foo.class_var ## 2

• 如果通过访问实例设置类变量，它将仅覆盖该实例的值。 这实质上覆盖了类变量并将其转换为一个可用的实例变量，直观地，仅适用于该实例。

   foo = Bar(2) foo.class_var ## 1 foo.class_var = 2 foo.class_var ## 2 Bar.class_var ## 1

什么时候使用 class 属性？

• 存储常量。 由于类属性可以作为类本身的属性来访问，因此使用它们来存储类范围的、特定于类的常量通常很好

  class Circle(object): pi = 3.14159 def __init__(self, radius): self.radius = radius def area(self): return Circle.pi * self.radius * self.radius Circle.pi ## 3.14159 c = Circle(10) c.pi ## 3.14159 c.area() ## 314.159

• 定义默认值。 作为一个简单的例子，我们可能会创建一个有界列表（即，一个只能包含一定数量或更少元素的列表）并选择默认上限为 10 个项目

  class MyClass(object): limit = 10 def __init__(self): self.data = [] def item(self, i): return self.data[i] def add(self, e): if len(self.data) >= self.limit: raise Exception("Too many elements") self.data.append(e) MyClass.limit ## 10

Answer 4

由于此处的评论和其他两个标记为重复的问题中的人们似乎都对此感到困惑，因此我认为值得在亚历克斯考文垂的.

Alex 正在分配一个可变类型的值，如列表，这一事实与事物是否共享无关。 我们可以通过id函数或is运算符看到这一点：

>>> class A: foo = object()
>>> a, b = A(), A()
>>> a.foo is b.foo
True
>>> class A:
...     def __init__(self): self.foo = object()
>>> a, b = A(), A()
>>> a.foo is b.foo
False

_{（如果您想知道为什么我使用object()而不是5 ，那是为了避免遇到我不想在这里讨论的两个其他问题；出于两个不同的原因，完全单独创建5 s最终可能是数字5的同一个实例。但完全独立创建的object()不能。）}

---

那么，为什么 Alex 示例中的a.foo.append(5)会影响b.foo ，而我示例中的a.foo = 5却不会？ 那么，尝试a.foo = 5在Alex的例子，并注意不影响b.foo有两种。

a.foo = 5只是让a.foo成为5的名字。 这不会影响b.foo或a.foo曾经引用的旧值的任何其他名称。* 我们正在创建一个隐藏类属性的实例属性有点棘手，** 但是一旦你明白了，这里没有发生任何复杂的事情。

---

希望 Alex 使用列表的原因现在已经很明显了：你可以改变列表的事实意味着更容易显示两个变量命名同一个列表，也意味着在现实生活中的代码中更重要的是知道你是否有两个列表或同一个列表的两个名称。

---

_{* 来自 C++ 等语言的人的困惑在于，在 Python 中，值不存储在变量中。 值存在于值域中，单独存在，变量只是值的名称，而赋值只是为值创建一个新名称。 如果有帮助，请将每个 Python 变量视为shared_ptr<T>而不是T 。}

_{** 有些人通过使用类属性作为实例可能设置或可能不设置的实例属性的“默认值”来利用这一点。 这在某些情况下很有用，但也可能令人困惑，所以要小心。}

Answer 5

还有一种情况。

类和实例属性是Descriptor 。

# -*- encoding: utf-8 -*-


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

    def __get__(self, obj, objtype):
        return self.val


class Base(object):
    attr_1 = RevealAccess(10, 'var "x"')

    def __init__(self):
        self.attr_2 = RevealAccess(10, 'var "x"')


def main():
    b = Base()
    print("Access to class attribute, return: ", Base.attr_1)
    print("Access to instance attribute, return: ", b.attr_2)

if __name__ == '__main__':
    main()

以上将输出：

('Access to class attribute, return: ', 10)
('Access to instance attribute, return: ', <__main__.RevealAccess object at 0x10184eb50>)

相同类型的实例通过类或实例访问返回不同的结果！

我在c.PyObject_GenericGetAttr 的定义中找到了一个很棒的帖子。

解释

如果在组成的类的字典中找到该属性。 对象 MRO，然后检查正在查找的属性是否指向数据描述符（这只不过是实现__get__和__set__方法的类）。 如果是，则通过调用数据描述符的__get__方法（第 28-33 行）解析属性查找。