如何避免在实例之间共享类数据？

问题描述：

我想要的是这种行为：

class a:
    list = []

x = a()
y = a()

x.list.append(1)
y.list.append(2)
x.list.append(3)
y.list.append(4)

print(x.list) # prints [1, 3]
print(y.list) # prints [2, 4]

当然，我打印的时候真正发生的情况是：

print(x.list) # prints [1, 2, 3, 4]
print(y.list) # prints [1, 2, 3, 4]

显然，它们在类中共享数据a。如何获取单独的实例来实现我想要的行为？

解决方案 1：

你想要这个：

class a:
    def __init__(self):
        self.list = []

在类声明中声明变量会使它们成为“类”成员，而不是实例成员。在__init__方法中声明它们可确保在创建对象的每个新实例的同时创建成员的新实例，这正是您所寻找的行为。

解决方案 2：

接受的答案有效，但多一点解释也无妨。

类属性不会在创建实例时变为实例属性。只有当为它们分配值时，它们才会变为实例属性。

在原始代码中，list实例化后不会为属性分配任何值；因此它仍然是一个类属性。在内部定义列表__init__是可行的，因为__init__在实例化后被调用。或者，此代码也会产生所需的输出：

>>> class a:
    list = []

>>> y = a()
>>> x = a()
>>> x.list = []
>>> y.list = []
>>> x.list.append(1)
>>> y.list.append(2)
>>> x.list.append(3)
>>> y.list.append(4)
>>> print(x.list)
[1, 3]
>>> print(y.list)
[2, 4]

但是，问题中令人困惑的情况永远不会发生在数字和字符串等不可变对象上，因为它们的值不能在不赋值的情况下改变。例如，类似于原始带有字符串属性类型的代码可以毫无问题地运行：

>>> class a:
    string = ''


>>> x = a()
>>> y = a()
>>> x.string += 'x'
>>> y.string += 'y'
>>> x.string
'x'
>>> y.string
'y'

总结一下：当且仅当在实例化后为类属性分配了值（无论是否在__init__方法中），类属性才会成为实例属性。这是一件好事，因为这样，如果在实例化后从未为属性分配值，则可以拥有静态属性。

解决方案 3：

尽管接受的答案是正确的，但我还是想添加一些描述。

让我们做一个小练习

首先定义一个类如下：

class A:
    temp = 'Skyharbor'

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

    def change(self, y):
        self.temp = y

那么我们这里有什么？

• 我们有一个非常简单的类，它有一个temp字符串属性

• __init__设置的方法self.x

• 变更方法集self.temp

到目前为止还挺简单的，对吧？现在让我们开始研究这个类。我们先初始化这个类：

a = A('Tesseract')

现在执行以下操作：

>>> print(a.temp)
Skyharbor
>>> print(A.temp)
Skyharbor

嗯，a.temp正如预期的那样，但它到底是如何A.temp工作的呢？好吧，它之所以有效是因为 temp 是一个类属性。python 中的一切都是对象。这里 A 也是类的对象type。因此，属性 temp 是类拥有的属性，如果你通过（而不是通过 的实例）A更改 temp 的值，则更改的值将反映在类的所有实例中。让我们继续这样做：A`a`A

>>> A.temp = 'Monuments'
>>> print(A.temp)
Monuments
>>> print(a.temp)
Monuments

很有趣不是吗？请注意id(a.temp)和id(A.temp)仍然相同。

任何 Python 对象都会自动被赋予一个__dict__属性，其中包含其属性列表。让我们研究一下此字典对于我们的示例对象包含什么：

>>> print(A.__dict__)
{
    'change': <function change at 0x7f5e26fee6e0>,
    '__module__': '__main__',
    '__init__': <function __init__ at 0x7f5e26fee668>,
    'temp': 'Monuments',
    '__doc__': None
}
>>> print(a.__dict__)
{x: 'Tesseract'}

请注意，temp属性是在A类的属性中列出的，而x列出的是实例的属性。

a.temp那么，如果实例中甚至没有列出，我们怎么会得到定义的值呢a？这就是方法的魔力__getattribute__()。在 Python 中，点语法会自动调用此方法，因此当我们编写时a.temp，Python 会执行a.__getattribute__('temp')。该方法执行属性查找操作，即通过查看不同位置来查找属性的值。

标准实现__getattribute__()首先搜索对象的内部字典 ( dict )，然后搜索对象本身的类型。在这种情况下，a.__getattribute__('temp')首先执行a.__dict__['temp']，然后a.__class__.__dict__['temp']

好的，现在让我们使用我们的change方法：

>>> a.change('Intervals')
>>> print(a.temp)
Intervals
>>> print(A.temp)
Monuments

好了，现在我们已经使用了self，print(a.temp)它为我们提供了与不同的值print(A.temp)。

现在如果我们比较id(a.temp)和id(A.temp)，它们会有所不同。

解决方案 4：

您将“list”声明为“类级属性”，而不是“实例级属性”。为了使属性作用域在实例级，您需要通过引用__init__方法中的“self”参数来初始化它们（或根据情况在其他地方引用）。

您不必严格地在__init__方法中初始化实例属性，但是这样更容易理解。

解决方案 5：

因此，几乎这里的每个回复似乎都忽略了某个特定点。类变量永远不会成为实例变量，如下面的代码所示。通过使用元类在类级别拦截变量赋值，我们可以看到，当重新分配 a.myattr 时，不会调用类上的字段赋值魔术方法。这是因为赋值创建了一个新的实例变量。此行为与类变量完全无关，如第二个类所示，它没有类变量，但仍允许字段赋值。

class mymeta(type):
    def __init__(cls, name, bases, d):
        pass

    def __setattr__(cls, attr, value):
        print("setting " + attr)
        super(mymeta, cls).__setattr__(attr, value)

class myclass(object):
    __metaclass__ = mymeta
    myattr = []

a = myclass()
a.myattr = []           #NOTHING IS PRINTED
myclass.myattr = [5]    #change is printed here
b = myclass()
print(b.myattr)         #pass through lookup on the base class

class expando(object):
    pass

a = expando()
a.random = 5            #no class variable required
print(a.random)         #but it still works

简而言之，类变量与实例变量无关。

更清楚地说，它们恰好在实例查找范围内。类变量实际上是类对象本身的实例变量。您也可以根据需要使用元类变量，因为元类本身也是对象。无论是否用于创建其他对象，一切都是对象，因此不要受其他语言使用类一词的语义的束缚。在 Python 中，类实际上只是一个对象，用于确定如何创建其他对象以及它们的行为将是什么。元类是创建类的类，只是为了进一步说明这一点。

解决方案 6：

是的，如果您希望列表成为对象属性而不是类属性，则必须在“构造函数”中声明。

解决方案 7：

为了保护其他实例共享的变量，您需要在每次创建实例时创建新的实例变量。当您在类中声明变量时，它是类变量，由所有实例共享。如果您想将其作为实例，则需要使用init方法重新初始化变量，以引用实例

摘自Programiz.com 的《Python 对象和类》：

__init__()函数。每当实例化该类的新对象时，就会调用此特殊函数。

这种类型的函数在面向对象编程（OOP）中也称为构造函数。我们通常使用它来初始化所有变量。

例如：

class example:
    list=[] #This is class variable shared by all instance
    def __init__(self):
        self.list = [] #This is instance variable referred to specific instance