访问字段：如果存储在字典中，则值不同

Question

我的问题看起来像这样。

# Module.py
class TestClass:
    name = "default"
    nameDict = {'name':"standard"}

    def __init__(self, name):
       self.name = name
       self.nameDict['name'] = name

然后我调用另一个模块的字段。该类是之前启动的，我像这样调用名称字段：

Module.TestClass("newName")

# Inside another function
print(Module.TestClass.name)
print(Module.TestClass.nameDict['name'])

这给出了：

default #name
newName #nameDict

我不明白为什么会有不同的值。有谁知道为什么会发生这种情况？

感谢您的宝贵时间。

Answer 1

这是一个有趣的问题；发生了很多事情。

Module.TestClass 是您在“Module.py”中定义的类。使用Module.TestClass("newName")，您正在创建该类的实例，但您没有保存它。

当您执行print(Module.TestClass.name) 时，您正在打印Module.TestClass 的name 属性的值，它是类，不是 实例。你之前给 instance 的 name 不会改变 class' name 属性。

真正有趣的是print(Module.TestClass.nameDict['name'])。即使您仍在访问 class 的 nameDict 属性，它 也受到您之前创建的 instance 的影响。这是因为 Python 变量包含对对象的引用。定义类时，您将字典分配给类范围内的属性nameDict。 完全相同字典对象正被类 和所有类的实例所指向。所以，如果你在一个地方改变它，它就会在任何地方都改变，因为它实际上是完全相同的字典。

这是一个很好的方法来做你想做的事情：

# Module.py

class TestClass(object):
    def __init__(self, name='default'):
        self.name = name
        self.nameDict = {'name': name}

# other.py

testclass_instance = Module.TestClass("newName")

# Inside another function
print(testclass_instance.name)  # newName
print(testclass_instance.nameDict['name'])  # newName

Answer 2

你看到的不同是因为 -

1. 字符串是不可变的，而字典是可变的。

1234563

2. 在您的 init 函数中，当您更改字典中 name 键的值时，您正在改变字典（与类变量相同的字典），因此它在类变量字典中反映为好吧。如果你在这里分配了一个新的字典，你仍然可以在类变量中看到旧的值。

这基本上是因为当你创建一个实例时，类变量的引用被复制到实例中，引用仍然指向当时指向的任何类变量。因为在这种情况下，由于引用相同，所以对 dict 的更改会反映在类变量中。

但是当你进行赋值时，你是在让变量指向一个新的引用，这不会导致类变量发生变化。

一个简单的例子来说明这一点 -

>>> class CA:
...     d = [1,2]
...
>>> CA.d
[1, 2]
>>> c = CA()
>>> c.d
[1, 2]
>>> id(c.d) == id(CA.d)
True
>>> c.d.append(3)
>>> CA.d
[1, 2, 3]
>>> c.d = [1,2,3,4,5]
>>> CA.d
[1, 2, 3]
>>> CA.d = [1,2,3,4,5,6]
>>> CA.d
[1, 2, 3, 4, 5, 6]
>>> d = CA()
>>> d.d
[1, 2, 3, 4, 5, 6]
>>> c.d
[1, 2, 3, 4, 5]

Answer 3

这种行为也让我感到惊讶：

import Module

# Inside another function
print(Module.TestClass.name)             #<-- default
print(Module.TestClass.nameDict['name']) #<-- standard

foo = Module.TestClass("newName")

print(Module.TestClass.name)             #<-- default
print(Module.TestClass.nameDict['name']) #<-- newName

你为什么要类变量？也许你想做：

foo = Module.TestClass("newName")

print(foo.name)
print(foo.nameDict['name'])

Answer 4

因为TestClass.name是一个字符串对象，所以是不可变的，而TestClass.nameDict是一个可变字典对象。因此，当您执行self.name = name 时，会在具有“newName”值的实例上创建一个新名称变量，而当您执行self.nameDict['name'] = name 时，dict 类变量会发生突变。

要验证此行为，您可以检查变量的 id：

例子：-

class TestClass(object):

    ...

    def __init__(self, newName):
        print(id(self.name)) #1
        self.name = newName
        print(id(self.name)) #2

        print(id(self.nameDict)) #3
        self.nameDict['name'] = newName
        print(id(self.nameDict)) #4

1 与#2 不同，而#3 和#4 相同。

更多参考：-Mutable and immutable objects in python