迭代 Python 字典时修改它

Question

假设我们有一个 Python 字典 d，我们像这样迭代它：

for k,v in d.iteritems():
    del d[f(k)] # remove some item
    d[g(k)] = v # add a new item

（f 和 g 只是一些黑盒转换。）

换句话说，我们尝试向d 添加/删除项目，同时使用iteritems 对其进行迭代。

这是明确定义的吗？您能否提供一些参考资料来支持您的回答？

（很明显，如果它坏了如何解决这个问题，所以这不是我想要的角度。）

Answer 1

您不能这样做，至少对于 d.iteritems()。我试过了，Python 失败了

RuntimeError: dictionary changed size during iteration

如果您改为使用d.items()，那么它可以工作。

在 Python 3 中，d.items() 是字典的视图，类似于 Python 2 中的 d.iteritems()。要在 Python 3 中执行此操作，请改用 d.copy().items()。这同样允许我们迭代字典的副本，以避免修改我们正在迭代的数据结构。

Answer 2

下面的代码表明这不是很好的定义：

def f(x):
    return x

def g(x):
    return x+1

def h(x):
    return x+10

try:
    d = {1:"a", 2:"b", 3:"c"}
    for k, v in d.iteritems():
        del d[f(k)]
        d[g(k)] = v+"x"
    print d
except Exception as e:
    print "Exception:", e

try:
    d = {1:"a", 2:"b", 3:"c"}
    for k, v in d.iteritems():
        del d[f(k)]
        d[h(k)] = v+"x"
    print d
except Exception as e:
    print "Exception:", e

第一个示例调用 g(k)，并抛出异常（迭代期间字典大小改变）。

第二个例子调用 h(k) 并没有抛出异常，但是输出：

{21: 'axx', 22: 'bxx', 23: 'cxx'}

查看代码，这似乎是错误的 - 我本来希望是这样的：

{11: 'ax', 12: 'bx', 13: 'cx'}

Answer 3

Alex Martelli 对此here 发表意见。

在循环容器时更改容器（例如 dict）可能不安全。 所以del d[f(k)] 可能不安全。如您所知，解决方法是使用d.items()（循环遍历容器的独立副本）而不是d.iteritems()（使用相同的底层容器）。

可以在字典的现有索引处修改值，但在新索引处插入值（例如d[g(k)]=v）可能不起作用。

Answer 4

在 Python 文档页面（Python 2.7）上明确提到

在字典中添加或删除条目时使用iteritems() 可能会引发RuntimeError 或无法遍历所有条目。

Python 3 也是如此。

iter(d)、d.iterkeys() 和 d.itervalues()如果实现调用iter(d) 不会感到惊讶）。

Answer 5

我遇到了同样的问题，我使用以下程序解决了这个问题。

Python List 可以被迭代，即使你在迭代它的过程中进行了修改。 因此对于以下代码，它将无限打印 1。

for i in list:
   list.append(1)
   print 1

所以list和dict协同使用就可以解决这个问题。

d_list=[]
 d_dict = {} 
 for k in d_list:
    if d_dict[k] is not -1:
       d_dict[f(k)] = -1 # rather than deleting it mark it with -1 or other value to specify that it will be not considered further(deleted)
       d_dict[g(k)] = v # add a new item 
       d_list.append(g(k))

Answer 6

我有一个包含 Numpy 数组的大字典，所以 @murgatroid99 建议的 dict.copy().keys() 东西是不可行的（尽管它有效）。相反，我只是将 keys_view 转换为列表，它工作正常（在 Python 3.4 中）：

for item in list(dict_d.keys()):
    temp = dict_d.pop(item)
    dict_d['some_key'] = 1  # Some value

我意识到这并没有像上面的答案那样深入 Python 内部工作的哲学领域，但它确实为所述问题提供了实用的解决方案。

Answer 7

今天我有一个类似的用例，但不是简单地在循环开始时将字典上的键具体化，而是希望更改字典以影响字典的迭代，这是一个有序字典。

我最终构建了以下例程，也可以是found in jaraco.itertools：

def _mutable_iter(dict):
    """
    Iterate over items in the dict, yielding the first one, but allowing
    it to be mutated during the process.
    >>> d = dict(a=1)
    >>> it = _mutable_iter(d)
    >>> next(it)
    ('a', 1)
    >>> d
    {}
    >>> d.update(b=2)
    >>> list(it)
    [('b', 2)]
    """
    while dict:
        prev_key = next(iter(dict))
        yield prev_key, dict.pop(prev_key)

文档字符串说明了用法。这个函数可以用来代替上面的d.iteritems()来达到预期的效果。

Answer 8

Python 3 你应该：

prefix = 'item_'
t = {'f1': 'ffw', 'f2': 'fca'}
t2 = dict() 
for k,v in t.items():
    t2[k] = prefix + v

或使用：

t2 = t1.copy()

你不应该修改原始字典，它会导致混乱以及潜在的错误或 RunTimeErrors。除非你只是用新的键名附加到字典中。

Answer 9

这个问题是关于使用迭代器（很有趣，Python 3 不再支持 Python 2 .iteritems 迭代器） 来删除或添加项目，并且 它必须有No 作为唯一正确答案，您可以在接受的答案中找到它。然而：大多数搜索者试图找到一个解决方案，他们不会关心这是如何在技术上完成的，无论是迭代器还是递归，有解决问题的方法：

您不能在不使用附加（递归）函数的情况下循环更改字典。

因此，该问题应与具有有效解决方案的问题相关联：

• How can I remove a key:value pair wherever the chosen key occurs in a deeply nested dictionary? (= "删除")

• 也很有帮助，因为它显示了如何在运行中更改 dict 的项目：How can I replace a key:value pair by its value wherever the chosen key occurs in a deeply nested dictionary? (= "replace")。

通过相同的递归方法，您还可以根据问题的要求添加项目。

---

由于我链接此问题的请求被拒绝，这里是可以从字典中删除项目的解决方案的副本。请参阅 How can I remove a key:value pair wherever the chosen key occurs in a deeply nested dictionary? (= "delete") 获取示例/学分/注释。

import copy

def find_remove(this_dict, target_key, bln_overwrite_dict=False):
    if not bln_overwrite_dict:
        this_dict = copy.deepcopy(this_dict)

    for key in this_dict:
        # if the current value is a dict, dive into it
        if isinstance(this_dict[key], dict):
            if target_key in this_dict[key]:
                this_dict[key].pop(target_key)

            this_dict[key] = find_remove(this_dict[key], target_key)

    return this_dict

dict_nested_new = find_remove(nested_dict, "sub_key2a")

诀窍

诀窍是在递归到达子级别之前提前找出 target_key 是否在下一个子级中（= this_dict[key] = 当前 dict 迭代的值）。只有这样，您仍然可以在遍历字典时删除子级别的键：值对。一旦您达到与要删除的密钥相同的级别，然后尝试从那里删除它，您将收到错误消息：

RuntimeError: dictionary changed size during iteration

递归解决方案仅对下一个值的子级别进行任何更改，因此避免了错误。