blocks|key|1601806|text|如下所示：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1601807|class+MyClass(object):
++++@staticmethod
++++def+my_condition():
++++++++return+True

++++def+__init__(self,+attributes):
++++++++self.attributes+=+{**attributes}
++++++++if+MyClass.my_condition():
++++++++++++self.attributes["test"]+=+False


my_attributes+=+{"test":+True}
cls_obj+=+MyClass(my_attributes)
print("my_attributes:",+my_attributes,+"class.attributes:",+cls_obj.attributes)|code-block|syntax|javascript|1601808|输出：|1601809|my_attributes:+{'test':+True}+class.attributes:+{'test':+False}|1601810|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

Something like this:

<pre><code>class MyClass(object):
 @staticmethod
 def my_condition():
 return True

 def __init__(self, attributes):
 self.attributes = {**attributes}
 if MyClass.my_condition():
 self.attributes["test"] = False


my_attributes = {"test": True}
cls_obj = MyClass(my_attributes)
print("my_attributes:", my_attributes, "class.attributes:", cls_obj.attributes)
</code></pre>

Output:

<pre><code>my_attributes: {'test': True} class.attributes: {'test': False}
</code></pre>

blocks|key|1816308|text|将一个(可变的)字典引用传递给一个对象。现在，您有两个引用的所有者:构造函数的调用者(对象的“外部世界”)和对象本身。这两个所有者可以修改字典。下面是一个插图：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1816309|>>>+d+=+{}
>>>+def+ctor(d):+return+[d]+#+just+build+a+list+with+one+element
>>>+L+=+ctor(d)
>>>+d[1]+=+2
>>>+L
[{1:+2}]
>>>+L[0][3]+=+4
>>>+d
{1:+2,+3:+4}|code-block|syntax|javascript|1816310|你如何防止这种情况发生？两个所有者都想保护自己不受变量的疯狂突变的影响。如果我是外部世界，我希望向dict传递一个不可变的引用，但Python不为dict提供不可变的引用。副本就是我们要走的路：|1816311|>>>+d+=+{}
>>>+L+=+ctor(dict(d))+#+I+don't+give+you+*my*+d
>>>+d[1]+=+2
>>>+L
[{}]|1816312|如果我是对象，我会在使用它之前复制一个对象：|1816313|>>>+d+=+{}
>>>+def+ctor2(d):+return+[dict(d)]+#+to+be+sure+L[0]+is+*mine*!
>>>+L+=+ctor2(dict(d))+#+I+don't+give+you+*my*+d|1816314|但是现在你已经制作了对象的两个副本，因为每个人都害怕看到它的变量被另一个修改了。如果字典包含(可变的)引用，问题仍然存在。|1816315|解决方案是详细说明每个人的职责：|1816316|class+MyClass(object):
++++"""Usage:+MyClass(attributes).do_something()+where+attributes+is+a+mapping.
++++The+mapping+won't+be+modified"""
++++...|1816317|请注意，这是常见的预期行为:除非指定，否则函数/构造器的参数不会被修改。我们尽可能避免副作用，但情况并不总是这样:参见list.sort()与sorted(...)。|offset|length|style|CODE|1816318|因此，我认为您的解决方案很好。但我倾向于避免在构造函数中使用过多的逻辑：|1816319|class+MyClass(object):
++++@staticmethod
++++def+create_prod(attributes):
++++++++attributes+=+dict(attributes)
++++++++attributes.update({"test":+False})
++++++++return+MyClass(attributes)

++++@staticmethod
++++def+create_test(attributes):
++++++++return+MyClass(attributes)

++++def+__init__(self,+attributes):
++++++++self._attributes+=+attributes+#+MyClass+won't+modify+attributes|1816320|entityMap^0|0|0|0|0|0|0|0|0|0|1N|B|1Z|B|0|0|0^^$0|@$1|2|3|4|5|6|7|16|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|17|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|18|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|19|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|1A|8|@]|9|@]|A|$]]|$1|M|3|N|5|D|7|1B|8|@]|9|@]|A|$E|F]]|$1|O|3|P|5|6|7|1C|8|@]|9|@]|A|$]]|$1|Q|3|R|5|6|7|1D|8|@]|9|@]|A|$]]|$1|S|3|T|5|D|7|1E|8|@]|9|@]|A|$E|F]]|$1|U|3|V|5|6|7|1F|8|@$W|1G|X|1H|Y|Z]|$W|1I|X|1J|Y|Z]]|9|@]|A|$]]|$1|10|3|11|5|6|7|1K|8|@]|9|@]|A|$]]|$1|12|3|13|5|D|7|1L|8|@]|9|@]|A|$E|F]]|$1|14|3|-4|5|6|7|1M|8|@]|9|@]|A|$]]]|15|$]]

You pass a (mutable) dictionary reference to an object. Now, you have two owners of the reference: the caller of the constructor (the "external world" for the object) and the object itself. These two owners may modify the dictionary. Here is an illustration:

<pre><code>&gt;&gt;&gt; d = {}
&gt;&gt;&gt; def ctor(d): return [d] # just build a list with one element
&gt;&gt;&gt; L = ctor(d)
&gt;&gt;&gt; d[1] = 2
&gt;&gt;&gt; L
[{1: 2}]
&gt;&gt;&gt; L[0][3] = 4
&gt;&gt;&gt; d
{1: 2, 3: 4}
</code></pre>

How do you prevent this? Both owners want to protect themselves from wild mutation of their variables. If I were the external world, I would like to pass an immutable reference to the dict, but Python does not provide immutable references for dicts. A copy is the way to go:

<pre><code>&gt;&gt;&gt; d = {}
&gt;&gt;&gt; L = ctor(dict(d)) # I don't give you *my* d
&gt;&gt;&gt; d[1] = 2
&gt;&gt;&gt; L
[{}]
</code></pre>

If I were the object, I would do a copy of the object before using it:

<pre><code>&gt;&gt;&gt; d = {}
&gt;&gt;&gt; def ctor2(d): return [dict(d)] # to be sure L[0] is *mine*!
&gt;&gt;&gt; L = ctor2(dict(d)) # I don't give you *my* d
</code></pre>

But now you have made two copies of the object just because everyone is scared to see its variables modified by the other. And the issue is still here if the dictionary contains (mutable) references.

The solution is to spell out the responsibilities of each one:

<pre><code>class MyClass(object):
 """Usage: MyClass(attributes).do_something() where attributes is a mapping.
 The mapping won't be modified"""
 ...
</code></pre>

Note that this is the common expected behavior: unless specified, the arguments of a function/contructor are not modified. We avoid side effect when possible, but that's not always the case: see <code>list.sort()</code> vs <code>sorted(...)</code>.

Hence I think your solution is good. But I prefer to avoid too much logic in the constructor:

<pre><code>class MyClass(object):
 @staticmethod
 def create_prod(attributes):
 attributes = dict(attributes)
 attributes.update({"test": False})
 return MyClass(attributes)

 @staticmethod
 def create_test(attributes):
 return MyClass(attributes)

 def __init__(self, attributes):
 self._attributes = attributes # MyClass won't modify attributes
</code></pre>

I have a class object that receives some data. Based on a condition, I need that data to change, but only under that condition. Problem I'm running into is that when I call <code>dict.update()</code> , it updates the original variable too. So a subsequent request comes in, and now that original variable is "tainted" so to speak, and is using overridden information that it shouldn't have.

Assuming a dictionary like this:

<pre><code>my_attributes = {"test": True}
</code></pre>

And some logic like this:

<pre><code>class MyClass(object):

 def __init__(self, attributes):
 if my_condition():
 attributes.update({"test": False})
</code></pre>

The end result:

<pre><code>&gt;&gt;&gt; my_attributes
{'test': False}
</code></pre>

So, the next time <code>MyClass</code> is used, those root attributes are still overridden. 

I've seemingly gotten around this problem by re-defining <code>attributes</code>:

<pre><code>class MyClass(object):

 def __init__(self, attributes):
 if my_condition():
 attributes = {}
 attributes.update(my_attributes)
 attributes.update({"test": False})
</code></pre>

This has seemed to get around the problem, but I'm not entirely sure this is a good, or even the right, solution to the issue.

Updating a dictionary privately?

我有一个接收一些数据的类对象。基于一个条件，我需要更改该数据，但仅在该条件下。我遇到的问题是，当我调用dict.update()时，它也会更新原始变量。因此，随后的请求进入，现在可以说，原始变量被“污染”了，并且使用了它不应该具有的覆盖信息。假设字典是这样的：my_attributes = {"test": True}...

问私下更新字典？
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问私下更新字典？EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问私下更新字典？
EN