Je voulais tester si une clé existe dans un dictionnaire avant de mettre à jour la valeur de la clé. J'ai écrit le code suivant:

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

Je pense que ce n'est pas la meilleure façon d'accomplir cette tâche. Existe-t-il une meilleure façon de tester une clé dans le dictionnaire?

inest le moyen prévu pour tester l'existence d'une clé dans un fichier dict.

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

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

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

Si vous vouliez une valeur par défaut, vous pouvez toujours utiliser dict.get():

d = dict()

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

et si vous vouliez toujours garantir une valeur par défaut pour n'importe quelle clé, vous pouvez soit l'utiliser à dict.setdefault()plusieurs reprises ou à defaultdictpartir du collectionsmodule, comme ceci:

from collections import defaultdict

d = defaultdict(int)

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

mais en général, le inmot-clé est le meilleur moyen de le faire.

Vous n'avez pas besoin d'appeler les touches:

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

Cela sera beaucoup plus rapide car il utilise le hachage du dictionnaire plutôt que de faire une recherche linéaire, ce que feraient les touches d'appel.

Vous pouvez tester la présence d'une clé dans un dictionnaire à l'aide du mot clé in :

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

Une utilisation courante pour vérifier l'existence d'une clé dans un dictionnaire avant de la muter est d'initialiser par défaut la valeur (par exemple, si vos valeurs sont des listes, par exemple, et que vous voulez vous assurer qu'il existe une liste vide à laquelle vous pouvez ajouter lors de l'insertion de la première valeur d'une clé). Dans de tels cas, vous pouvez trouver le collections.defaultdict()type d'intérêt.

Dans un code plus ancien, vous pouvez également trouver certaines utilisations de has_key(), une méthode obsolète pour vérifier l'existence de clés dans les dictionnaires (utilisez simplement à la key_name in dict_nameplace).

Vous pouvez raccourcir ceci:

if 'key1' in dict:
    ...

Cependant, c'est au mieux une amélioration cosmétique. Pourquoi pensez-vous que ce n'est pas la meilleure façon?

Pour plus d'informations sur la vitesse d'exécution des méthodes proposées pour la réponse acceptée (boucles de 10 m):

• 'key' in mydict temps écoulé 1,07 sec
• mydict.get('key') temps écoulé 1,84 sec
• mydefaultdict['key'] temps écoulé 1,07 sec

Par conséquent, l'utilisation inou defaultdictest déconseillée get.

Je recommanderais setdefaultplutôt d' utiliser la méthode. On dirait qu'il fera tout ce que vous voulez.

>>> 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}

Le dictionnaire en python a une méthode get ('clé', par défaut). Vous pouvez donc simplement définir une valeur par défaut au cas où il n'y aurait pas de clé.

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

Qu'en est-il de l'utilisation d'EAFP (plus facile de demander pardon que permission):

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

Voir d'autres postes SO:

Utiliser try vs if en python ou

Vérification de l'existence de membres en Python

En utilisant l'opérateur ternaire:

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

Les moyens d'obtenir les résultats sont les suivants:

• if your_dict.has_key (key) supprimé dans Python 3
• si saisissez votre_dict
• essayer / sauf bloquer

Ce qui est mieux dépend de 3 choses:

1. Le dictionnaire «a-t-il normalement la clé» ou «n'a-t-il pas normalement la clé»?
2. Avez-vous l'intention d'utiliser des conditions comme si ... sinon ... elseif ... sinon?
3. Quelle est la taille du dictionnaire?

En savoir plus: http://paltman.com/try-except-performance-in-python-a-simple-test/

Utilisation de try / block au lieu de 'in' ou '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."

Python 2 uniquement: (et python 2.7 prend indéjà en charge )

vous pouvez utiliser la méthode has_key ():

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

Juste une info pour Chris. B (meilleure réponse):

d = defaultdict(int)

Fonctionne également; la raison en est que l'appel int()renvoie 0ce qui se defaultdictpasse en arrière-plan (lors de la construction d'un dictionnaire), d'où le nom "Factory Function" dans la documentation.

Vérifier si une clé donnée existe déjà dans un dictionnaire

Pour avoir une idée de comment faire cela, nous inspectons d'abord les méthodes que nous pouvons appeler dans le dictionnaire. Voici les méthodes:

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

La méthode brutale pour vérifier si la clé existe déjà peut être la get()méthode:

d.get("key")

Les deux autres méthodes intéressantesitems() et keys()semblent trop de travail. Examinons donc si get()c'est la bonne méthode pour nous. Nous avons notre 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}

L'impression montre que la clé que nous n'avons pas sera renvoyée None:

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

Nous pouvons l' utiliser pour obtenir l'information si la clé est présente ou non. Mais considérez ceci si nous créons un dict avec un seul key:None:

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

Diriger cette get()méthode n'est pas fiable au cas où certaines valeurs pourraient l'être None. Cette histoire devrait avoir une fin plus heureuse. Si nous utilisons le incomparateur:

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

Nous obtenons les bons résultats. Nous pouvons examiner le code d'octet 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

Cela montre que l' inopérateur de comparaison n'est pas seulement plus fiable mais encore plus rapide que get().

Le dictionnaire Python a la méthode appelée __contains__. Cette méthode retournera True si le dictionnaire a la clé sinon renvoie 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.

Partager une autre façon de vérifier si une clé existe à l'aide d'opérateurs booléens.

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

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

Cela revient

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

Explication

D' abord , vous devez savoir qu'en Python, 0, Noneou des objets avec une longueur nulle à évaluer False. Tout le reste est évalué True. Les opérations booléennes sont évaluées de gauche à droite et renvoient l'opérande non True ou False.

Voyons un exemple:

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

Puisque 'Some string'évalue à True, le reste de orn'est pas évalué et il n'y a pas de division par zéro d'erreur levée.

Mais si nous passons la commande 1/0est évaluée en premier et déclenche une exception:

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

Nous pouvons l'utiliser pour le modèle pour vérifier si une clé existe.

(k in d and 'blah')

fait la même chose que

if k in d:
    'blah'
else:
    False

Cela renvoie déjà le résultat correct si la clé existe, mais nous voulons qu'elle affiche «boo» lorsqu'elle ne l'est pas. Donc, nous prenons le résultat et oravec'boo'

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

Vous pouvez utiliser la forboucle pour parcourir le dictionnaire et obtenir le nom de la clé que vous souhaitez trouver dans le dictionnaire, après cela, vérifiez si elle existe ou n'utilise pas la ifcondition:

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')