相关疑难解决方法(0)

有没有办法从Python中删除字典中的项目？

另外,如何从字典中删除项目以返回副本(即,不修改原始文件)？

我想dict在python中制作一个深层副本.不幸的是,该.deepcopy()方法不存在dict.我怎么做？

>>> my_dict = {'a': [1, 2, 3], 'b': [4, 5, 6]}
>>> my_copy = my_dict.deepcopy()
Traceback (most recent calll last):
  File "<stdin>", line 1, in <module>
AttributeError: 'dict' object has no attribute 'deepcopy'
>>> my_copy = my_dict.copy()
>>> my_dict['a'][2] = 7
>>> my_copy['a'][2]
7

最后一行应该是3.

我希望这些修改my_dict不会影响快照my_copy.

我怎么做？该解决方案应与Python 3.x兼容.

我对以下行为感到非常困惑.案例1,3和4按我的预期执行,但案例2没有.为什么案例2允许函数全局更改字典条目的值,即使该函数从未返回字典？我使用函数的一个主要原因是将函数中的所有内容与其余代码隔离开来,但如果我选择在函数内部使用相同的变量名称,这似乎是不可能的.我理解在函数中明确定义的任何东西都是该函数的本地函数,但如果字典被定义并作为函数的输入传递,则情况似乎并非如此.

Python 2.7.2+ (default, Oct  4 2011, 20:06:09) 
[GCC 4.6.1] on linux2
Type "help", "copyright", "credits" or "license" for more information.

=============案例1 ===============

>>> def testfun1(a):
...     a=2
... 
>>> a=0
>>> testfun1(a)
>>> a
0

=============案例2 ===============

>>> def testfun2(b):
...     b['test']=2
... 
>>> b={}
>>> testfun2(b)
>>> b
{'test': 2}

=============案例3 ===============

>>> def testfun3():
...     c=2
... 
>>> c=0
>>> testfun3()
>>> c
0

=============案例4 ===============(由这个问题解释:全局词典不需要关键字全局来修改它们吗？)

>>> def testfun4():
...     d['test']=10
... 
>>> …

我希望以在程序初始化代码中只设置一次的方式控制全局变量(或全局范围变量),并在此之后锁定它们.

我使用UPPER_CASE_VARIABLES作为全局变量,但我想确定无论如何都不要更改变量.

• python是否提供该(或类似)功能？
• 你如何控制全局范围的变量？

我不明白这些情况:

content = {'a': {'v': 1}, 'b': {'v': 2}}
d1 = {'k1': {}}
d2 = {'k2': {}}
d1['k1'].update(content)
print(d1)
content['a']['v'] = 3
content['b']['v'] = 4
d2['k2'].update(content)
print(d2)
print(d1)
>>> {'k1': {'a': {'v': 1}, 'b': {'v': 2}}}
>>> {'k2': {'a': {'v': 3}, 'b': {'v': 4}}}
>>> {'k1': {'a': {'v': 3}, 'b': {'v': 4}}}

在上述情况下,在更新可变内容之后改变d1的内容.

content = {'a': 1, 'b': 2}
d1 = {'k1': {}}
d2 = {'k2': {}}
d1['k1'].update(content)
print(d1)
content['a'] = 3
content['b'] = 4
d2['k2'].update(content) …

我尝试在代码的开头存储一个词典模板，大多数功能将使用该模板：

• 字典：键=客户名称，值=字典2
• Dictionary2：键=用户名，值=无

我把所有的客户和他们的用户都塞满了。然后，代码的每个部分都可以复制此字典并产生其自己的输出。目标是每个输出将具有相同的“基本”字典结构，如模板，在其中可以修改“无”。

对于使用此词典的每个过程，我使用以下内容：

process1dict = clientdict 
# processing 1
output1dict = ... #modified version of original clientdict, the None values have been replaced by dictionaries/lists

process2dict = clientdict
# processing 2
output2dict = ... #same here but could be different

我的问题是，每次复制到流程中时，先后顺序都会改变！我注意到由于None初始值的cliendict变化，它在每个过程之后都会改变（取决于每个过程的输出）。

编辑：我找到了副本库，但copy()似乎无济于事。我将尝试使用deepcopy（），但是为什么copy()不起作用？为什么deepcopy()会呢？

使用词典时如何避免以下情况

a={'b':1}
c=a
c.update({'b':2})
print a # {'b':2}
print c # {'b':2}

我有一个嵌套的字典，我们称它为字典d。该词典的键是一个整数，每个键的值是另一个词典。我正在python 2.7上尝试一个简单的代码来更新一个外键的值，但是似乎它正在更新外键的ALL的值。

希望这些代码将使其更易于理解。这是我的意见。

>>> template = {'mean':0,'median':0}
>>> d[0] = template
>>> d[1] = template
>>> d[0]['mean'] = 1
>>> d

然后是输出：

{0: {'mean':1, 'median':0}, 1:{'mean':1,'median':0}}

您会看到，我只为d [0] ['mean']分配了'1'，但是d [1] ['mean']也有所更新。如果我增加d中的键数，它将仅更改所有d键上的所有['mean']值。

我在这里做错什么吗？这是错误吗？

我来自C,学习Python.在Python(3.5.2)中,似乎将一种数据类型分配给同一类型的另一种数据类型有时通过值来完成,有时通过引用来完成.

例如,字符串按值分配:

>>> str1 = "hello"
>>> str2 = str1
>>> print(str1, str2)
hello hello
>>> str2 = "goodbye"
>>> print(str1, str2)
hello goodbye

这是我期望的行为.但是,它与字典的工作方式不同:

>>> dict1 = {'key1':'val1', 'key2':'val2'}
>>> dict2 = dict1
>>> print(dict1, dict2)
{'key2': 'val2', 'key1': 'val1'} {'key2': 'val2', 'key1': 'val1'}
>>> dict2['key1'] = 'newval'
>>> print(dict1, dict2)
{'key2': 'val2', 'key1': 'newval'} {'key2': 'val2', 'key1': 'newval'}

请注意,两个dict1 和 dict2发生了变化.同样,如果我将键/值对添加到其中一个词典中,它将同时出现在两个词典中.哎呀!

(对不起,这是我的C-background讲话):)

我如何知道任何给定变量类型的行为？有这种疯狂的方法还是我只需要记住任意规则？

PS我意识到我可以通过使用获得我预期的行为dict2 = dict(dict1).

在"可能重复"包含良好的信息如何做到这一点,但我感兴趣的是,为什么我不得不这样做.这个问题的答案已经非常有用了!

我有一个数据表如下:

      A  B  C
type1 A1 B1 C1
type2 A2 B2 C2

我使用下面的代码

d={}
D={}
h = ['A','B','C']
type1=['A1','B1','C1']
type2=['A2','B2','C2']

for i,val in enumerate(h):

    d['Type1'] = type1[i]
    d['Type2'] = type2[i]
    D[val]=d
    print('loop',i,'\nd:',d,'\nD:',D,'\n\n====')

#print(D)

我希望得到以下dict作为结果:

{'A':{'Type1':'A1','Type2':'A2'},'B':{'Type1':'B1','Type2':B2},'C':{'Type1':C1,'Type2':'C2'},}

但是,输出是:

{'A': {'Type1': 'C1', 'Type2': 'C2'}, 'B': {'Type1': 'C1', 'Type2': 'C2'}, 'C': {'Type1': 'C1', 'Type2': 'C2'}}

我逻辑中的错误是什么？

我无法弄清楚那里有什么问题.

我在循环中添加了一个打印件.

loop 0 
d: {'Type1': 'A1', 'Type2': 'A2'} 
D: {'A': {'Type1': 'A1', 'Type2': 'A2'}} 

====
loop 1 
d: {'Type1': 'B1', 'Type2': 'B2'} 
D: {'A': {'Type1': 'B1', 'Type2': …