Volevo verificare se esiste una chiave in un dizionario prima di aggiornare il valore per la chiave. Ho scritto il seguente codice:

if 'key1' in dict.keys():
  print "blah"
else:
  print "boo"

Penso che questo non sia il modo migliore per svolgere questo compito. Esiste un modo migliore per testare una chiave nel dizionario?

inè il modo previsto per verificare l'esistenza di una chiave in a dict.

d = {"key1": 10, "key2": 23}

if "key1" in d:
    print("this will execute")

if "nonexistent key" in d:
    print("this will not")

Se si desidera un valore predefinito, è sempre possibile utilizzare dict.get():

d = dict()

for i in range(100):
    key = i % 10
    d[key] = d.get(key, 0) + 1

e se si desidera garantire sempre un valore predefinito per qualsiasi chiave, è possibile utilizzare dict.setdefault()ripetutamente o defaultdictdal collectionsmodulo, in questo modo:

from collections import defaultdict

d = defaultdict(int)

for i in range(100):
    d[i % 10] += 1

ma in generale, la inparola chiave è il modo migliore per farlo.

Non è necessario chiamare i tasti:

if 'key1' in dict:
  print("blah")
else:
  print("boo")

Sarà molto più veloce poiché usa l'hash del dizionario invece di fare una ricerca lineare, come farebbero i tasti di chiamata.

È possibile verificare la presenza di una chiave in un dizionario, utilizzando la a parola chiave:

d = {'a': 1, 'b': 2}
'a' in d # <== evaluates to True
'c' in d # <== evaluates to False

Un uso comune per verificare l'esistenza di una chiave in un dizionario prima di modificarlo è inizializzare il valore per impostazione predefinita (ad esempio, se i valori sono elenchi, ad esempio, e si desidera assicurarsi che sia presente un elenco vuoto a cui è possibile aggiungere quando si inserisce il primo valore per una chiave). In casi come quelli, potresti trovare il collections.defaultdict()tipo di tuo interesse.

Nel codice precedente, potresti anche trovare alcuni usi di has_key()un metodo deprecato per controllare l'esistenza delle chiavi nei dizionari (basta usare key_name in dict_nameinvece).

Puoi abbreviare questo:

if 'key1' in dict:
    ...

Tuttavia, questo è nella migliore delle ipotesi un miglioramento estetico. Perché credi che questo non sia il modo migliore?

Per ulteriori informazioni sull'esecuzione rapida dei metodi proposti per la risposta accettata (loop da 10 m):

• 'key' in mydict tempo trascorso 1,07 sec
• mydict.get('key') tempo trascorso 1,84 sec
• mydefaultdict['key'] tempo trascorso 1,07 sec

Pertanto utilizzare ino defaultdictsono sconsigliati get.

Consiglierei invece di utilizzare il setdefaultmetodo. Sembra che farà tutto quello che vuoi.

>>> d = {'foo':'bar'}
>>> q = d.setdefault('foo','baz') #Do not override the existing key
>>> print q #The value takes what was originally in the dictionary
bar
>>> print d
{'foo': 'bar'}
>>> r = d.setdefault('baz',18) #baz was never in the dictionary
>>> print r #Now r has the value supplied above
18
>>> print d #The dictionary's been updated
{'foo': 'bar', 'baz': 18}

Il dizionario in python ha un metodo get ('chiave', predefinito). Quindi puoi semplicemente impostare un valore predefinito nel caso in cui non ci sia chiave.

values = {...}
myValue = values.get('Key', None)

Che dire dell'utilizzo di EAFP (è più facile chiedere perdono che autorizzazione):

try:
   blah = dict["mykey"]
   # key exists in dict
except KeyError:
   # key doesn't exist in dict

Vedi altri post SO:

Usando try vs if in python o

Verifica dell'esistenza dei membri in Python

Utilizzando l'operatore ternario:

message = "blah" if 'key1' in dict else "booh"
print(message)

I modi in cui è possibile ottenere i risultati sono:

• if your_dict.has_key (chiave) Rimosso in Python 3
• se chiave in your_dict
• prova / tranne blocco

Quale è meglio dipende da 3 cose:

1. Il dizionario "normalmente ha la chiave" o "normalmente non ha la chiave".
2. Intendi utilizzare condizioni come se ... altro ... altro ... altro?
3. Quanto è grande il dizionario?

Maggiori informazioni: http://paltman.com/try-except-performance-in-python-a-simple-test/

Uso di try / block invece di 'in' o 'if':

try:
    my_dict_of_items[key_i_want_to_check]
except KeyError:
    # Do the operation you wanted to do for "key not present in dict".
else:
    # Do the operation you wanted to do with "key present in dict."

Solo Python 2: (e python 2.7 supporta ingià)

puoi usare il metodo has_key ():

if dict.has_key('xyz')==1:
    #update the value for the key
else:
    pass

Solo una FYI che aggiunge a Chris. B (miglior risposta):

d = defaultdict(int)

Funziona anche; il motivo è che la chiamata int()ritorna 0che è ciò che defaultdictfa dietro le quinte (quando si costruisce un dizionario), da cui il nome "Funzione di fabbrica" ​​nella documentazione.

Controlla se una determinata chiave esiste già in un dizionario

Per avere un'idea di come fare, controlliamo prima quali metodi possiamo chiamare sul dizionario. Ecco i metodi:

d={'clear':0, 'copy':1, 'fromkeys':2, 'get':3, 'items':4, 'keys':5, 'pop':6, 'popitem':7, 'setdefault':8, 'update':9, 'values':10}

Python Dictionary clear()       Removes all Items
Python Dictionary copy()        Returns Shallow Copy of a Dictionary
Python Dictionary fromkeys()    Creates dictionary from given sequence
Python Dictionary get()         Returns Value of The Key
Python Dictionary items()       Returns view of dictionary (key, value) pair
Python Dictionary keys()        Returns View Object of All Keys
Python Dictionary pop()         Removes and returns element having given key
Python Dictionary popitem()     Returns & Removes Element From Dictionary
Python Dictionary setdefault()  Inserts Key With a Value if Key is not Present
Python Dictionary update()      Updates the Dictionary 
Python Dictionary values()      Returns view of all values in dictionary

Il metodo brutale per verificare se la chiave esiste già potrebbe essere il get()metodo:

d.get("key")

Gli altri due metodi interessantiitems() e keys()sembra troppo lavoro. Quindi esaminiamo se get()è il metodo giusto per noi. Abbiamo il nostro dict d:

d= {'clear':0, 'copy':1, 'fromkeys':2, 'get':3, 'items':4, 'keys':5, 'pop':6, 'popitem':7, 'setdefault':8, 'update':9, 'values':10}

La stampa mostra che la chiave che non abbiamo sarà restituita None:

print(d.get('key')) #None
print(d.get('clear')) #0
print(d.get('copy')) #1

Si può utilizzare che per avere le informazioni se la chiave è presente o no. Ma considera questo se creiamo un dict con un singolo key:None:

d= {'key':None}
print(d.get('key')) #None
print(d.get('key2')) #None

Condurre questo get()metodo non è affidabile nel caso in cui alcuni valori possano esserlo None. Questa storia dovrebbe avere un finale più felice. Se utilizziamo il incomparatore:

print('key' in d) #True
print('key2' in d) #False

Otteniamo i risultati corretti. Possiamo esaminare il codice byte Python:

import dis
dis.dis("'key' in d")
#   1           0 LOAD_CONST               0 ('key')
#               2 LOAD_NAME                0 (d)
#               4 COMPARE_OP               6 (in)
#               6 RETURN_VALUE

dis.dis("d.get('key2')")
#   1           0 LOAD_NAME                0 (d)
#               2 LOAD_METHOD              1 (get)
#               4 LOAD_CONST               0 ('key2')
#               6 CALL_METHOD              1
#               8 RETURN_VALUE

Ciò dimostra che l' inoperatore di confronto non è solo più affidabile ma anche più veloce di get().

Il dizionario Python ha il metodo chiamato __contains__. Questo metodo restituirà True se il dizionario ha la chiave else restituisce False.

 >>> temp = {}

 >>> help(temp.__contains__)

Help on built-in function __contains__:

__contains__(key, /) method of builtins.dict instance
    True if D has a key k, else False.

Condivisione di un altro modo per verificare l'esistenza di una chiave utilizzando operatori booleani.

d = {'a': 1, 'b':2}
keys = 'abcd'

for k in keys:
    x = (k in d and 'blah') or 'boo'
    print(x) 

Questo ritorna

>>> blah
>>> blah
>>> boo
>>> boo

Spiegazione

In primo luogo si deve sapere che in Python, 0, None, o gli oggetti con lunghezza zero restituiscono False. Tutto il resto valuta True. Le operazioni booleane vengono valutate da sinistra a destra e restituiscono l'operando non True o False.

Vediamo un esempio:

>>> 'Some string' or 1/0 
'Some string'
>>>

Poiché viene 'Some string'valutato True, il resto ornon viene valutato e non viene generato alcun errore di divisione per zero.

Ma se cambiamo l'ordine 1/0viene valutato prima e solleva un'eccezione:

>>> 1/0 or 'Some string'
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ZeroDivisionError: division by zero
>>> 

Possiamo usarlo come modello per verificare se esiste una chiave.

(k in d and 'blah')

fa lo stesso di

if k in d:
    'blah'
else:
    False

Questo restituisce già il risultato corretto se la chiave esiste, ma vogliamo che stampi 'boo' quando non lo è. Quindi, prendiamo il risultato e orlo facciamo con'boo'

>>> False or 'boo'
'boo'
>>> 'blah' or 'boo'
'blah'
>>> 

Puoi usare forloop per scorrere il dizionario e ottenere il nome della chiave che vuoi trovare nel dizionario, dopodiché controlla se esiste o meno usando la ifcondizione:

dic = {'first' : 12, 'second' : 123}
for each in dic:
    if each == 'second': 
        print('the key exists and the corresponding value can be updated in the dictionary')