类变量和实例变量有什么区别？

Question

Python中类变量和实例变量有什么区别？

class Complex:
    a = 1

和

class Complex:
    def __init__(self):
        self.a = 1

使用调用：x = Complex().a 在这两种情况下都将 x 分配给 1。

将不胜感激有关__init__() 和self 的更深入的回答。

Answer 1

当你编写一个类块时，你创建了类属性（或类变量）。您在类块中分配的所有名称，包括您使用def 定义的方法，都将成为类属性。

创建类实例后，任何引用该实例的东西都可以在其上创建实例属性。在方法内部，“当前”实例几乎总是绑定到名称 self，这就是为什么您将这些视为“自变量”。通常在面向对象的设计中，附加到类的代码应该可以控制该类实例的属性，因此几乎所有实例属性分配都是在方法内部完成的，使用在self 中接收到的对实例的引用方法的参数。

类属性通常与 Java、C# 或 C++ 等语言中的 静态 变量（或方法）进行比较。但是，如果您想深入了解，我会避免将类属性视为与静态变量“相同”。虽然它们通常用于相同的目的，但基本概念却大不相同。更多信息请参见该行下方的“高级”部分。

一个例子！

class SomeClass:
    def __init__(self):
        self.foo = 'I am an instance attribute called foo'
        self.foo_list = []

    bar = 'I am a class attribute called bar'
    bar_list = []

执行此块后，有一个类SomeClass，具有3个类属性：__init__、bar和bar_list。

然后我们将创建一个实例：

instance = SomeClass()

当这种情况发生时，SomeClass 的 __init__ 方法将被执行，并在其 self 参数中接收新实例。此方法创建两个实例属性：foo 和 foo_list。然后将此实例分配给instance 变量，因此它绑定到具有这两个实例属性的事物：foo 和foo_list。

但是：

print instance.bar

给予：

I am a class attribute called bar

这是怎么发生的？当我们尝试通过点语法检索一个属性，而该属性不存在时，Python 会通过一系列步骤来尝试满足您的请求。接下来它会尝试查看实例类的类属性。在这种情况下，它在SomeClass 中找到了一个属性bar，因此它返回了该属性。

顺便说一句，这也是方法调用的工作方式。例如，当您调用 mylist.append(5) 时，mylist 没有名为 append 的属性。但是mylist 的class 确实如此，并且它绑定到一个方法对象。该方法对象由mylist.append 位返回，然后(5) 位使用参数5 调用该方法。

这很有用的方式是SomeClass 的所有 实例都可以访问相同的bar 属性。我们可以创建一百万个实例，但我们只需要将那个字符串存储在内存中，因为它们都可以找到它。

但是你必须小心一点。看看下面的操作：

sc1 = SomeClass()
sc1.foo_list.append(1)
sc1.bar_list.append(2)

sc2 = SomeClass()
sc2.foo_list.append(10)
sc2.bar_list.append(20)

print sc1.foo_list
print sc1.bar_list

print sc2.foo_list
print sc2.bar_list

你认为这会打印什么？

[1]
[2, 20]
[10]
[2, 20]

这是因为每个实例都有自己的foo_list 副本，因此它们被单独附加。但是所有个实例共享对同一个bar_list的访问。因此，当我们执行sc1.bar_list.append(2) 时，它会影响sc2，即使sc2 还不存在！同样sc2.bar_list.append(20) 影响了通过sc1 检索到的bar_list。这通常不是您想要的。

---

随后进行高级研究。 :)

要真正了解来自 Java 和 C# 等传统静态类型 OO 语言的 Python，您必须学会重新思考类。

在Java 中，类本身并不是真正的事物。当您编写一个类时，您更多地声明了该类的所有实例所共有的一堆东西。在运行时，只有实例（和静态方法/变量，但它们实际上只是与类关联的命名空间中的全局变量和函数，实际上与 OO 无关）。类是您在源代码中写下实例在运行时的样子的方式；它们只“存在”在您的源代码中，而不是正在运行的程序中。

在 Python 中，类没有什么特别之处。它是一个对象，就像其他任何东西一样。所以“类属性”其实和“实例属性”是一回事；实际上只有“属性”。进行区分的唯一原因是我们倾向于使用类对象与非类对象不同。底层机制都是一样的。这就是为什么我说将类属性视为其他语言的静态变量是错误的。

但真正使 Python 类与 Java 样式类不同的是，就像任何其他对象一样每个类都是某个类的实例！

在 Python 中，大多数类都是名为 type 的内置类的实例。正是这个类控制了类的共同行为，并使所有面向对象的东西都按照它的方式进行。默认的 OO 方式让类的实例具有自己的属性，并具有由它们的类定义的公共方法/属性，这只是 Python 中的一个协议。如果你愿意，你可以改变它的大部分方面。如果您曾经听说过使用元类，那么这就是定义一个类，该类是与type 不同的类的实例。

关于类的唯一真正“特殊”的事情（除了使它们按默认方式工作的所有内置机制之外）是类块语法，它可以让您更轻松地创建type 的实例.这个：

class Foo(BaseFoo):
    def __init__(self, foo):
        self.foo = foo

    z = 28

大致等价于：

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

classdict = {'__init__': __init__, 'z': 28 }

Foo = type('Foo', (BaseFoo,) classdict)

它会安排classdict的所有内容成为被创建对象的属性。

因此，通过Class.attribute 访问类属性就像i = Class(); i.attribute 一样容易，这几乎是微不足道的。 i 和 Class 都是对象，对象具有属性。这也便于理解如何在创建类后对其进行修改；只需按照与任何其他对象相同的方式分配其属性！

事实上，实例与用于创建它们的类没有特别的特殊关系。 Python 知道在哪个类中搜索实例中未找到的属性的方式是通过隐藏的__class__ 属性。您可以阅读它以了解这是哪个类的实例，就像任何其他属性一样：c = some_instance.__class__。现在您有一个变量c 绑定到一个类，即使它可能与该类的名称不同。您可以使用它来访问类属性，甚至调用它来创建它的更多实例（即使您不知道它是什么类！）。

您甚至可以分配给i.__class__ 来更改它是哪个类的实例！如果您这样做，则不会立即发生任何特别的事情。这不是惊天动地的。这意味着当您查找实例中不存在的属性时，Python 将查看__class__ 的新内容。由于这包括大多数方法，并且方法通常期望它们正在操作的实例处于某些状态，因此如果您随意执行此操作通常会导致错误，并且非常令人困惑，但是可以完成。如果你非常小心，你存储在__class__ 中的东西甚至不必是类对象； Python 所要做的就是在某些情况下查找属性，因此您所需要的只是一个具有正确类型属性的对象（除了一些注意事项，Python 确实对作为特定类的类或实例的事物很挑剔）。

现在可能已经足够了。希望（如果你已经读到这里）我没有把你弄糊涂。当您了解 Python 的工作原理时，它会很整洁。 :)

Answer 2

您所说的“实例”变量实际上并不是实例变量；它是一个类变量。请参阅language reference about classes。

在您的示例中，a 似乎是一个实例变量，因为它是不可变的。在您分配可变对象的情况下，可以看到 class 变量的本质：

>>> class Complex:
>>>    a = []
>>>
>>> b = Complex()
>>> c = Complex()
>>> 
>>> # What do they look like?
>>> b.a
[]
>>> c.a
[]
>>> 
>>> # Change b...
>>> b.a.append('Hello')
>>> b.a
['Hello']
>>> # What does c look like?
>>> c.a
['Hello']

如果您使用self，那么它将是一个真正的实例变量，因此每个实例都有自己唯一的a。对象的__init__ 函数是called when a new instance is created，self 是对该实例的引用。