Déterminer si une clé est présente dans un dictionnaire

Question

J'ai un dictionnaire Python comme mydict = {'nom':'abc','ville':'xyz','pays','def'}.

Comment puis-je vérifier si une clé se trouve dans le dictionnaire ou pas? Je connais déjà ces méthodes :

if mydict.has_key('nom'):

if 'nom' in mydict:

Answer 1

if 'name' in mydict:

est la version préférée et pythonique. L'utilisation de has_key() est découragée, et cette méthode a été supprimée en Python 3.

Answer 2

Sur le même thème que la réponse de martineau, la meilleure solution est souvent de ne pas vérifier. Par exemple, le code

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

est normalement écrit

foo = d.get(x, bar)

ce qui est plus court et exprime plus directement ce que vous voulez dire.

Un autre cas courant est quelque chose comme

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

d[x].append(foo)

qui peut être réécrit

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

ou réécrit encore mieux en utilisant un collections.defaultdict(list) pour d et en écrivant

d[x].append(foo)

Answer 3

En termes de bytecode, in sauve un LOAD_ATTR et remplace un CALL_FUNCTION par 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             

Je pense que in est beaucoup plus lisible et est à privilégier dans tous les cas que je peux penser.

En termes de performances, le chronométrage reflète le bytecode

$ python -mtimeit -s'd = dict((i, i) for i in range(10000))' "'foo' in d"
 10000000 boucles, meilleure de 3: 0.11 usec par boucle

$ python -mtimeit -s'd = dict((i, i) for i in range(10000))' "d.has_key('foo')"
  1000000 boucles, meilleure de 3: 0.205 usec par boucle

in est presque deux fois plus rapide.

Answer 4

Ma réponse est "aucun des deux".

Je crois que la manière la plus "pythonique" de faire les choses est de NE PAS vérifier au préalable si la clé est dans un dictionnaire et plutôt écrire du code qui suppose qu'elle est là et attraper les KeyErrors qui sont levées parce que ce n'était pas le cas.

Cela se fait généralement en encapsulant le code dans une clause try...except et est un idiome bien connu habituellement exprimé comme "Il vaut mieux demander le pardon que la permission" ou avec l'acronyme EAFP, ce qui signifie essentiellement qu'il vaut mieux essayer quelque chose et attraper les erreurs plutôt que de vérifier que tout est OK avant de faire quoi que ce soit. Pourquoi valider ce qui n'a pas besoin d'être validé lorsque vous pouvez gérer les exceptions de manière gracieuse au lieu d'essayer de les éviter ? Parce que c'est souvent plus lisible et que le code tend à être plus rapide si la probabilité que la clé ne soit pas là (ou toute autre condition préalable) est faible.

Bien sûr, cela n'est pas approprié dans toutes les situations et tout le monde n'est pas d'accord avec cette philosophie, donc vous devrez décider par vous-même au cas par cas. Sans surprise, l'opposé de ceci est appelé LBYL pour "Look Before You Leap".

Par exemple, considérez :

if 'name' in dct:
    value = dct['name'] * 3
else:
    logerror('"%s" non trouvé dans le dictionnaire, en utilisant par défaut' % name)
    value = 42

vs

try:
    value = dct['name'] * 3
except KeyError:
    logerror('"%s" non trouvé dans le dictionnaire, en utilisant par défaut' % name)
    value = 42

Quoique dans ce cas, ce soit presque exactement la même quantité de code, le second ne perd pas de temps à vérifier d'abord et est probablement légèrement plus rapide à cause de cela (bloc try...except n'est pas totalement gratuit cependant, donc cela ne fait probablement pas une grande différence ici).

En général, tester à l'avance peut souvent être beaucoup plus impliqué et les gains réalisés en ne le faisant pas peuvent être significatifs. Cela dit, if 'name' in dict: est meilleur pour les raisons énoncées dans les autres réponses.

Si le sujet vous intéresse, ce message intitulé "EAFP vs LBYL (was Re: A little disappointed so far)" des archives de la liste de diffusion Python explique probablement mieux la différence entre les deux approches que je ne l'ai fait ici. Il y a également une bonne discussion sur les deux approches dans le livre Python in a Nutshell, 2ème édition par Alex Martelli dans le chapitre 6 sur les Exceptions intitulé Stratégies de vérification des erreurs. (Je vois qu'il y a maintenant une nouvelle 3ème édition, publiée en 2017, qui couvre à la fois Python 2.7 et 3.x).