安全地从字典中删除多个键

我知道d安全地从字典中删除条目“键” ，您可以这样做：

if d.has_key('key'):
    del d['key']

但是，我需要安全地从字典中删除多个条目。我正在考虑在元组中定义条目，因为我将需要多次执行此操作。

entitiesToREmove = ('a', 'b', 'c')
for x in entitiesToRemove:
    if d.has_key(x):
        del d[x]

但是，我想知道是否有更聪明的方法来做到这一点？

为什么不这样：

entries = ('a', 'b', 'c')
the_dict = {'b': 'foo'}

def entries_to_remove(entries, the_dict):
    for key in entries:
        if key in the_dict:
            del the_dict[key]

mattbornski使用dict.pop（）提供了一个更紧凑的版本

d = {'some':'data'}
entriesToRemove = ('any', 'iterable')
for k in entriesToRemove:
    d.pop(k, None)

使用词典理解

final_dict = {key: t[key] for key in t if key not in [key1, key2]}

其中key1和key2将被删除。

在下面的示例中，将删除键“ b”和“ c”并将其保存在键列表中。

>>> a
{'a': 1, 'c': 3, 'b': 2, 'd': 4}
>>> keys = ["b", "c"]
>>> print {key: a[key] for key in a if key not in keys}
{'a': 1, 'd': 4}
>>> 

解决方案正在使用map和filter起作用

蟒蛇2

d={"a":1,"b":2,"c":3}
l=("a","b","d")
map(d.__delitem__, filter(d.__contains__,l))
print(d)

蟒蛇3

d={"a":1,"b":2,"c":3}
l=("a","b","d")
list(map(d.__delitem__, filter(d.__contains__,l)))
print(d)

你得到：

{'c': 3}

如果还需要检索要删除的键的值，这将是一个很好的方法：

valuesRemoved = [d.pop(k, None) for k in entitiesToRemove]

当然，您仍然可以仅从中删除键来执行此操作d，但是您将不必要使用列表理解来创建值列表。只是为了函数的副作用而使用列表理解也有点不清楚。

发现用溶液pop和map

d = {'a': 'valueA', 'b': 'valueB', 'c': 'valueC', 'd': 'valueD'}
keys = ['a', 'b', 'c']
list(map(d.pop, keys))
print(d)

此输出：

{'d': 'valueD'}

我这么晚才回答了这个问题，只是因为我认为如果有人进行搜索，将来会有所帮助。这可能会有所帮助。

更新资料

如果字典中不存在键，则以上代码将引发错误。

DICTIONARY = {'a': 'valueA', 'b': 'valueB', 'c': 'valueC', 'd': 'valueD'}
keys = ['a', 'l', 'c']

def remove_keys(key):
    try:
        DICTIONARY.pop(key, None)
    except:
        pass  # or do any action

list(map(remove_key, keys))
print(DICTIONARY)

输出：

DICTIONARY = {'b': 'valueB', 'd': 'valueD'}

任何现有的答案我都没有问题，但是我很惊讶没有找到这个解决方案：

keys_to_remove = ['a', 'b', 'c']
my_dict = {k: v for k, v in zip("a b c d e f g".split(' '), [0, 1, 2, 3, 4, 5, 6])}

for k in keys_to_remove:
    try:
        del my_dict[k]
    except KeyError:
        pass

assert my_dict == {'d': 3, 'e': 4, 'f': 5, 'g': 6}

注：我碰到这个问题，从跌跌撞撞来这里。我的答案与此答案有关。

为什么不：

entriestoremove = (2,5,1)
for e in entriestoremove:
    if d.has_key(e):
        del d[e]

我不知道您所说的“更聪明的方式”。当然，还有其他方法，也许是对字典的理解：

entriestoremove = (2,5,1)
newdict = {x for x in d if x not in entriestoremove}

排队

import functools

#: not key(c) in d
d = {"a": "avalue", "b": "bvalue", "d": "dvalue"}

entitiesToREmove = ('a', 'b', 'c')

#: python2
map(lambda x: functools.partial(d.pop, x, None)(), entitiesToREmove)

#: python3

list(map(lambda x: functools.partial(d.pop, x, None)(), entitiesToREmove))

print(d)
# output: {'d': 'dvalue'}

对cpython 3的一些计时测试表明，简单的for循环是最快的方法，并且可读性强。添加一个函数也不会导致太多开销：

timeit结果（10000次迭代）：

• all(x.pop(v) for v in r) # 0.85
• all(map(x.pop, r)) # 0.60
• list(map(x.pop, r)) # 0.70
• all(map(x.__delitem__, r)) # 0.44
• del_all(x, r) # 0.40
• <inline for loop>(x, r) # 0.35

def del_all(mapping, to_remove):
      """Remove list of elements from mapping."""
      for key in to_remove:
          del mapping[key]

对于小迭代，由于函数调用的开销，执行“内联”要快一些。但是，del_all它比所有python理解和映射结构都更安全，可重用并且运行速度更快。

我认为，如果您使用的是python 3，最好将键视为一个集合：

def remove_keys(d, keys):
    to_remove = set(keys)
    filtered_keys = d.keys() - to_remove
    filtered_values = map(d.get, filtered_keys)
    return dict(zip(filtered_keys, filtered_values))

例：

>>> remove_keys({'k1': 1, 'k3': 3}, ['k1', 'k2'])
{'k3': 3}

完全支持字典的set方法（而不是我们在Python 3.9中遇到的麻烦）是很好的，这样您就可以简单地“删除”一组键。但是，只要不是这种情况，并且您有一个大型词典并且可能要删除大量键，则可能需要了解性能。因此，我创建了一些代码，该代码创建的大小足以进行有意义的比较：100,000 x 1000矩阵，因此总共10,000,00个项目。

from itertools import product
from time import perf_counter

# make a complete worksheet 100000 * 1000
start = perf_counter()
prod = product(range(1, 100000), range(1, 1000))
cells = {(x,y):x for x,y in prod}
print(len(cells))

print(f"Create time {perf_counter()-start:.2f}s")
clock = perf_counter()
# remove everything above row 50,000

keys = product(range(50000, 100000), range(1, 100))

# for x,y in keys:
#     del cells[x, y]

for n in map(cells.pop, keys):
    pass

print(len(cells))
stop = perf_counter()
print(f"Removal time {stop-clock:.2f}s")

在某些情况下，1000万个或更多的项目并不罕见。比较本地计算机上的这两种方法，我发现使用map和时会略有改善pop，大概是因为调用的函数较少，但是这两种方法在我的计算机上大约需要2.5秒的时间。但这与首先创建字典（55s）或在循环中包括检查所需的时间相比显得苍白。如果可能，那么最好创建一个集合，该集合是字典键和过滤器的交集：

keys = cells.keys() & keys

总结：del已经进行了优化，所以不用担心使用它。

我迟到了这个讨论，但对于其他人。解决方案可以是这样创建键列表。

k = ['a','b','c','d']

然后在列表推导或for循环中使用pop（）遍历这些键，并一次弹出一个键。

new_dictionary = [dictionary.pop(x, 'n/a') for x in k]

如果密钥不存在，则“ n / a”，则需要返回默认值。