Prüfen Sie, ob ein bestimmter Schlüssel in einem Wörterbuch bereits vorhanden ist

Sie müssen keine Tasten anrufen:

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

Das wird viel schneller sein, da es das Hashing des Wörterbuchs verwendet, anstatt eine lineare Suche durchzuführen, die die aufrufenden Schlüssel tun würden.

Mit dem können Sie das Vorhandensein eines Schlüssels in einem Wörterbuch testen im Stichwort:

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

Um die Existenz eines Schlüssels in einem Wörterbuch zu prüfen, bevor Sie das Wort ändern, wird der Wert standardmäßig initialisiert (z. B. wenn Ihre Werte beispielsweise Listen sind und Sie sicherstellen möchten, dass eine leere Liste vorhanden ist, an die Sie anhängen können beim Einfügen des ersten Wertes für einen Schlüssel). In solchen Fällen kann der Typ collections.defaultdict() von Interesse sein.

In älterem Code finden Sie möglicherweise auch einige Verwendungen von has_key(), einer veralteten Methode zum Überprüfen der Existenz von Schlüsseln in Wörterbüchern (verwenden Sie stattdessen key_name in dict_name).

Sie können dies verkürzen:

if 'key1' in dict:
    ...

Dies ist jedoch bestenfalls eine kosmetische Verbesserung. Warum glauben Sie, dass dies nicht der beste Weg ist?

Ich würde empfehlen, stattdessen die setdefault-Methode zu verwenden. Es klingt, als würde es alles tun, was Sie wollen.

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

Weitere Informationen zur Geschwindigkeitsausführung der vorgeschlagenen Antwortmethoden (10m-Schleifen):

• 'key' in mydict verstrichene Zeit 1,07 sek
• mydict.get('key') verstrichene Zeit 1,84 sek
• mydefaultdict['key'] verstrichene Zeit 1,07 sek

Daher wird die Verwendung von in oder defaultdict gegen get empfohlen.

Das Wörterbuch in Python hat eine get-Methode ("key", Standardeinstellung). Sie können also einfach einen Standardwert festlegen, falls kein Schlüssel vorhanden ist. 

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

Was ist mit der Verwendung von EAFP (leichter um Vergebung als um Erlaubnis zu bitten):

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

Siehe andere SO Beiträge:

Verwenden von try vs wenn in Python oder

Überprüfung der Existenz von Mitgliedern in Python

Ternären Operator verwenden:

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

Zur Überprüfung können Sie die has_key()-Methode verwenden 

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

Wenn Sie einen Wert wünschen, können Sie die get()-Methode verwenden

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

Wenn Sie einen Tupel oder eine Liste oder ein Wörterbuch oder einen beliebigen String als Standardwert als Rückgabewert verwenden möchten, verwenden Sie die get()-Methode

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

Die Ergebnisse, auf die Sie die Ergebnisse erhalten können, sind:

• if your_dict.has_key (key) In Python 3 entfernt
• wenn Sie in Ihr_Dict eingeben
• versuche/außer sperren

Was besser ist, hängt von 3 Dingen ab:

1. Hat das Wörterbuch "normalerweise den Schlüssel" oder "hat normalerweise keinen Schlüssel".
2. Beabsichtigen Sie, Bedingungen zu verwenden, wenn ... sonst ... elseif ... anders?
3. Wie groß ist das Wörterbuch?

Lesen Sie mehr: http://paltman.com/try-except-performance-in-python-a-simple-test/

Verwendung von try/block anstelle von 'in' oder '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."

Nur eine FYI, die Chris hinzufügt. B (beste Antwort):

d = defaultdict(int)

Funktioniert auch Der Grund ist, dass der Aufruf von int()0 zurückgibt, was defaultdict im Hintergrund (beim Erstellen eines Wörterbuchs) ausführt, daher der Name "Factory Function" in der Dokumentation.

Sie können die Methode has_key () verwenden:

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

Oder die dict.get-Methode zum Festlegen eines Standardwerts, falls nicht gefunden:

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

Gibt für die Werte im Diktat kein boo aus, erreicht das Ziel jedoch, indem der Wert von key1 gedruckt wird, um stattdessen seine Existenz zu bestätigen.

Das Python-Wörterbuch hat die Methode __contains__. Diese Methode gibt True zurück, wenn das Wörterbuch den Schlüssel enthält. Andernfalls wird False zurückgegeben.

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

Um zu überprüfen, ob ein bestimmter Schlüssel in einem Wörterbuch vorhanden ist, sollten Sie eine der folgenden Methoden verwenden

Ansatz 1 (in 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.") 

Lass es uns überprüfen:

dict = {'r': 30, 'g':59, 'b':11} 

key = 'b'
checkKey(dict, key) 

key = 'a'
checkKey(dict, key) 

Ergebnis von Approach One:

# Key is here, value = 11
# Key isn't present.

Ansatz Zwei (in 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.") 

Lass es uns auch überprüfen: 

dict = {'x': 10, 'y':20, 'z':30} 

key = 'y'
checkKey(dict, key) 

key = 'u'
checkKey(dict, key) 

Ergebnis von Approach Two:

# Key is here, value = 20
# Key isn't present.

Ansatz 3 (in Python 3 arbeiten):

def checkKey(dict, key):      
    if dict.has_key(key): 
        print "Key is here, value =", dict[key] 
    else: 
        print "Key isn't present."

Lass es uns auch überprüfen:

dict = {'u': 0, 'v':1, 'w':2} 

key = 'u'
checkKey(dict, key) 

key = 'm'
checkKey(dict, key)

Ergebnis von Approach Three:

# Key is here, value = 0
# Key isn't present.

Hoffe das hilft.

Eine weitere Möglichkeit zum Überprüfen, ob ein Schlüssel vorhanden ist, mithilfe von Booleschen Operatoren.

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

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

Dies kehrt zurück

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

Erklärung

Zunächst sollten Sie wissen, dass in Python 0, None oder Objekte mit einer Länge von Null zu False ausgewertet werden. Alles andere ergibt True. Boolesche Operationen werden von links nach rechts ausgewertet und geben den Operanden nicht True oder False zurück.

Sehen wir uns ein Beispiel an:

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

Da 'Some string' zu True ausgewertet wird, wird der Rest der or nicht ausgewertet und es wird kein Fehler durch Division durch Null ausgelöst.

Wenn wir jedoch die Reihenfolge ändern, wird 1/0 zuerst ausgewertet und löst eine Ausnahme aus:

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

Wir können dieses Muster verwenden, um zu prüfen, ob ein Schlüssel vorhanden ist.

(k in d and 'blah')

macht das selbe wie

if k in d:
    'blah'
else:
    False

Dies gibt bereits das richtige Ergebnis zurück, wenn der Schlüssel vorhanden ist, aber wir möchten, dass er "boo" druckt, wenn dies nicht der Fall ist. Also nehmen wir das Ergebnis und or es mit 'boo'

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

Nun, Sie werden wissen, dass das Suchen eines Elements in einer Liste oder in Daten bedeutet, dass Sie alles durchgehen müssen (zumindest für ungeordnete Listen, z. B. dict.keys). Stattdessen verwenden Sie die normalerweise auftretenden Ausnahmen und Fehler.

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

Am einfachsten ist es, wenn Sie wissen, nach welchem ​​Schlüssel (Schlüsselname) gesucht werden soll:

# 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

oder Sie können auch einfach als:

if 'key' in my_dict:   # it will evaluates to true if that key is present otherwise false.
    # do something

Ich benutze das try/except ; Wenn eine Ausnahme ausgelöst wird, ist der Schlüssel nicht im Wörterbuch vorhanden. Beispiel:

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

Überprüfen Sie, ob ein bestimmter Schlüssel bereits in einem Wörterbuch vorhanden ist

Um die Idee zu bekommen, wie das geht, untersuchen wir zunächst, welche Methoden wir für Dictionary aufrufen können. Hier sind die Methoden:

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

Die brutale Methode, um zu überprüfen, ob der Schlüssel bereits vorhanden ist, ist möglicherweise die Methode get():

d.get("key")

Die anderen beiden interessanten Methoden items() und keys() klingen nach zu viel Arbeit. Untersuchen wir also, ob get() die richtige Methode für uns ist. Wir haben unser Diktum d:

d= {'clear':0, 'copy':1, 'fromkeys':2, 'get':3, 'items':4, 'keys':5, 'pop':6, 'popitem':7, 'setdefault':8, 'update':9, 'values':10}

Das Drucken zeigt, dass der Schlüssel, den wir nicht haben, None zurückgibt:

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

Wir kann Verwenden Sie diese Option, um die Informationen abzurufen, wenn der Schlüssel vorhanden ist oder nicht. Beachten Sie jedoch Folgendes, wenn wir ein Diktat mit einem einzigen key:None erstellen:

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

Dies führt dazu, dass die Methode get() nicht zuverlässig ist, wenn einige Werte None sein können. Diese Geschichte sollte ein glücklicheres Ende haben. Wenn wir den Komparator in verwenden:

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

Wir bekommen die richtigen Ergebnisse. Wir können den Python-Bytecode untersuchen:

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

Dies zeigt, dass der Vergleichsoperator in nicht nur zuverlässiger, sondern auch schneller ist als get().

Sie können die for-Schleife verwenden, um in jedes Element in das Wörterbuch einzusteigen und den Namen zu finden, den Sie im Wörterbuch suchen möchten. Überprüfen Sie anschließend, ob es vorhanden ist oder nicht: 

dic={‘first’ : 12, ‘second’ : 123}
For each in dic :
If each == ‘second’: 
    Print (‘it is exist’)
else :
     print (‘not exist’)