Rimozione sicura di più chiavi da un dizionario

So che per rimuovere una voce, 'chiave' dal mio dizionario d, in modo sicuro, fai:

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

Tuttavia, devo rimuovere più voci dal dizionario in modo sicuro. Stavo pensando di definire le voci in una tupla poiché avrò bisogno di farlo più di una volta.

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

Tuttavia, mi chiedevo se esiste un modo più intelligente per farlo?

Perché non così:

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]

Una versione più compatta è stata fornita da mattbornski usando dict.pop ()

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

Utilizzo di Dict Comprehensions

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

dove key1 e key2 devono essere rimossi.

Nell'esempio seguente, le chiavi "b" e "c" devono essere rimosse e vengono mantenute in un elenco di chiavi.

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

una soluzione sta usando mape filterfunzioni

pitone 2

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

pitone 3

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

ottieni:

{'c': 3}

Se hai anche bisogno di recuperare i valori per le chiavi che stai rimuovendo, questo sarebbe un buon modo per farlo:

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

Ovviamente potresti ancora farlo solo per la rimozione delle chiavi da d, ma creeresti inutilmente l'elenco di valori con la comprensione della lista. È anche un po 'poco chiaro usare una comprensione dell'elenco solo per l'effetto collaterale della funzione.

Ho trovato una soluzione con popemap

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

L'output di questo:

{'d': 'valueD'}

Ho risposto a questa domanda così tardi solo perché penso che sarà utile in futuro se qualcuno cerca la stessa cosa. E questo potrebbe aiutare.

Aggiornare

Il codice precedente genererà un errore se una chiave non esiste nel 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)

produzione:

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

Non ho alcun problema con nessuna delle risposte esistenti, ma sono rimasto sorpreso di non trovare questa soluzione:

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: mi sono imbattuto in questa domanda proveniente da qui . E la mia risposta è correlata a questa risposta .

Perchè no:

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

Non so cosa intendi per "modo più intelligente". Sicuramente ci sono altri modi, magari con la comprensione del dizionario:

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

in linea

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

Alcuni test di temporizzazione per cpython 3 mostrano che un semplice ciclo for è il modo più veloce ed è abbastanza leggibile. Anche l'aggiunta di una funzione non causa molto overhead:

risultati timeit (10k iterazioni):

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

Per piccole iterazioni, farlo "inline" era un po 'più veloce, a causa del sovraccarico della chiamata di funzione. Ma del_allè sicuro, riutilizzabile e più veloce di tutti i costrutti di mappatura e comprensione di Python.

Penso che usare il fatto che le chiavi possano essere trattate come un set sia il modo più carino se sei su 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))

Esempio:

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

Sarebbe bello avere il pieno supporto per i metodi set per i dizionari (e non il pasticcio diabolico che stiamo ottenendo con Python 3.9) in modo da poter semplicemente "rimuovere" un set di chiavi. Tuttavia, fintanto che non è così e hai un dizionario di grandi dimensioni con potenzialmente un numero elevato di chiavi da rimuovere, potresti voler conoscere le prestazioni. Quindi, ho creato un codice che crea qualcosa di abbastanza grande per confronti significativi: una matrice 100.000 x 1000, quindi 10.000,00 elementi in totale.

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 milioni di elementi o più non sono insoliti in alcune impostazioni. Confrontando i due metodi sulla mia macchina locale vedo un leggero miglioramento durante l'utilizzo mape pop, presumibilmente a causa di un minor numero di chiamate di funzione, ma entrambi richiedono circa 2,5 secondi sulla mia macchina. Ma questo impallidisce rispetto al tempo necessario per creare il dizionario in primo luogo (55s), o includendo i controlli all'interno del ciclo. Se ciò è probabile, è meglio creare un insieme che sia un'intersezione delle chiavi del dizionario e del filtro:

keys = cells.keys() & keys

In sintesi: delè già fortemente ottimizzato, quindi non preoccuparti di usarlo.

Sono in ritardo per questa discussione, ma per chiunque altro. Una soluzione potrebbe essere quella di creare un elenco di chiavi in ​​quanto tali.

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

Quindi usa pop () in un elenco di comprensione, o ciclo for, per iterare sui tasti e visualizzarli uno alla volta come tali.

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

Il "n / a" è nel caso in cui la chiave non esiste, deve essere restituito un valore predefinito.