15

我想在字典中弹出所有大值及其键，并保留最小的。这是我的程序的一部分

for key,value in dictionary.items():
    for key1, value1 in dictionary.items(): 
            if key1!= key and value > value1:
                dictionary.pop(key)             
    print (dictionary)

这导致

RuntimeError: dictionary changed size during iteration

我怎样才能避免这个错误？

4

9 回答 9

14

在 Python3 中，尝试

for key in list(dict.keys()):
    if condition:
        matched
        del dict[key]

循环 dict 以更新其密钥时，还应注意 1 件事：

代码1：

keyPrefix = ‘keyA’
for key, value in Dict.items():
    newkey = ‘/’.join([keyPrefix, key])
    Dict[newkey] = Dict.pop(key)

代码2：

keyPrefix = ‘keyA’
for key, value in Dict.keys():
    newkey = ‘/’.join([keyPrefix, key])
    Dict[newkey] = Dict.pop(key)

code1/code2 的结果是：

{‘keyA/keyA/keyB’ : ”, ‘keyA/keyA/keyA’: ”}

我解决这个意外结果的方法：

    Dict = {‘/’.join([keyPrefix, key]): value for key, value in Dict.items()}

链接：https ://blog.gainskills.top/2016/07/21/loop-a-dict-to-update-key/

于 2015-09-23T06:38:17.880 回答
13

替代解决方案

如果您正在寻找字典中的最小值，您可以这样做：

min(dictionary.values())

如果不能使用 min，则可以使用 sorted：

sorted(dictionary.values())[0]

为什么我会收到此错误？

在旁注中，您遇到的原因Runtime Error是在内部循环中您修改了外部循环所基于的迭代器。当pop外部循环尚未到达的条目并且外部迭代器到达它时，它会尝试访问已删除的元素，从而导致错误。
如果你尝试在 Python 2.7（而不是 3.x）上执行你的代码，实际上你会得到一个Key Error.

我该怎么做才能避免错误？

如果要根据迭代器修改循环内的可迭代对象，则应使用它的深层副本。

于 2012-11-22T20:55:54.793 回答
6

您可以使用copy.deepcopy制作原始字典的副本，在更改原始字典时循环复制副本。

from copy import deepcopy

d=dict()
for i in range(5):
    d[i]=str(i)

k=deepcopy(d)

d[2]="22"
print(k[2])
#The result will be 2.

你的问题是迭代你正在改变的东西。

于 2012-11-22T21:02:49.590 回答
2

在循环期间记录密钥，然后在循环完成时执行 dictionary.pop(key) 。像这样：

for key,value in dictionary.items():
    for key1, value1 in dictionary.items(): 
            if key1!= key and value > value1:
                storedvalue = key
    dictionary.pop(key)
于 2012-11-22T20:37:49.297 回答
2

这是解决它的一种方法：

  1. 从字典中，得到一个键列表，按值排序
  2. 由于此列表中的第一个键具有最小值，因此您可以使用它做任何您想做的事情。

这是一个示例：

# A list of grades, not in any order
grades = dict(John=95,Amanda=89,Jake=91,Betty=97)

# students is a list of students, sorted from lowest to highest grade
students = sorted(grades, key=lambda k: grades[k])

print 'Grades from lowest to highest:'
for student in students:
    print '{0} {1}'.format(grades[student], student)

lowest_student = students[0]
highest_student = students[-1]
print 'Lowest grade of {0} belongs to {1}'.format(grades[lowest_student], lowest_student)
print 'Highest grade of {0} belongs to {1}'.format(grades[highest_student], highest_student)

这里的秘诀在于 sorted() 函数：我们不是按键排序，而是按值排序。

于 2012-11-22T20:57:05.880 回答
0

当我现在阅读您的循环时，您希望只保留单个最小元素，但不使用min. 因此，与您的代码现在执行的操作相反，检查是否 value1 < minValueSoFar，如果是，请将 key1 保持为 minKeySoFar。然后在循环结束时（如 Zayatzz 建议的那样），执行dictionary.pop(minKeySoFar)

顺便说一句，我注意到key1!=key假设一个相当长的列表，测试是不相关的并且计算效率低下。

minValueSoFar = 9999999;   # or whatever
for key,value in dictionary.items():
    if value < minValueSoFar:
        minValueSoFar = value
        minKeySoFar = key
dictionary.pop(minKeySoFar)   # or whatever else you want to do with the result
于 2012-11-22T20:48:00.763 回答
0

如果您只想保留具有最小值的键，我会首先找到该项目，然后创建一个仅包含它的新字典。如果你的字典是d，这样的事情会在一行中完成：

d = dict((min(d.items(), key=lambda item: item[1]),))

这不仅可以避免在迭代字典时更新字典的任何问题，而且可能比删除所有其他元素更快。

如果您出于某种原因必须就地进行修改，则以下方法会起作用，因为它会在修改字典之前复制所有键：

key_to_keep = min(d.items(), key=lambda item: item[1])[0]

for key in list(d):
    if key != key_to_keep:
        d.pop(key)
于 2012-11-22T21:09:36.977 回答
0

迭代期间字典更改大小的替代解决方案：

for key,value in list(dictionary.items()):
    for key1, value1 in list(dictionary.items()): 
            if key1!= key and value > value1:
                dictionary.pop(key)             
print (dictionary)

最好谨慎使用！使用此类代码时，因为list(dictionary.items())在编译器第一次进入循环时计算。因此，对字典所做的任何更改都不会影响当前循环内的进程。

于 2019-12-05T06:44:00.863 回答
0

您可以使用要删除的值创建一个列表，然后运行第二个 for 循环：

for entry in (listofkeystopop):
        dictionary.pop(entry)
于 2021-01-13T22:09:39.140 回答