Come rimuovere una chiave da un dizionario Python?

Quando elimino una chiave da un dizionario, utilizzo:

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

C'è un modo di fare una linea per farlo?

Per eliminare una chiave indipendentemente dal fatto che sia presente nel dizionario, utilizzare la forma a due argomenti di dict.pop():

my_dict.pop('key', None)

Questo restituirà my_dict[key]se keyesiste nel dizionario e in caso Nonecontrario. Se il secondo parametro non è specificato (es. my_dict.pop('key')) E keynon esiste, KeyErrorviene sollevato a.

Per eliminare una chiave garantita, è anche possibile utilizzare

del my_dict['key']

Questo aumenterà a KeyErrorse la chiave non è nel dizionario.

In particolare per rispondere "esiste un modo di fare una linea per farlo?"

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

... bene, hai chiesto ;-)

Dovresti considerare, tuttavia, che questo modo di eliminare un oggetto da un nondict è atomico: è possibile che 'key'sia presente my_dictdurante l' ifistruzione, ma che possa essere eliminato prima che delvenga eseguito, nel qual caso delfallirà con a KeyError. Detto questo, sarebbe più sicuro usaredict.pop o qualcosa del genere

try:
    del my_dict['key']
except KeyError:
    pass

che, naturalmente, è sicuramente non una battuta.

Mi ci è voluto del tempo per capire cosa stesse my_dict.pop("key", None)facendo esattamente . Quindi aggiungerò questo come risposta per salvare gli altri.

pop(key[, default])

Se la chiave è nel dizionario, rimuoverla e restituire il suo valore, altrimenti restituisce il valore predefinito . Se non viene fornito il valore predefinito e la chiave non è presente nel dizionario, KeyErrorviene sollevato a.

Documentazione

del my_dict[key]è leggermente più veloce rispetto my_dict.pop(key)alla rimozione di una chiave da un dizionario quando esiste la chiave

>>> import timeit
>>> setup = "d = {i: i for i in range(100000)}"

>>> timeit.timeit("del d[3]", setup=setup, number=1)
1.79e-06
>>> timeit.timeit("d.pop(3)", setup=setup, number=1)
2.09e-06
>>> timeit.timeit("d2 = {key: val for key, val in d.items() if key != 3}", setup=setup, number=1)
0.00786

Ma quando la chiave non esiste if key in my_dict: del my_dict[key]è leggermente più veloce di my_dict.pop(key, None). Entrambi sono almeno tre volte più veloci che delin un'istruzione try/ except:

>>> timeit.timeit("if 'missing key' in d: del d['missing key']", setup=setup)
0.0229
>>> timeit.timeit("d.pop('missing key', None)", setup=setup)
0.0426
>>> try_except = """
... try:
...     del d['missing key']
... except KeyError:
...     pass
... """
>>> timeit.timeit(try_except, setup=setup)
0.133

Se devi rimuovere molte chiavi da un dizionario in una riga di codice, penso che usare map () sia abbastanza sintetico e leggibile da Pythonic:

myDict = {'a':1,'b':2,'c':3,'d':4}
map(myDict.pop, ['a','c']) # The list of keys to remove
>>> myDict
{'b': 2, 'd': 4}

E se hai bisogno di rilevare errori in cui fai apparire un valore che non è nel dizionario, usa lambda inside map () in questo modo:

map(lambda x: myDict.pop(x,None), ['a', 'c', 'e'])
[1, 3, None] # pop returns
>>> myDict
{'b': 2, 'd': 4}

o in python3, invece, è necessario utilizzare una comprensione dell'elenco:

[myDict.pop(x, None) for x in ['a', 'c', 'e']]

Funziona. E 'e' non ha causato errori, anche se myDict non aveva un tasto 'e'.

È possibile utilizzare una comprensione del dizionario per creare un nuovo dizionario con quella chiave rimossa:

>>> my_dict = {k: v for k, v in my_dict.items() if k != 'key'}

È possibile eliminare in base alle condizioni. Nessun errore se keynon esiste.

Utilizzando la parola chiave "del":

del dict[key]

Possiamo eliminare una chiave da un dizionario Python con i seguenti approcci.

Utilizzando la delparola chiave; è quasi lo stesso approccio che hai fatto però -

 myDict = {'one': 100, 'two': 200, 'three': 300 }
 print(myDict)  # {'one': 100, 'two': 200, 'three': 300}
 if myDict.get('one') : del myDict['one']
 print(myDict)  # {'two': 200, 'three': 300}

O

Possiamo fare come segue:

Ma bisogna tenere presente che, in questo processo, in realtà non eliminerà alcuna chiave dal dizionario piuttosto che escludere una chiave specifica da quel dizionario. Inoltre, ho osservato che restituiva un dizionario che non era stato ordinato come myDict.

myDict = {'one': 100, 'two': 200, 'three': 300, 'four': 400, 'five': 500}
{key:value for key, value in myDict.items() if key != 'one'}

Se lo eseguiamo nella shell, eseguirà qualcosa del genere {'five': 500, 'four': 400, 'three': 300, 'two': 200}- nota che non è lo stesso ordinato myDict. Ancora una volta, se proviamo a stampare myDict, possiamo vedere tutte le chiavi incluse quelle che abbiamo escluso dal dizionario con questo approccio. Tuttavia, possiamo creare un nuovo dizionario assegnando la seguente istruzione in una variabile:

var = {key:value for key, value in myDict.items() if key != 'one'}

Ora se proviamo a stamparlo, seguirà l'ordine parent:

print(var) # {'two': 200, 'three': 300, 'four': 400, 'five': 500}

O

Utilizzando il pop()metodo

myDict = {'one': 100, 'two': 200, 'three': 300}
print(myDict)

if myDict.get('one') : myDict.pop('one')
print(myDict)  # {'two': 200, 'three': 300}

La differenza tra dele popè che, usando il pop()metodo, possiamo effettivamente memorizzare il valore della chiave se necessario, come il seguente:

myDict = {'one': 100, 'two': 200, 'three': 300}
if myDict.get('one') : var = myDict.pop('one')
print(myDict) # {'two': 200, 'three': 300}
print(var)    # 100

Fork questa sostanza per riferimento futuro, se lo trovi utile.

Puoi usare la gestione delle eccezioni se vuoi essere molto dettagliato:

try: 
    del dict[key]

except KeyError: pass

Questo è più lento, tuttavia, rispetto al pop()metodo, se la chiave non esiste.

my_dict.pop('key', None)

Non importa per alcune chiavi, ma se lo fai ripetutamente, quest'ultimo metodo è una scommessa migliore.

L'approccio più veloce è questo:

if 'key' in dict: 
    del myDict['key']

Ma questo metodo è pericoloso perché se 'key'viene rimosso tra le due linee, KeyErrorverrà sollevato un.

Preferisco la versione immutabile

foo = {
    1:1,
    2:2,
    3:3
}
removeKeys = [1,2]
def woKeys(dct, keyIter):
    return {
        k:v
        for k,v in dct.items() if k not in keyIter
    }

>>> print(woKeys(foo, removeKeys))
{3: 3}
>>> print(foo)
{1: 1, 2: 2, 3: 3}

Un altro modo consiste nell'usare items () + comprensione di dict

items () accoppiato con la comprensione di dict può anche aiutarci a raggiungere il compito della cancellazione della coppia chiave-valore ma, ha lo svantaggio di non essere una tecnica di dict sul posto. In realtà un nuovo dict se creato ad eccezione della chiave che non desideriamo includere.

test_dict = {"sai" : 22, "kiran" : 21, "vinod" : 21, "sangam" : 21} 

# Printing dictionary before removal 
print ("dictionary before performing remove is : " + str(test_dict)) 

# Using items() + dict comprehension to remove a dict. pair 
# removes  vinod
new_dict = {key:val for key, val in test_dict.items() if key != 'vinod'} 

# Printing dictionary after removal 
print ("dictionary after remove is : " + str(new_dict)) 

Produzione:

dictionary before performing remove is : {'sai': 22, 'kiran': 21, 'vinod': 21, 'sangam': 21}
dictionary after remove is : {'sai': 22, 'kiran': 21, 'sangam': 21}

Filtro singolo su chiave

• restituisce "chiave" e rimuoverlo da my_dict se "chiave" esiste in my_dict
• return Nessuno se "chiave" non esiste in my_dict

questo cambierà my_dictsul posto (mutevole)

my_dict.pop('key', None)

Più filtri sui tasti

generare un nuovo dict (immutabile)

dic1 = {
    "x":1,
    "y": 2,
    "z": 3
}

def func1(item):
    return  item[0]!= "x" and item[0] != "y"

print(
    dict(
        filter(
            lambda item: item[0] != "x" and item[0] != "y", 
            dic1.items()
            )
    )
)