Chciałem sprawdzić, czy klucz istnieje w słowniku przed zaktualizowaniem wartości klucza. Napisałem następujący kod:

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

Myślę, że nie jest to najlepszy sposób na wykonanie tego zadania. Czy jest lepszy sposób na sprawdzenie klucza w słowniku?

injest zamierzonym sposobem sprawdzenia istnienia klucza w pliku dict.

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

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

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

Jeśli chcesz mieć wartość domyślną, zawsze możesz użyć dict.get():

d = dict()

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

a jeśli chcesz zawsze zapewnić domyślną wartość dla dowolnego klucza, którego możesz użyć dict.setdefault()wielokrotnie lub defaultdictz collectionsmodułu, na przykład:

from collections import defaultdict

d = defaultdict(int)

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

ale ogólnie insłowo kluczowe jest najlepszym sposobem na to.

Nie musisz dzwonić na klucze:

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

Będzie to znacznie szybsze, ponieważ używa haszowania słownika w przeciwieństwie do wyszukiwania liniowego, co robiłyby klawisze wywoływania.

Możesz sprawdzić obecność klucza w słowniku, używając słowa kluczowego in :

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

Typowym zastosowaniem do sprawdzania istnienia klucza w słowniku przed jego mutacją jest domyślna inicjalizacja wartości (np. Jeśli twoje wartości są na przykład listami i chcesz upewnić się, że istnieje pusta lista, do której możesz dołączyć podczas wstawiania pierwszej wartości klucza). W takich przypadkach może okazać się interesujący collections.defaultdict()typ.

W starszym kodzie można również znaleźć niektóre zastosowania has_key()przestarzałej metody sprawdzania istnienia kluczy w słownikach (wystarczy użyć key_name in dict_namezamiast tego).

Możesz to skrócić:

if 'key1' in dict:
    ...

Jest to jednak w najlepszym przypadku kosmetyczna poprawa. Dlaczego uważasz, że to nie jest najlepszy sposób?

Aby uzyskać dodatkowe informacje na temat szybkości wykonywania proponowanych metod przyjętej odpowiedzi (pętle 10 m):

• 'key' in mydict czas, który upłynął 1,07 sek
• mydict.get('key') czas, który upłynął 1,84 sek
• mydefaultdict['key'] czas, który upłynął 1,07 sek

Dlatego przy użyciu inlub defaultdictsą zalecane przeciwko get.

setdefaultZamiast tego poleciłbym użycie tej metody. Wygląda na to, że zrobi wszystko, co chcesz.

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

Słownik w Pythonie ma metodę get ('key', domyślnie). Możesz więc ustawić wartość domyślną na wypadek, gdyby nie było klucza.

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

Co z użyciem EAFP (łatwiej poprosić o wybaczenie niż zgodę):

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

Zobacz inne posty SO:

Używanie try vs, jeśli w Pythonie lub

Sprawdzanie istnienia członka w Pythonie

Za pomocą operatora trójskładnikowego:

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

Sposoby uzyskania wyników to:

• if your_dict.has_key (key) Usunięte w Python 3
• jeśli wpisz swój_dykt
• spróbuj / z wyjątkiem bloku

To, co jest lepsze, zależy od 3 rzeczy:

1. Czy słownik „zwykle ma klucz”, czy „zwykle nie ma klucza”.
2. Czy zamierzasz stosować warunki, takie jak jeśli ... else ... elseif ... else?
3. Jak duży jest słownik?

Czytaj więcej: http://paltman.com/try-except-performance-in-python-a-simple-test/

Użycie try / block zamiast „in” lub „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."

Tylko Python 2: (i Python 2.7 injuż obsługuje )

możesz użyć metody has_key ():

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

Tylko dodatkowa informacja dla Chrisa. B (najlepsza odpowiedź):

d = defaultdict(int)

Działa również; Powodem jest to, że wywoływanie int()zwraca 0to, co defaultdictrobi za kulisami (podczas konstruowania słownika), stąd nazwa „Funkcja fabryczna” w dokumentacji.

Sprawdź, czy dany klucz już istnieje w słowniku

Aby dowiedzieć się, jak to zrobić, najpierw sprawdzamy, jakie metody możemy wywołać w słowniku. Oto metody:

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

Brutalna metoda sprawdzenia, czy klucz już istnieje, może być następującą get()metodą:

d.get("key")

Pozostałe dwie interesujące metody items()i keys()brzmią jak zbyt dużo pracy. Sprawdźmy więc, czy get()jest to dla nas właściwa metoda. Mamy nasz dyktand d:

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

Drukowanie pokazuje, że klucz, którego nie mamy, powróci None:

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

My może używać, aby uzyskać informacje, czy klucz jest obecny lub nie. Ale rozważ to, jeśli utworzymy dyktat z jednym key:None:

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

Prowadzenie tej get()metody nie jest wiarygodne w przypadku, gdy niektóre wartości mogą być None. Ta historia powinna mieć szczęśliwsze zakończenie. Jeśli użyjemy inkomparatora:

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

Otrzymujemy prawidłowe wyniki. Możemy zbadać kod bajtowy Pythona:

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

To pokazuje, że inoperator porównania jest nie tylko bardziej niezawodny, ale nawet szybszy niż get().

Słownik Python ma metodę o nazwie __contains__. Ta metoda zwróci True, jeśli słownik ma klucz, a inna zwróci 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.

Udostępnianie jeszcze jednego sposobu sprawdzania, czy klucz istnieje za pomocą operatorów logicznych.

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

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

To zwraca

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

Wyjaśnienie

Po pierwsze należy wiedzieć, że w Pythonie 0, Nonelub obiektów o zerowej długości do oceny False. Wszystko inne ocenia True. Operacje logiczne są oceniane od lewej do prawej i zwracają operand nie Prawda lub Fałsz.

Zobaczmy przykład:

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

Ponieważ 'Some string'ocenia na True, reszta ornie jest oceniana i nie występuje podział przez błąd zerowy.

Ale jeśli zmienimy, 1/0najpierw oceniane jest zamówienie i pojawia się wyjątek:

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

Możemy użyć tego do wzorca do sprawdzenia, czy klucz istnieje.

(k in d and 'blah')

robi to samo co

if k in d:
    'blah'
else:
    False

To już zwraca poprawny wynik, jeśli klucz istnieje, ale chcemy, aby wypisał „boo”, gdy nie istnieje. Tak więc bierzemy wynik i orto z'boo'

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

Możesz użyć forpętli do iteracji w słowniku i uzyskać nazwę klucza, który chcesz znaleźć w słowniku, a następnie sprawdź, czy istnieje, czy nie używa ifwarunku:

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