determinare se una chiave è presente in un dizionario

Question

Eventuali duplicati:
'has_key()' or 'in'?

ho un dizionario Python come:

mydict = {'name':'abc','city':'xyz','country','def'} 

voglio verificare se un la chiave è nel dizionario o no. Sono ansioso di sapere ciò che è più preferibile dai seguenti due casi e perché?

1> if mydict.has_key('name'): 
2> if 'name' in mydict: 

Answer 1

if 'name' in mydict: 

è la preferita, versione divinatorio. L'utilizzo di has_key() è sconsigliato e questo metodo has been removed in Python 3.

Answer 2

In termini di bytecode, in salva una LOAD_ATTR e sostituisce un CALL_FUNCTION con un COMPARE_OP.

>>> dis.dis(indict) 
    2   0 LOAD_GLOBAL    0 (name) 
       3 LOAD_GLOBAL    1 (d) 
       6 COMPARE_OP    6 (in) 
       9 POP_TOP    


>>> dis.dis(haskey) 
    2   0 LOAD_GLOBAL    0 (d) 
       3 LOAD_ATTR    1 (haskey) 
       6 LOAD_GLOBAL    2 (name) 
       9 CALL_FUNCTION   1 
      12 POP_TOP    

I miei sentimenti sono che in è molto più leggibile ed è da preferire in tutti i casi che mi vengono in mente.

In termini di prestazioni, la tempistica riflette l'opcode

$ python -mtimeit -s'd = dict((i, i) for i in range(10000))' "'foo' in d" 
10000000 loops, best of 3: 0.11 usec per loop 

$ python -mtimeit -s'd = dict((i, i) for i in range(10000))' "d.has_key('foo')" 
    1000000 loops, best of 3: 0.205 usec per loop 

in è quasi due volte più veloce.

Answer 3

La mia risposta è "nessuno dei due".

Credo che il modo più "Python" per fare le cose è NON controllare preventivamente se la chiave è in un dizionario e invece basta scrivere codice che presume che sia lì e prendere qualsiasi KeyErrors che si alza perché non lo era.

Questo è solitamente fatto con racchiudendo il codice in una clausola try...except ed è un linguaggio ben noto di solito espressa come "è più facile chiedere perdono che il permesso" o con l'acronimo EAFP, che sostanzialmente significa che è meglio provare qualcosa e catturare gli errori invece per assicurarsi che tutto sia OK prima di fare qualsiasi cosa. Perché convalidare ciò che non ha bisogno di essere convalidato quando puoi gestire le eccezioni con grazia invece di cercare di evitarli? Perché è spesso più leggibile e il codice tende ad essere più veloce se la probabilità è bassa che la chiave non sarà lì (o qualunque precondizione ci possa essere).

Naturalmente, questo non è appropriato in tutte le situazioni e non tutti sono d'accordo con la filosofia, quindi dovrai decidere tu stesso caso per caso. Non sorprendentemente l'opposto di questo è chiamato LBYL per "Look Before You Leap".

Come esempio banale considerazione:

if 'name' in dct: 
    value = dct['name'] * 3 
else: 
    logerror('"%s" not found in dictionary, using default' % name) 
    value = 42 

vs

try: 
    value = dct['name'] * 3 
except KeyError: 
    logerror('"%s" not found in dictionary, using default' % name) 
    value = 42 

Anche se nel caso è quasi esattamente la stessa quantità di codice, il secondo non spendere tempo a controllare prima ed è probabilmente un po 'più veloce a causa di esso (prova ... tranne il blocco non è completamente gratuito, quindi probabilmente non fa molta differenza qui).

In generale, i test in anticipo possono spesso essere molto più coinvolti e il risparmio ottenuto dal non farlo può essere significativo. Detto questo, if 'name' in dict: è migliore per i motivi indicati nelle altre risposte.

Se siete interessati al tema, questo message dal titolo "EAFP vs LBYL (era Re: Un po 'deluso finora)" dal Python archivio della mailing list probabilmente spiega la differenza tra i due è avvicinato meglio di me avere qui C'è anche una buona discussione sui due approcci nel libro Python in a Nutshell, 2 ° Ed di Alex Martelli nel capitolo sulle eccezioni intitolato "Error-Checking Strategies".

Answer 4

Nella stessa vena della risposta di martineau, la soluzione migliore spesso non è controllare. Ad esempio, il codice

if x in d: 
    foo = d[x] 
else: 
    foo = bar 

è normalmente scritto

foo = d.get(x, bar) 

che è più breve e parla di quello che vuoi dire in modo più diretto.

Un altro caso comune è qualcosa di simile

if x not in d: 
    d[x] = [] 

d[x].append(foo) 

che può essere riscritta

d.setdefault(x, []).append(foo) 

o riscritta meglio ancora utilizzando un collections.defaultdict(list) per d e la scrittura

d[x].append(foo)