Elimina un elemento da un dizionario

C'è un modo per eliminare un elemento da un dizionario in Python?

Inoltre, come posso eliminare un elemento da un dizionario per restituire una copia (ovvero, non modificare l'originale)?

L' delistruzione rimuove un elemento:

del d[key]

Tuttavia, ciò muta il dizionario esistente, quindi i contenuti del dizionario cambiano per chiunque abbia un riferimento alla stessa istanza. Per restituire un nuovo dizionario, creane una copia:

def removekey(d, key):
    r = dict(d)
    del r[key]
    return r

Il dict()costruttore fa una copia superficiale . Per fare una copia profonda, vedere il copymodulo .

Nota che fare una copia per ogni dict del/ incarico / ecc. significa che stai passando da un tempo costante a un tempo lineare e che usi anche lo spazio lineare. Per i piccoli dadi, questo non è un problema. Ma se stai pianificando di fare molte copie di dadi grandi, probabilmente vorrai una struttura dati diversa, come un HAMT (come descritto in questa risposta ).

pop muta il dizionario.

 >>> lol = {"hello": "gdbye"}
 >>> lol.pop("hello")
     'gdbye'
 >>> lol
     {}

Se vuoi conservare l'originale, puoi semplicemente copiarlo.

Penso che la tua soluzione sia il modo migliore per farlo. Ma se vuoi un'altra soluzione, puoi creare un nuovo dizionario usando le chiavi del vecchio dizionario senza includere la chiave specificata, in questo modo:

>>> a
{0: 'zero', 1: 'one', 2: 'two', 3: 'three'}
>>> {i:a[i] for i in a if i!=0}
{1: 'one', 2: 'two', 3: 'three'}

La dichiarazione del è quello che stai cercando. Se hai un dizionario chiamato foo con un tasto chiamato 'bar', puoi eliminare 'bar' da foo in questo modo:

del foo['bar']

Si noti che ciò modifica permanentemente il dizionario su cui si opera. Se desideri conservare il dizionario originale, dovrai crearne una copia in anticipo:

>>> foo = {'bar': 'baz'}
>>> fu = dict(foo)
>>> del foo['bar']
>>> print foo
{}
>>> print fu
{'bar': 'baz'}

La dictchiamata fa una copia superficiale. Se si desidera una copia profonda, utilizzare copy.deepcopy.

Ecco un metodo che puoi copiare e incollare, per tua comodità:

def minus_key(key, dictionary):
    shallow_copy = dict(dictionary)
    del shallow_copy[key]
    return shallow_copy

Ci sono molte belle risposte, ma voglio sottolineare una cosa.

È possibile utilizzare sia il dict.pop()metodo sia delun'istruzione più generica per rimuovere elementi da un dizionario. Entrambi mutano il dizionario originale, quindi è necessario crearne una copia (vedere i dettagli di seguito).

Ed entrambi genereranno un KeyErrorse la chiave che stai fornendo loro non è presente nel dizionario:

key_to_remove = "c"
d = {"a": 1, "b": 2}
del d[key_to_remove]  # Raises `KeyError: 'c'`

e

key_to_remove = "c"
d = {"a": 1, "b": 2}
d.pop(key_to_remove)  # Raises `KeyError: 'c'`

Devi occuparti di questo:

catturando l'eccezione:

key_to_remove = "c"
d = {"a": 1, "b": 2}
try:
    del d[key_to_remove]
except KeyError as ex:
    print("No such key: '%s'" % ex.message)

e

key_to_remove = "c"
d = {"a": 1, "b": 2}
try:
    d.pop(key_to_remove)
except KeyError as ex:
    print("No such key: '%s'" % ex.message)

eseguendo un controllo:

key_to_remove = "c"
d = {"a": 1, "b": 2}
if key_to_remove in d:
    del d[key_to_remove]

e

key_to_remove = "c"
d = {"a": 1, "b": 2}
if key_to_remove in d:
    d.pop(key_to_remove)

ma con pop()c'è anche un modo molto più conciso: fornisci il valore di ritorno predefinito:

key_to_remove = "c"
d = {"a": 1, "b": 2}
d.pop(key_to_remove, None)  # No `KeyError` here

A meno che non si utilizzi pop()per ottenere il valore di una chiave rimossa, è possibile fornire qualsiasi cosa, non necessaria None. Anche se potrebbe essere che l'utilizzo delcon incheck sia leggermente più veloce a causa della pop()sua funzione con le sue complicazioni che causano spese generali. Di solito non è così, quindi pop()con il valore predefinito è abbastanza buono.

Per quanto riguarda la domanda principale, dovrai fare una copia del tuo dizionario, per salvare il dizionario originale e averne uno nuovo senza che la chiave venga rimossa.

Alcune altre persone qui suggeriscono di fare una copia completa (in profondità) copy.deepcopy(), che potrebbe essere eccessiva, una copia "normale" (superficiale), usando copy.copy()o dict.copy(), potrebbe essere sufficiente. Il dizionario mantiene un riferimento all'oggetto come valore per una chiave. Pertanto, quando si rimuove una chiave da un dizionario, questo riferimento viene rimosso, non l'oggetto a cui si fa riferimento. L'oggetto stesso può essere rimosso in seguito automaticamente dal Garbage Collector, se non ci sono altri riferimenti nella memoria. Realizzare una copia profonda richiede più calcoli rispetto alla copia superficiale, quindi diminuisce le prestazioni del codice effettuando la copia, sprecando memoria e fornendo più lavoro al GC, a volte è sufficiente una copia superficiale.

Tuttavia, se si hanno oggetti mutabili come valori di dizionario e si prevede di modificarli in un secondo momento nel dizionario restituito senza la chiave, è necessario effettuare una copia approfondita.

Con copia superficiale:

def get_dict_wo_key(dictionary, key):
    """Returns a **shallow** copy of the dictionary without a key."""
    _dict = dictionary.copy()
    _dict.pop(key, None)
    return _dict


d = {"a": [1, 2, 3], "b": 2, "c": 3}
key_to_remove = "c"

new_d = get_dict_wo_key(d, key_to_remove)
print(d)  # {"a": [1, 2, 3], "b": 2, "c": 3}
print(new_d)  # {"a": [1, 2, 3], "b": 2}
new_d["a"].append(100)
print(d)  # {"a": [1, 2, 3, 100], "b": 2, "c": 3}
print(new_d)  # {"a": [1, 2, 3, 100], "b": 2}
new_d["b"] = 2222
print(d)  # {"a": [1, 2, 3, 100], "b": 2, "c": 3}
print(new_d)  # {"a": [1, 2, 3, 100], "b": 2222}

Con copia profonda:

from copy import deepcopy


def get_dict_wo_key(dictionary, key):
    """Returns a **deep** copy of the dictionary without a key."""
    _dict = deepcopy(dictionary)
    _dict.pop(key, None)
    return _dict


d = {"a": [1, 2, 3], "b": 2, "c": 3}
key_to_remove = "c"

new_d = get_dict_wo_key(d, key_to_remove)
print(d)  # {"a": [1, 2, 3], "b": 2, "c": 3}
print(new_d)  # {"a": [1, 2, 3], "b": 2}
new_d["a"].append(100)
print(d)  # {"a": [1, 2, 3], "b": 2, "c": 3}
print(new_d)  # {"a": [1, 2, 3, 100], "b": 2}
new_d["b"] = 2222
print(d)  # {"a": [1, 2, 3], "b": 2, "c": 3}
print(new_d)  # {"a": [1, 2, 3, 100], "b": 2222}

... come posso eliminare un elemento da un dizionario per restituire una copia (ovvero, non modificare l'originale)?

A dictè la struttura di dati errata da utilizzare per questo.

Certo, copiare il dict e saltar fuori dalla copia funziona, così come la costruzione di un nuovo dict con una comprensione, ma tutto ciò che la copia richiede tempo - hai sostituito un'operazione a tempo costante con una lineare. E tutte quelle copie vive allo stesso tempo occupano spazio, spazio lineare per copia.

Altre strutture di dati, come i tentativi mappati dell'array di hash , sono progettate esattamente per questo tipo di caso d'uso: l'aggiunta o la rimozione di un elemento restituisce una copia in tempo logaritmico, condividendo la maggior parte della sua memoria con l'originale . ¹

Naturalmente ci sono alcuni aspetti negativi. Le prestazioni sono logaritmiche piuttosto che costanti (sebbene con una base ampia, di solito 32-128). E, sebbene sia possibile rendere identica l'API non mutante, l'API dict"mutante" è ovviamente diversa. E, soprattutto, non ci sono batterie HAMT incluse con Python. ²

La pyrsistentlibreria è un'implementazione piuttosto solida delle sostituzioni di dict (e vari altri tipi) basate su HAMT per Python. Ha persino un'API evolutiva elegante per il porting del codice mutante esistente sul codice persistente nel modo più fluido possibile. Ma se vuoi essere esplicito sulla restituzione delle copie piuttosto che sulla mutazione, lo usi semplicemente in questo modo:

>>> from pyrsistent import m
>>> d1 = m(a=1, b=2)
>>> d2 = d1.set('c', 3)
>>> d3 = d1.remove('a')
>>> d1
pmap({'a': 1, 'b': 2})
>>> d2
pmap({'c': 3, 'a': 1, 'b': 2})
>>> d3
pmap({'b': 2})

Questo d3 = d1.remove('a')è esattamente ciò che la domanda sta ponendo.

Se hai strutture di dati mutabili come dicte listincorporate in pmap, avrai comunque problemi di aliasing: puoi risolverlo solo andando immutabile fino in fondo, incorporando pmaps e pvectors.

_{1. Gli HAMT sono anche diventati popolari in linguaggi come Scala, Clojure, Haskell perché giocano molto bene con la programmazione senza blocco e la memoria transazionale del software, ma nessuno di questi è molto rilevante in Python.}

_{2. Infatti, v'è un HAMT nel stdlib, impiegati per l'attuazione di contextvars. Il PEP ritirato in precedenza spiega perché. Ma questo è un dettaglio di implementazione nascosto della libreria, non un tipo di raccolta pubblica.}

d = {1: 2, '2': 3, 5: 7}
del d[5]
print 'd = ', d

Risultato: d = {1: 2, '2': 3}

Chiama semplicemente del d ['chiave'].

Tuttavia, in produzione, è sempre buona norma verificare se 'chiave' esiste in d.

if 'key' in d:
    del d['key']

No, non esiste altro

def dictMinus(dct, val):
   copy = dct.copy()
   del copy[val]
   return copy

Tuttavia, spesso la creazione di copie di dizionari solo leggermente modificati non è probabilmente una buona idea perché comporterà richieste di memoria relativamente grandi. Di solito è meglio registrare il vecchio dizionario (se necessario) e quindi modificarlo.

# mutate/remove with a default
ret_val = body.pop('key', 5)
# no mutation with a default
ret_val = body.get('key', 5)

>>> def delete_key(dict, key):
...     del dict[key]
...     return dict
... 
>>> test_dict = {'one': 1, 'two' : 2}
>>> print delete_key(test_dict, 'two')
{'one': 1}
>>>

questo non fa alcun errore nella gestione, presuppone che la chiave sia nel dict, si consiglia di verificarlo prima e raisese non lo è

Ecco un approccio progettuale di alto livello:

def eraseElement(d,k):
    if isinstance(d, dict):
        if k in d:
            d.pop(k)
            print(d)
        else:
            print("Cannot find matching key")
    else:
        print("Not able to delete")


exp = {'A':34, 'B':55, 'C':87}
eraseElement(exp, 'C')

Sto passando il dizionario e la chiave che desidero nella mia funzione, convalida se si tratta di un dizionario e se la chiave è a posto, e se esistono entrambe, rimuove il valore dal dizionario e stampa i resti.

Produzione: {'B': 55, 'A': 34}

Spero che aiuti!

Di seguito lo snippet di codice ti aiuterà sicuramente, ho aggiunto commenti in ogni riga che ti aiuteranno a capire il codice.

def execute():
   dic = {'a':1,'b':2}
   dic2 = remove_key_from_dict(dic, 'b')  
   print(dict2)           # {'a': 1}
   print(dict)            # {'a':1,'b':2}

def remove_key_from_dict(dictionary_to_use, key_to_delete):
   copy_of_dict = dict(dictionary_to_use)     # creating clone/copy of the dictionary
   if key_to_delete in copy_of_dict :         # checking given key is present in the dictionary
       del copy_of_dict [key_to_delete]       # deleting the key from the dictionary 
   return copy_of_dict                        # returning the final dictionary

oppure puoi anche usare dict.pop ()

d = {"a": 1, "b": 2}

res = d.pop("c")  # No `KeyError` here
print (res)       # this line will not execute

o l'approccio migliore è

res = d.pop("c", "key not found")
print (res)   # key not found
print (d)     # {"a": 1, "b": 2}

res = d.pop("b", "key not found")
print (res)   # 2
print (d)     # {"a": 1}

Ecco un'altra variante usando la comprensione dell'elenco:

original_d = {'a': None, 'b': 'Some'}
d = dict((k,v) for k, v in original_d.iteritems() if v)
# result should be {'b': 'Some'}

L'approccio si basa su una risposta da questo post: modo efficiente per rimuovere le chiavi con stringhe vuote da un dict

    species = {'HI': {'1': (1215.671, 0.41600000000000004),
  '10': (919.351, 0.0012),
  '1025': (1025.722, 0.0791),
  '11': (918.129, 0.0009199999999999999),
  '12': (917.181, 0.000723),
  '1215': (1215.671, 0.41600000000000004),
  '13': (916.429, 0.0005769999999999999),
  '14': (915.824, 0.000468),
  '15': (915.329, 0.00038500000000000003),
 'CII': {'1036': (1036.3367, 0.11900000000000001), '1334': (1334.532, 0.129)}}

Il codice seguente crea una copia di dict speciesed elimina gli elementi che non sono presentitrans_HI

trans_HI=['1025','1215']
for transition in species['HI'].copy().keys():
    if transition not in trans_HI:
        species['HI'].pop(transition)