Безопасное удаление нескольких ключей из словаря

Я знаю, что нужно безопасно удалить запись «ключ» из моего словаря 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]

Более компактная версия была предоставлена ​​маттборнски с использованием 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'}

Я ответил на этот вопрос так поздно только потому, что думаю, что в будущем это поможет, если кто-то будет искать то же самое. И это может помочь.

Обновить

Приведенный выше код выдаст ошибку, если ключ не существует в dict.

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

Было бы неплохо иметь полную поддержку методов набора для словарей (а не того нечестивого беспорядка, который мы получаем с Python 3.9), чтобы вы могли просто «удалить» набор ключей. Однако, если это не так, и у вас есть большой словарь с потенциально большим количеством ключей, которые нужно удалить, вы можете узнать о производительности. Итак, я создал код, который создает что-то достаточно большое для значимых сравнений: матрица 100 000 x 1000, итого 10 000 000 элементов.

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")

10 миллионов элементов и более - обычное дело для некоторых настроек. Сравнивая два метода на моем локальном компьютере, я вижу небольшое улучшение при использовании mapи pop, предположительно из-за меньшего количества вызовов функций, но оба метода на моем компьютере занимают около 2,5 с. Но это меркнет по сравнению со временем, необходимым для создания словаря в первую очередь (55 с) или включением проверок в цикле. Если это вероятно, лучше всего создать набор, который является пересечением ключей словаря и вашего фильтра:

keys = cells.keys() & keys

В итоге: delон уже сильно оптимизирован, поэтому не беспокойтесь об его использовании.

Я опаздываю на это обсуждение, но для всех остальных. Решением может быть создание списка ключей как такового.

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

Затем используйте pop () в понимании списка или в цикле for, чтобы перебирать ключи и выскакивать по одному как таковые.

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

«Н / п» означает, что если ключ не существует, необходимо вернуть значение по умолчанию.