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

Vous n'avez pas à appeler clés:

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

beaucoup plus vite , comme on utilise un dictionnaire de hachage plutôt que de faire une recherche linéaire, appelant les touches ferait.

vous pouvez tester la présence d'une clé dans un dictionnaire, en utilisant le 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 la muter est d'initialiser la valeur par défaut (par exemple si vos valeurs sont des listes, par exemple, et vous voulez vous assurer qu'il y a une liste vide à laquelle vous pouvez ajouter lors de l'insertion de la première valeur pour une clé). Dans de tels cas, vous pouvez trouver le collections.defaultdict() type d'intérêt.

dans l'ancien code, vous pouvez également trouver quelques utilisations de has_key() , une méthode dépréciée pour vérifier l'existence de clés dans les dictionnaires (il suffit d'utiliser 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 croyez-vous que ce n'est pas la meilleure façon?

je recommande d'utiliser plutôt la méthode setdefault . 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}

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

• '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 de in ou defaultdict est recommandée contre get .

en python a une méthode get('key', default). 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 (plus facile de demander pardon que la permission):

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

Voir les autres, de SORTE que les messages:

utilisant try vs si en python ou

Vérifier membre de l'existence en Python

pour le contrôle vous pouvez utiliser has_key() méthode

if dict.has_key('key1'):
   print "it is there"

Si vous voulez une valeur, vous pouvez utiliser get() méthode

a = dict.get('key1', expeced_type)

si vous voulez un tuple ou une liste ou un dictionnaire ou n'importe quelle chaîne comme valeur par défaut comme valeur de retour, puis utiliser get() méthode

a = dict.get('key1', {}).get('key2', [])

utilisant l'opérateur ternaire:

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

juste un ajout POUR INFO à Chris. B (meilleure réponse):

d = defaultdict(int)

fonctionne aussi; la raison est que l'appel int() retourne 0 ce qui est ce que defaultdict fait dans les coulisses (lors de la construction d'un dictionnaire), d'où le nom" fonction D'usine " dans la documentation.

les moyens par lesquels vous pouvez obtenir les résultats sont:

• si votre_dict.has_key (key) supprimé en Python 3
• si la clé dans your_dict
• try/except bloc

ce qui est mieux dépend de 3 choses:

1. le dictionnaire "normalement a la clé" ou " normalement ne ne pas avoir la clé".
2. avez-vous l'intention d'utiliser des conditions comme si...autre...elseif...d'autre?
3. 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."

vous pouvez utiliser la méthode has_key ():

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

Ou la dict.get méthode pour définir une valeur par défaut si non trouvé:

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

print dict.get('key1', 'blah')

n'imprimera pas boo pour les valeurs dans le dict, mais accomplit le but en imprimant la valeur de key1 pour confirmer son existence à la place.

Python dictionnaire de la méthode dite du __contains__ . Cette méthode retournera True si le dictionnaire a la clé else retourne 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.

bien.. Vous savez que la recherche de l'existence d'un élément dans une liste ou des données signifie tout PARCOURIR (du moins pour la liste non classée E. g dict.keys).Ainsi, en utilisant les exceptions et les erreurs qui se produisent normalement, nous pouvons éviter cette complexité...

d={1:'a',2:'b'}
try:
    needed=d[3]
    print(needed)
except:
    print("Key doesnt exist")

le plus facile est si vous savez quelle clé (nom de clé) est à rechercher:

# 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 faire simplement 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 avaient envoyé, que les clés ne sont pas présents dans le dictionnaire. exemple:

st = 'sdhfjaks'
d = {}
try:
    print d['st']
except Exception, e:
    print 'Key not in the dictionary'

pourquoi ne pas utiliser simplement la méthode has_key ().

a = {}
a.has_key('b') => #False

a['b'] = 8
a.has_key('b') => #True