Removendo várias chaves de um dicionário com segurança

Sei que para remover uma entrada, 'chave' do meu dicionário d, com segurança, você faz:

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

No entanto, preciso remover várias entradas do dicionário com segurança. Eu estava pensando em definir as entradas em uma tupla, pois precisarei fazer isso mais de uma vez.

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

No entanto, eu queria saber se existe uma maneira mais inteligente de fazer isso?

Por que não assim:

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]

Uma versão mais compacta foi fornecida por mattbornski usando dict.pop ()

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

Usando Compreensões de Dict

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

onde key1 e key2 devem ser removidos.

No exemplo abaixo, as teclas "b" e "c" devem ser removidas e mantidas em uma lista de chaves.

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

uma solução está usando mape filterfunciona

python 2

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

python 3

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

você obtém:

{'c': 3}

Se você também precisar recuperar os valores para as chaves que está removendo, seria uma boa maneira de fazê-lo:

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

Obviamente, você ainda pode fazer isso apenas para a remoção das chaves d, mas criaria desnecessariamente a lista de valores com a compreensão da lista. Também é um pouco obscuro usar uma compreensão de lista apenas para o efeito colateral da função.

Encontrou uma solução com popemap

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

A saída disso:

{'d': 'valueD'}

Eu respondi a essa pergunta tão tarde apenas porque acho que ajudará no futuro se alguém pesquisar a mesma. E isso pode ajudar.

Atualizar

O código acima gerará um erro se uma chave não existir no 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)

resultado:

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

Não tenho nenhum problema com nenhuma das respostas existentes, mas fiquei surpreso ao não encontrar esta solução:

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}

Nota: Eu me deparei com essa pergunta vindo daqui . E minha resposta está relacionada a essa resposta .

Por que não:

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

Não sei o que você quer dizer com "maneira mais inteligente". Certamente existem outras maneiras, talvez com compreensão de dicionário:

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

na linha

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

Alguns testes de tempo para o cpython 3 mostram que um loop for simples é o caminho mais rápido e é bastante legível. A adição de uma função também não causa muita sobrecarga:

timeit resulta (10k iterações):

• 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]

Para pequenas iterações, fazer isso 'inline' era um pouco mais rápido, devido à sobrecarga da chamada de função. Mas del_allé seguro para fiapos, reutilizável e mais rápido do que todas as construções de compreensão e mapeamento de python.

Eu acho que usar o fato de que as chaves podem ser tratadas como um conjunto é a melhor maneira se você estiver no 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))

Exemplo:

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

Seria bom ter suporte completo para métodos definidos para dicionários (e não para a bagunça profana que estamos enfrentando no Python 3.9), para que você possa simplesmente "remover" um conjunto de chaves. No entanto, desde que não seja esse o caso, e você tenha um dicionário grande com um número potencialmente grande de chaves para remover, convém saber sobre o desempenho. Então, eu criei um código que cria algo grande o suficiente para comparações significativas: uma matriz de 100.000 x 1000, portanto, 10.000,00 itens no total.

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 milhões de itens ou mais não é incomum em algumas configurações. Comparando os dois métodos na minha máquina local, vejo uma ligeira melhora ao usar mape pop, presumivelmente por causa de menos chamadas de função, mas ambas demoram cerca de 2,5 segundos na minha máquina. Mas isso empalidece em comparação com o tempo necessário para criar o dicionário (55s), ou incluindo verificações dentro do loop. Se isso for provável, é melhor criar um conjunto que seja uma interseção das chaves do dicionário e do seu filtro:

keys = cells.keys() & keys

Em resumo: deljá está fortemente otimizado, portanto, não se preocupe em usá-lo.

Estou atrasado para esta discussão, mas para qualquer outra pessoa. Uma solução pode ser criar uma lista de chaves como tal.

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

Em seguida, use pop () em uma lista de compreensão, ou for loop, para iterar sobre as teclas e pop uma de cada vez, como tal.

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

O 'n / a' está no caso de a chave não existir, um valor padrão precisa ser retornado.