it-swarm.com.de

Durchlaufen von Wörterbüchern mit 'for'-Schleifen

Ich bin ein bisschen verwirrt über den folgenden Code:

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

Was ich nicht verstehe, ist der Teil key. Woran erkennt Python, dass nur der Schlüssel aus dem Wörterbuch gelesen werden muss? Ist key ein spezielles Wort in Python? Oder ist es einfach eine Variable?

2804
TopChef

key ist nur ein Variablenname.

for key in d:

durchlaufen Sie einfach die Schlüssel im Wörterbuch und nicht die Schlüssel und Werte. Zum Durchlaufen von Schlüssel und Wert können Sie Folgendes verwenden:

Für Python 2.x:

for key, value in d.iteritems():

Für Python 3.x:

for key, value in d.items():

Ändern Sie zum Testen das Wort key in poop.

Für Python 3.x wurde iteritems() durch items() ersetzt, wodurch eine mengenähnliche Ansicht zurückgegeben wird, die durch das Diktat unterstützt wird, wie iteritems(), aber noch besser. Dies ist auch in 2.7 als viewitems() verfügbar.

Die Operation items() funktioniert sowohl für 2 als auch für 3, aber in 2 wird eine Liste der (key, value) -Paare des Wörterbuchs zurückgegeben, die keine Änderungen am Diktat widerspiegeln, die nach dem items() auftreten. Anruf. Wenn Sie das 2.x-Verhalten in 3.x möchten, können Sie list(d.items()) aufrufen.

4946
sberry

Es ist nicht so, dass der Schlüssel ein spezielles Wort ist, sondern dass Wörterbücher das Iterator-Protokoll implementieren. Sie können dies in Ihrer Klasse tun, z. Siehe diese Frage zum Erstellen von Klasseniteratoren.

Bei Wörterbüchern wird es auf C-Ebene implementiert. Die Details finden Sie in PEP 234 . Insbesondere der Abschnitt mit dem Titel "Dictionary Iterators":

  • Wörterbücher implementieren einen tp_iter-Slot, der einen effizienten Iterator zurückgibt, der die Schlüssel des Wörterbuchs durchläuft. [...] Das heißt, wir können schreiben

    for k in dict: ...
    

    das ist gleichbedeutend mit, aber viel schneller als

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

    solange die Einschränkung von Änderungen am Wörterbuch (entweder durch die Schleife oder durch einen anderen Thread) nicht verletzt wird.

  • Fügen Sie Wörterbüchern Methoden hinzu, die explizit verschiedene Arten von Iteratoren zurückgeben:

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

    Dies bedeutet, dass for x in dict die Abkürzung für for x in dict.iterkeys() ist.

In Python 3 werden dict.iterkeys(), dict.itervalues() und dict.iteritems() nicht mehr unterstützt. Verwenden Sie stattdessen dict.keys(), dict.values() und dict.items().

394
ars

Das Durchlaufen eines dict durchläuft seine Schlüssel in keiner bestimmten Reihenfolge, wie Sie hier sehen können:

Edit: (Dies ist nicht länger der Fall in Python3.6, aber beachte, dass es nicht garantiert ​​ist)

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

Für Ihr Beispiel ist es eine bessere Idee, dict.items() zu verwenden:

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

Dies gibt Ihnen eine Liste von Tupeln. Wenn Sie sie wie folgt durchlaufen, wird jedes Tupel automatisch in k und v entpackt:

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

Die Verwendung von k und v als Variablennamen beim Durchlaufen einer dict ist durchaus üblich, wenn der Hauptteil der Schleife nur aus wenigen Zeilen besteht. Für kompliziertere Schleifen kann es sinnvoll sein, aussagekräftigere Namen zu verwenden:

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

Es ist eine gute Idee, sich an die Verwendung von Formatzeichenfolgen zu gewöhnen:

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

key ist einfach eine Variable.

Für Python2.X:

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

... oder besser,

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

Für Python3.X:

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

Wenn Sie Wörterbücher mit der for .. in ..- Syntax durchlaufen, wird immer über die Schlüssel iteriert (auf die Werte kann mit dictionary[key] zugegriffen werden).

Um über Schlüssel-Wert-Paare zu iterieren, verwenden Sie in Python 2 for k,v in s.iteritems() und in Python 3 for k,v in s.items().

51

Dies ist eine sehr verbreitete Loop-Sprache. in ist ein Operator. Wann for key in dict zu verwenden ist und wann es for key in dict.keys() sein muss, erfahren Sie in David Goodgers Idiomatic Python article (archived copy) .

27
chryss

Sie können dies verwenden:

for key,val in d.items():
    print key, 'is the key for ', val
16

Ich habe einen Anwendungsfall, in dem ich das Diktat durchlaufen muss, um das Schlüssel-Wert-Paar zu erhalten, sowie den Index, der angibt, wo ich bin. So mache ich es:

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

Beachten Sie, dass die Klammern um den Schlüssel "value" wichtig sind. Ohne die Klammern erhalten Sie einen ValueError "nicht genügend Werte zum Entpacken".

14
jdhao

was auch immer, heute funktionieren sowohl python 2.6 und 2.7 als auch 3.x in meiner Box gut mit items():

z = {0: 'a', 1: 'b'}
for k, v in z.items(): print(v, k)
12
象嘉道

Durchlaufen von Wörterbüchern mit 'for'-Schleifen

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

Woran erkennt Python, dass nur der Schlüssel aus dem Wörterbuch gelesen werden muss? Ist key ein spezielles Wort in Python? Oder ist es einfach eine Variable?

Es sind nicht nur for Schleifen. Das wichtige Wort hier ist "iterieren".

Ein Wörterbuch ist eine Zuordnung von Schlüsseln zu Werten:

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

Jedes Mal, wenn wir darüber iterieren, iterieren wir über die Schlüssel. Der Variablenname key soll nur beschreibend sein - und ist für diesen Zweck durchaus geeignet.

Dies geschieht in einem Listenverständnis:

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

Es passiert, wenn wir das Dictionary an list (oder ein anderes Objekt vom Typ collection) übergeben:

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

Die Art und Weise, wie Python iteriert, ist in einem Kontext, in dem dies erforderlich ist, der Aufruf der __iter__ -Methode des Objekts (in diesem Fall des Dictionary), die einen Iterator (in diesem Fall einen Keyiterator) zurückgibt Objekt):

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

Wir sollten diese speziellen Methoden nicht selbst verwenden, sondern die jeweilige eingebaute Funktion verwenden, um sie iter aufzurufen:

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

Iteratoren haben eine __next__ -Methode - aber wir nennen sie mit der eingebauten Funktion 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

Wenn ein Iterator erschöpft ist, wird StopIteration ausgelöst. Auf diese Weise kann Python eine for -Schleife, ein Listenverständnis, einen Generatorausdruck oder einen anderen iterativen Kontext verlassen. Sobald ein Iterator StopIteration ausgelöst hat, wird er immer ausgelöst. Wenn Sie erneut iterieren möchten, benötigen Sie einen neuen.

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

Zurück zu Dikten

Wir haben gesehen, wie Dikte in vielen Zusammenhängen durchlaufen wurden. Was wir gesehen haben, ist, dass wir jedes Mal, wenn wir über ein Diktat iterieren, die Schlüssel bekommen. Zurück zum ursprünglichen Beispiel:

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

Wenn wir den Variablennamen ändern, erhalten wir immer noch die Schlüssel. Lass es uns versuchen:

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

Wenn wir die Werte durchlaufen möchten, müssen wir die .values -Methode von Dikten verwenden oder für beide zusammen .items:

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

In dem angegebenen Beispiel wäre es effizienter, die Elemente wie folgt zu durchlaufen:

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

Aber für akademische Zwecke ist das Beispiel der Frage in Ordnung.

12
Aaron Hall

Sie können die Implementierung von CPythons dicttype auf GitHub überprüfen. Dies ist die Signatur einer Methode, die den Diktieriterator implementiert:

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

CPython dictobject.c

7
abc

Um die Tasten zu durchlaufen, ist es langsamer, aber besser, my_dict.keys() zu verwenden. Wenn Sie versucht haben, so etwas zu tun:

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

dies würde einen Laufzeitfehler verursachen, da Sie die Schlüssel ändern, während das Programm ausgeführt wird. Wenn Sie unbedingt Zeit sparen möchten, verwenden Sie for key in my_dict, aber Sie wurden gewarnt;).

2

Der Schlüssel in my_dict entspricht dem Schlüssel in my_dict.keys (). Wenn Sie also Werte von dict erhalten möchten, können Sie zwei Methoden ausprobieren.

Ein:

for value in my_dict.values():
    print(value)

Zwei:

for key in my_dict:
    print(my_dict[key])
1
Amaan Durrani

Druckvorschlag für lange Werte
Wenn Sie lange Zeichenfolgen in den Werten haben, können Sie diese hier schnell in einem (mehr?) Lesbaren Format ausdrucken:
for key, value in my_dictionary.iteritems(): print(key) print("---------") print(value) print("\n")

0
Joseph True