Vérifier si une clé donnée existe déjà dans un dictionnaire
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 un meilleur moyen de tester une clé dans le dictionnaire?
in est le moyen prévu pour tester l'existence d'une clé dans un dict.
d = dict()
for i in xrange(100):
key = i % 10
if key in d:
d[key] += 1
else:
d[key] = 1
Si vous voulez une valeur par défaut, vous pouvez toujours utiliser dict.get():
d = dict()
for i in xrange(100):
key = i % 10
d[key] = d.get(key, 0) + 1
... et si vous voulez toujours assurer une valeur par défaut pour toute clé, vous pouvez utiliser defaultdict à partir du module collections, comme suit:
from collections import defaultdict
d = defaultdict(lambda: 0)
for i in xrange(100):
d[i % 10] += 1
... mais en général, le mot clé in est le meilleur moyen de le faire.
Vous n'êtes pas obligé d'appeler des clés:
if 'key1' in dict:
print "blah"
else:
print "boo"
Ce sera beaucoup plus rapide car il utilise le hachage du dictionnaire au lieu 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 de la touche dans mot-clé:
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 le muter consiste à initialiser la valeur par défaut (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, le type collections.defaultdict() pourrait vous intéresser.
Dans le code plus ancien, vous pouvez également trouver quelques utilisations de has_key(), une méthode déconseillée pour vérifier l'existence de clés dans les dictionnaires (utilisez plutôt key_name in dict_name à la place).
Vous pouvez raccourcir ceci:
if 'key1' in dict:
...
Cependant, il s’agit au mieux d’une amélioration esthétique. Pourquoi pensez-vous que ce n'est pas la meilleure façon?
Je recommanderais d'utiliser la méthode setdefault à la place. On dirait que cela 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}
Pour plus d'informations sur l'exécution rapide des méthodes proposées par la réponse acceptée (boucles de 10 m):
'key' in mydicttemps écoulé 1.07 secmydict.get('key')temps écoulé 1.84 secmydefaultdict['key']temps écoulé 1.07 sec
Par conséquent, l'utilisation de in ou defaultdict est recommandée par rapport à get.
Dictionnaire en python a une méthode get ('clé', valeur 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 de l'EAFP (il est plus facile de demander pardon que l'autorisation):
try:
blah = dict["mykey"]
# key exists in dict
except KeyError:
# key doesn't exist in dict
Voir d'autres SO messages:
Utilisation de l'opérateur ternaire:
message = "blah" if 'key1' in dict else "booh"
print(message)
Pour vérifier, vous pouvez utiliser la méthode has_key()
if dict.has_key('key1'):
print "it is there"
Si vous voulez une valeur, vous pouvez utiliser la méthode get()
a = dict.get('key1', expeced_type)
Si vous voulez un tuple, une liste, un dictionnaire ou une chaîne comme valeur par défaut comme valeur de retour, utilisez la méthode get().
a = dict.get('key1', {}).get('key2', [])
Voici comment vous pouvez obtenir les résultats:
- if your_dict.has_key (key) Supprimé en Python 3
- si clé dans your_dict
- essayer/sauf bloquer
Ce qui est mieux dépend de 3 choses:
- Est-ce que le dictionnaire "a normalement la clé" ou "normalement n'a pas la clé"?.
- Avez-vous l'intention d'utiliser des conditions telles que si… autre… autre… autre?
- Quelle est la taille du dictionnaire?
Lire la suite: 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."
Juste un ajout à Chris. B (meilleure réponse):
d = defaultdict(int)
Fonctionne aussi bien; La raison en est que l'appel de int() renvoie 0, ce que defaultdict fait en arrière-plan (lors de la construction d'un dictionnaire), d'où le nom "Factory Function" dans la documentation.
Vous pouvez utiliser la méthode has_key ():
if dict.has_key('xyz')==1:
#update the value for the key
else:
pass
Ou la méthode dict.get pour définir une valeur par défaut si non trouvée:
mydict = {"a": 5}
print mydict["a"] #prints 5
print mydict["b"] #Throws KeyError: 'b'
print mydict.get("a", 0) #prints 5
print mydict.get("b", 0) #prints 0
Le dictionnaire Python a la méthode appelée __contains__. Cette méthode retournera True si le dictionnaire a la clé, sinon 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.
Pour vérifier si une clé donnée existe dans un dictionnaire, utilisez l'une des approches suivantes:
Première approche (travaillant en Python 3):
def checkKey(dict, key):
if key in dict.keys():
print("Key is here, ", end =" ")
print("value =", dict[key])
else:
print("Key isn't present.")
Vérifions cela:
dict = {'r': 30, 'g':59, 'b':11}
key = 'b'
checkKey(dict, key)
key = 'a'
checkKey(dict, key)
Résultat de Approach One:
# Key is here, value = 11
# Key isn't present.
Approche Deux (travaillant en Python 3):
def checkKey(dict, key):
if key in dict:
print("Key is here, ", end =" ")
print("value =", dict[key])
else:
print("Key isn't present.")
Vérifions aussi:
dict = {'x': 10, 'y':20, 'z':30}
key = 'y'
checkKey(dict, key)
key = 'u'
checkKey(dict, key)
Résultat de Approach Two:
# Key is here, value = 20
# Key isn't present.
Approche Trois (travaillant en Python 3):
def checkKey(dict, key):
if dict.has_key(key):
print "Key is here, value =", dict[key]
else:
print "Key isn't present."
Vérifions aussi:
dict = {'u': 0, 'v':1, 'w':2}
key = 'u'
checkKey(dict, key)
key = 'm'
checkKey(dict, key)
Résultat de Approach Three:
# Key is here, value = 0
# Key isn't present.
J'espère que cela t'aides.
Partage d'une autre manière 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 retourne
>>> blah
>>> blah
>>> boo
>>> boo
Explication
Tout d'abord, vous devez savoir qu'en Python, 0, None ou les objets de longueur nulle sont évalués à False. Tout le reste est évalué à True. Les opérations booléennes sont évaluées de gauche à droite et renvoient l'opérande non Vrai ou Faux.
Voyons un exemple:
>>> 'Some string' or 1/0
'Some string'
>>>
Puisque 'Some string' est évalué à True, le reste de la or n'est pas évalué et aucune erreur de division par zéro n'est générée.
Mais si nous commutons l'ordre 1/0 est évalué en premier et lève une exception:
>>> 1/0 or 'Some string'
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
ZeroDivisionError: division by zero
>>>
Nous pouvons utiliser ceci pour motif afin de 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 souhaitons qu'elle imprime 'boo' lorsqu'elle ne le fait pas. Donc, on prend le résultat et or le avec 'boo'
>>> False or 'boo'
'boo'
>>> 'blah' or 'boo'
'blah'
>>>
Eh bien .. Vous savez sûrement que rechercher l’existence d’un élément dans une liste ou dans des données signifie tout parcourir (au moins pour une liste non ordonnée, par exemple, dict.keys). Ainsi, en utilisant Exception et Erreurs qui apparaissent normalement, nous pouvons éviter cette complexité ...
d={1:'a',2:'b'}
try:
needed=d[3]
print(needed)
except:
print("Key doesnt exist")
Le plus simple est de savoir quelle clé (nom de clé) doit être recherchée:
# suppose your dictionary is
my_dict = {'foo': 1, 'bar': 2}
# check if a key is there
if 'key' in my_dict.keys(): # it will evaluates to true if that key is present otherwise false.
# do something
ou vous pouvez aussi simplement faire comme:
if 'key' in my_dict: # it will evaluates to true if that key is present otherwise false.
# do something
J'utilise le try/except ; si une exception est levée, alors la clé n'est pas présente dans le dictionnaire . exemple:
st = 'sdhfjaks'
d = {}
try:
print d['st']
except Exception, e:
print 'Key not in the dictionary'
Vérifier si une clé donnée existe déjà dans un dictionnaire
Pour avoir une idée de la manière de procéder, nous examinons d’abord les méthodes auxquelles nous pouvons faire appel au 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 méthode get():
d.get("key")
Les deux autres intéressant méthodes items() et keys() semblent trop demander. Examinons donc si get() 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 retournera None:
print(d.get('key')) #None
print(d.get('clear')) #0
print(d.get('copy')) #1
Nous peut utilisez-le pour obtenir les informations 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 méthode get() n'est pas fiable au cas où certaines valeurs pourraient être None. Cette histoire devrait avoir une fin plus heureuse. Si nous utilisons le comparateur in:
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'opérateur de comparaison in est non seulement plus fiable mais encore plus rapide que get().
Vous pouvez utiliser for for pour aller dans chaque élément du dictionnaire et obtenir le nom de ce que vous voulez trouver dans le dictionnaire, puis vérifiez s'il existe ou non comme ça:
dic={‘first’ : 12, ‘second’ : 123}
For each in dic :
If each == ‘second’:
Print (‘it is exist’)
else :
print (‘not exist’)