Iteracja słowników za pomocą pętli 'for'

Nie chodzi o to, że klucz jest specjalnym słowem, ale o to, że słowniki implementują protokół iteratora. Możesz to zrobić w swojej klasie, np. zobacz to pytanie Jak budować Iteratory klas.

W przypadku słowników jest zaimplementowany na poziomie C. Szczegóły są dostępne w PEP 234 . W szczególności sekcja zatytułowana "Iteratory słownikowe":

• Słowniki implementują slot tp_iter, który zwraca efektywną iterator to iteruje nad kluczami słownika. [...] To oznacza, że możemy napisać

  for k in dict: ...
  

  Co jest równoważne, ale znacznie szybsze niż

  for k in dict.keys(): ...
  

  O ile ograniczenie zmian w słowniku (albo przez pętlę, albo przez inny wątek) nie są naruszane.

• Dodawanie metod do słowników zwracających różne rodzaje Iteratory:

  for key in dict.iterkeys(): ...
  
  for value in dict.itervalues(): ...
  
  for key, value in dict.iteritems(): ...
  

  Oznacza to, że for x in dict jest skrótem od for x in dict.iterkeys().

W Pythonie 3, dict.iterkeys(), dict.itervalues() i dict.iteritems() nie są już obsługiwane. Użycie dict.keys(), dict.values() i dict.items() zamiast tego.

Iteracja nad dict iteracja przez klucze w żadnej konkretnej kolejności, jak widać tutaj:

(to jest nie ma już sprawy w Pythonie 3.6, ale zauważ, że to nie jest jeszcze gwarantowane zachowanie.)

>>> d = {'x': 1, 'y': 2, 'z': 3}
>>> list(d)
['y', 'x', 'z']
>>> d.keys()
['y', 'x', 'z']

Dla Twojego przykładu lepszym pomysłem jest użycie dict.items():

>>> d.items()
[('y', 2), ('x', 1), ('z', 3)]

To daje listę krotek. Gdy zapętlisz je w ten sposób, każda krotka jest rozpakowana do k i v automatycznie:

for k,v in d.items():
    print(k, 'corresponds to', v)

Za pomocą k i v jako nazwy zmiennych, gdy pętla nad dict jest dość powszechna, jeśli ciało pętli składa się tylko z kilku linii. W przypadku bardziej skomplikowanych pętli dobrym pomysłem może być użycie bardziej opisowych nazw:

for letter, number in d.items():
    print(letter, 'corresponds to', number)

Dobrym pomysłem jest przyzwyczajenie się do używania ciągów formatujących:

for letter, number in d.items():
    print('{0} corresponds to {1}'.format(letter, number))

key jest po prostu zmienną.

Dla Python2.X :

d = {'x': 1, 'y': 2, 'z': 3} 
for my_var in d:
    print my_var, 'corresponds to', d[my_var]

... albo lepiej,

d = {'x': 1, 'y': 2, 'z': 3} 
for the_key, the_value in d.iteritems():
    print the_key, 'corresponds to', the_value

Dla Python3.X :

d = {'x': 1, 'y': 2, 'z': 3} 
for the_key, the_value in d.items():
    print(the_key, 'corresponds to', the_value)

W przypadku iteracji przez słowniki przy użyciu składni for .. in .., zawsze iteracja odbywa się nad kluczami (wartości są dostępne przy użyciu dictionary[key]).

Do iteracji par klucz-wartość, w Pythonie 2 Użyj for k,v in s.iteritems(), a w Pythonie 3 for k,v in s.items().

Jest to bardzo popularny idiom pętli. in jest operatorem. Aby dowiedzieć się, kiedy używać for key in dict i kiedy musi być for key in dict.keys() Zobacz David Goodger ' s idiomatic Python article (archived copy).

Iteracja słowników za pomocą pętli ' for '

d = {'x': 1, 'y': 2, 'z': 3} 
for key in d:
    ...

Jak Python rozpoznaje, że potrzebuje tylko odczytać klucz z słownik? Czy key to specjalne słowo w Pythonie? Czy jest to po prostu zmienna?

To nie tylko for pętle. Ważne słowo to "iteracja".

Słownik jest odwzorowaniem kluczy do wartości:

d = {'x': 1, 'y': 2, 'z': 3} 

Za każdym razem, gdy nad nim iterujemy, iterujemy nad kluczami. Nazwa zmiennej key jest przeznaczona tylko być opisowym - i to jest całkiem trafne do celu.

Dzieje się tak w pojęciu listy:

>>> [k for k in d]
['x', 'y', 'z']

Dzieje się tak, gdy przekazujemy słownik do list (lub dowolnego innego obiektu typu collection):

>>> list(d)
['x', 'y', 'z']

>>> d.__iter__()
<dict_keyiterator object at 0x7fb1747bee08>

Nie powinniśmy używać tych specjalnych metod sami, zamiast tego użyj odpowiedniej wbudowanej funkcji, aby ją wywołać, iter:

>>> key_iterator = iter(d)
>>> key_iterator
<dict_keyiterator object at 0x7fb172fa9188>

Iteratory mają metodę __next__ - ale nazywamy ją wbudowaną funkcją, next:

>>> next(key_iterator)
'x'
>>> next(key_iterator)
'y'
>>> next(key_iterator)
'z'
>>> next(key_iterator)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
StopIteration

>>> list(key_iterator)
[]
>>> new_key_iterator = iter(d)
>>> list(new_key_iterator)
['x', 'y', 'z']

Powrót do dicts

Widzieliśmy iterację dictów w wielu kontekstach. Widzieliśmy, że za każdym razem, gdy powtarzamy dyktafon, dostajemy klucze. Powrót do oryginalnego przykładu:

d = {'x': 1, 'y': 2, 'z': 3} 
for key in d:

Jeśli zmienimy nazwę zmiennej, nadal otrzymamy klucze. Spróbujmy:

>>> for each_key in d:
...     print(each_key, '=>', d[each_key])
... 
x => 1
y => 2
z => 3

Jeśli chcemy iterować nad wartościami, musimy użyć metody .values dicts, lub dla obu razem, .items:

>>> list(d.values())
[1, 2, 3]
>>> list(d.items())
[('x', 1), ('y', 2), ('z', 3)]

W podanym przykładzie byłoby bardziej wydajne iteracje nad przedmiotami takimi jak:

for a_key, corresponding_value in d.items():
    print(a_key, corresponding_value)

Ale dla celów akademickich, przykład pytania jest w porządku.

Mam przypadek użycia, w którym muszę iterować przez dict, aby uzyskać klucz, parę wartości, a także indeks wskazujący, gdzie jestem. Tak to robię:

d = {'x': 1, 'y': 2, 'z': 3} 
for i, (key, value) in enumerate(d.items()):
   print(i, key, value)

Zauważ, że nawiasy wokół klucza, wartość jest ważna, bez nawiasów, otrzymasz ValueError "za mało wartości do rozpakowania".

Możesz sprawdzić implementację dicttype Cpythona na Githubie. Jest to sygnatura metody implementującej iterator dict:

_PyDict_Next(PyObject *op, Py_ssize_t *ppos, PyObject **pkey,
             PyObject **pvalue, Py_hash_t *phash)

CPython dictobject.c

To wyświetli wyjście w posortowane w kolejności według wartości w kolejności rosnącej.

d = {'x': 3, 'y': 1, 'z': 2}

def by_value(item):
    return item[1]

for key, value in sorted(d.items(), key=by_value):
    print(key, '->', value)

Wyjście:

Aby iterować nad kluczami, jest wolniejsze, ale lepiej używać my_dict.keys(). Jeśli próbowałeś zrobić coś takiego:

for key in my_dict:
    my_dict[key+"-1"] = my_dict[key]-1

Spowoduje to powstanie błędu runtime, ponieważ zmieniasz klucze podczas działania programu. Jeśli jesteś absolutnie nastawiony na skrócenie czasu, skorzystaj ze sposobu for key in my_dict, ale zostałeś ostrzeżony;).

Jeśli szukasz jasnego i wizualnego przykładu:

cat  = {'name': 'Snowy', 'color': 'White' ,'age': 14}
for key , value in cat.items():
   print(key, ': ', value)

Wynik:

name:  Snowy
color:  White
age:  14

Tutaj key jest tylko Nazwa zmiennej.

Key nie jest specjalnym słowem kluczowym w Pythonie.

Jak wiemy, w słownik Pythona jest zbiorem par key: value, z wymogiem, że klucze są unikalne (w ramach jednego słownika). Para szelek tworzy empty dictionary: {}. Umieszczenie oddzielonej przecinkami listy key:value par wewnątrz szelek dodaje początkowe key:value par do słownika .

Jest to najprostszy sposób na iterację przez słownik w Pythonie. Wystarczy umieścić go bezpośrednio w dla pętli, i gotowe!

d = {'x': 1, 'y': 2, 'z': 3}
for key in d:
  print (key)

Wyjście to:-

x # Here x is key name
y # Here y is key name
z # Here z is key name

Jeśli użyjemy tego podejścia wraz z małą sztuczką, możemy przetworzyć klucze i wartości dowolnego słownika . Sztuczka polega na użyciu indexing operator [] ze słownikiem i jego kluczami , aby uzyskać dostęp do wartości :

d = {'x': 1, 'y': 2, 'z': 3} # Dictionary
for key in d:
  print (key, 'corresponds to', d[key]) # Keys (key) and the values (d[key])
                                        # of d at the same time

Wyjście jest następujące:

x corresponds to 1 # Here 'x' is key and 1 is value
y corresponds to 2 # Here 'y' is key and 2 is value
z corresponds to 3 # Here 'z' is key and 3 is value

Poprzedni kod pozwala na uzyskanie dostępu do kluczy (key) i wartości (d[key]) z d (d jest nazwą słownika) w tym samym czasie. W ten sposób możemy wykonać dowolną operację zarówno z kluczami , jak i z wartościami .

Możemy również iteratr nad słownikiem używając pętli dla w ten sposób:

for key_name, _value in d.items():
  print(key_name, ":", _value)
  # key_name and _value are variable names.

Wyjście następującej treści to:

x : 1
y : 2
z : 3

Mam nadzieję, że pomoże to zrozumieć key:value parę w słownik Pythona a także iteracja .