Python 3.x 如何使变量和包含它的字典保持一致？

我有一个变量

self.foo = 1

还有一本字典

self.foo_dict = {
    'foo_key' = self.foo
}

我希望能够更改

self.foo

的值，并在

self.foo\u dict

中进行更改。如果这是C语言（dict是一个结构），我只会使用一个指针

有什么建议吗？这在Python中可能吗

这在Python中可能吗

答案1：不是以直截了当的方式，因为

int

是不可变的。然而

答案2：实现你想要的东西有一些变通方法

不要对变量

foo

使用

int

，您需要为

foo

创建一个包装类，因为

int

是不可变的，而您定义的任何包装类都不是

foo

的包装器类：

class Foo:
    def __init__(self, val):
        self.foo = val
    def set(self, val):
        self.foo = val
    def __repr__(self):
        return str(self.foo)

然后，拥有一致变量字典对的类可以是这样的：

class A:
    def __init__(self):
        self.foo = Foo(1)
        self.foo_dict = {
            'foo_key': self.foo
            }
    def set_foo(self, newval):
        self.foo.set(newval)

self.some_dict["valueA"] = some_value

self.some_dict = {"value1":1}
self.other_dict = some_dict
self.other_dict.update("{"value2": 2}")

试运行：

>>> a = A()
>>> a.foo
1
>>> a.foo_dict['foo_key']
1
>>> a.set_foo(20)
>>> a.foo
20
>>> a.foo_dict['foo_key']
20

---

我没有完全理解你的问题，但是如果你想更改

self.foo

的值，你可以直接使用字典。假设您有一些字典：

self.some_dict = {"valueA":1}

class Bar:
    def __init__(self, foo_):
        self.foo_dict = {}  
        self.foo = foo_

    @property
    def foo(self):
        return self.foo_dict["foo_key"]

    @foo.setter
    def foo(self, value):
        self.foo_dict["foo_key"] = value

    def show(self):
        print("foo={} ; foo_dict['foo_key']={}".format(
                        self.foo, self.foo_dict["foo_key"]))

b = Bar(1)
b.show()
b.foo = 2
b.show()
b.foo_dict["foo_key"] = 3
b.show()

考虑到字典是通过

键

到

值

对来工作的，您可以这样更改

valueA的值：

class A:
    def __init__(self):
        self.foo = Foo(1)
        self.foo_dict = {
            'foo_key': self.foo
            }
    def set_foo(self, newval):
        self.foo.set(newval)

self.some_dict["valueA"] = some_value

self.some_dict = {"value1":1}
self.other_dict = some_dict
self.other_dict.update("{"value2": 2}")

因此，该键的值更改为
某个\u值
。作为另一种可能性，您可以使用
dict.copy
创建词典副本。这样，您就有了另一个与第一个字典具有相同值的字典，然后使用
dict.update
进行更新，以在键中添加新元素或值。大概是这样的：

class A:
    def __init__(self):
        self.foo = Foo(1)
        self.foo_dict = {
            'foo_key': self.foo
            }
    def set_foo(self, newval):
        self.foo.set(newval)

self.some_dict["valueA"] = some_value

self.some_dict = {"value1":1}
self.other_dict = some_dict
self.other_dict.update("{"value2": 2}")

使用此命令，您可以将
值2
更新为其他命令。
无需包装类

>>> class Test(object):
    def __init__(self,foo):
        self.foo = foo
        self.foo_dict = {'foo_key': foo}
    def set_foo(self, foo):
        self.foo = foo
        self.foo_dict['foo_key'] = foo


>>> a = Test(1)
>>> a.foo
1
>>> a.foo_dict
{'foo_key': 1}
>>> a.set_foo(2)
>>> a.foo
2
>>> a.foo_dict
{'foo_key': 2}
>>> 

只需将
self.foo
设置为访问字典中的值的属性：

self.some_dict = {"valueA":1}

class Bar:
    def __init__(self, foo_):
        self.foo_dict = {}  
        self.foo = foo_

    @property
    def foo(self):
        return self.foo_dict["foo_key"]

    @foo.setter
    def foo(self, value):
        self.foo_dict["foo_key"] = value

    def show(self):
        print("foo={} ; foo_dict['foo_key']={}".format(
                        self.foo, self.foo_dict["foo_key"]))

b = Bar(1)
b.show()
b.foo = 2
b.show()
b.foo_dict["foo_key"] = 3
b.show()


属性在外观上与普通实例成员字段类似，但实际上它们是可以执行任何操作的自定义函数。这样，当访问
foo
属性时，将调用两个
foo（…）
方法。用
@property
装饰的是getter，而用
@PROPERTYNAME.setter
装饰的是setter。您还可以通过省略其中一个属性方法来限制对属性的读或写访问

在这里，它们将所有操作重定向到字典。这样一来，一个简单的可变变量只有一个实例，但有多种访问方法

上述示例将产生以下输出：

foo=1 ; foo_dict['foo_key']=1
foo=2 ; foo_dict['foo_key']=2
foo=3 ; foo_dict['foo_key']=3

因此，正如我们所看到的，无论是在字典中更改值还是通过属性更改值，这两个名称始终指向同一个变量。
的可能重复。不用int作为foo的值，你可以创建一个包装类，并使用该类的一个对象。为什么你不简单地使用一个类呢？@EbraHim，因为两个类是解决这个问题的明显方法。我发布了一个临时答案，我可以请你看一下吗？哇哇哇哇哇，慢一点，你键入什么，好吗！在你的写作中有太多的错误。我不认为你已经很好地理解了克斯托因。属性方法+1。在我发布第一个答案后，我也想这么做。然而，你的第一句话让我觉得。。。有点紧张，你知道我的意思吗？；-）：D谢谢。但是，如果我们有一个更舒适的选择，所有的同步都是在后台自动完成的，并且没有任何接口更改，那么为什么还要麻烦使用额外的包装类和调用方法来获取和设置其中的值呢？我同意你的方法是更好的方法。正如我所说，在我发布了我的第一个答案后，我认为它也可以使用属性来完成。但后来我决定不改变我的第一个答案。毕竟，如果我也添加了属性方法，您就没有机会在这里发布答案；-）@字节指挥官回答得很好。我觉得有点奇怪。据我所知，当我编写
b.foo
时，必须调用getter方法。那么，为什么我会收到变量
self.foo
的值，而不是在getter方法中返回的字典（即
foo（self）
）？@EbraHim
foo
是一个属性，这意味着在外部，它就像普通实例成员一样，就像我在任何地方用
self.foo=1
初始化它一样，例如，在构造函数方法中。但在内部，它是一对两个函数，一个getter和一个setter，在访问属性时隐式调用。
@property | def foo（self）：
方法是getter，在dictionary
foo dict
中查找映射到“foo_key”的值。这就是存储值的地方。
@foo.setter | def foo（self，value）：
方法是setter，它使用“foo_键”将新的
值存储在
foo_dict
中。