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

Question

我知道要从我的字典中删除一个条目"key" 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]

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

Answer 1

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

Answer 2

使用Dict理解

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}
>>> 

Answer 3

为什么不这样:

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()提供了更紧凑的版本

Answer 4

解决方案是使用map和filter功能

python 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}

Answer 5

如果您还需要检索要删除的键的值,这将是一个非常好的方法:

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

您当然可以仅仅为了删除密钥d而执行此操作,但是您将不必要地使用列表推导创建值列表.仅仅为了函数的副作用使用列表理解也有点不清楚.

Answer 6

找到了一个解决方案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'}

Answer 7

我测试了三种方法的性能：

# Method 1: `del`
for key in remove_keys:
    if key in d:
        del d[key]

# Method 2: `pop()`
for key in remove_keys:
    d.pop(key, None)

# Method 3: comprehension
{key: v for key, v in d.items() if key not in remove_keys}

以下是 1M 次迭代的结果：

1. del：2.03s 2.0 ns/iter (100%)
2. pop()：2.38s 2.4 ns/iter (117%)
3. 理解：4.11s 4.1 ns/iter (202%)

所以 和del都是pop()最快的。理解速度慢 2 倍。但无论如何，我们在这里说的是纳秒:) Python 中的字典速度快得离谱。

Answer 8

cpython 3 的一些计时测试表明，简单的 for 循环是最快的方法，并且非常易读。添加一个函数也不会造成太多开销：

timeit 结果（10k 次迭代）：

• 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_alllint 安全、可重用，并且比所有 python 理解和映射构造更快。

Answer 9

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

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}

注意：我从这里偶然发现了这个问题。我的答案与这个答案有关。