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

时间：2009-11-05 13:19:56

标签： python class

我想要的是这种行为：

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中分享数据。如何获得单独的实例来实现我想要的行为？

8 个答案:

答案 0 :(得分：126)

你想要这个：

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

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

答案 1 :(得分：15)

接受的答案有效，但多一点解释不会受到伤害。

创建实例时，类属性不会成为实例属性。它们在为值分配值时成为实例属性。

在原始代码中，实例化后没有为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__方法或不是。这是一件好事，因为如果您在实例化后从未为属性赋值，则可以使用静态属性。

答案 2 :(得分：11)

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

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

答案 3 :(得分：7)

虽然接受的anwer是现货，但我想补充一点说明。

让我们做一个小练习

首先按如下方式定义一个类：

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类所拥有的属性，如果通过A更改temp的值（而不是通过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__()。那就是a.temp方法的神奇之处。在Python中，点线语法会自动调用此方法，因此当我们编写a.__getattribute__('temp')时，Python会执行__getattribute__()。该方法执行属性查找操作，即通过查看不同的位置来查找属性的值。

a.__getattribute__('temp')的标准实现首先搜索对象的内部字典（ dict ），然后搜索对象本身的类型。在这种情况下，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)和pass=MyNewPass echo "ALTER USER 'root'@'localhost' IDENTIFIED BY '$pass';" > mysqlinit sudo chown mysql:mysql mysqlinit sudo /etc/init.d/mysql stop sudo mysqld_safe --init-file=`pwd`/mysqlinit & sleep 2 sudo killall mysqld sudo /etc/init.d/mysql start sudo rm mysqlinit sql mysql://root:$pass@/mysql ，它们会有所不同。

答案 4 :(得分：3)

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

答案 5 :(得分：3)

所以这里几乎所有的回应似乎都错过了一个特定的观点。类变量从不成为实例变量，如下面的代码所示。通过利用元类来拦截类级别的变量赋值，我们可以看到，当重新分配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

IN SHORT 类变量与实例变量无关。

更清楚它们恰好位于实例查找的范围内。类变量实际上是类对象本身上的实例变量。如果您也想要，也可以使用元类变量，因为元类本身也是对象。无论是否用于创建其他对象，一切都是一个对象，所以不要在其他语言的语义中使用单词class。在python中，类实际上只是一个对象，用于确定如何创建其他对象以及它们的行为。元类是创建类的类，只是为了进一步说明这一点。

答案 6 :(得分：0)

要保护变量与其他实例共享，您每次创建实例时都需要创建新的实例变量。在类中声明变量时，它是类变量，并由所有实例共享。如果要使其实例化，则需要使用 init 方法来重新初始化变量，如实例

所示。

来自Python Objects and Class by Programiz.com：

  

__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

答案 7 :(得分：-5)

我认为所提供的答案具有误导性。在实例化对象时，在类中定义的属性将成为实例属性，无论您如何定义它。因此，制作了a.list的副本，x.list和y.list是不同的副本。它们似乎是相同的原因是它们都是同一列表的别名。但这是列表工作方式的结果，而不是类的工作方式。如果您使用数字而不是列表执行相同的操作（或者只使用+ =而不是追加，这将创建新列表）您会看到更改x.attr不会影响更改y.attr

在self.list内定义__init__有效，因为该函数被调用两次，每次对象被实例化一次，因此创建了两个不同的列表。

相关问题
最新问题