python iterar - Iterando sobre diccionarios usando bucles 'for'




elementos como (10)

key es simplemente una variable.

Para Python2.X :

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

... o mejor,

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

Para Python3.X :

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

Estoy un poco desconcertado por el siguiente código:

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

Lo que no entiendo es la parte key . ¿Cómo reconoce Python que solo necesita leer la clave del diccionario? ¿Es key una palabra especial en Python? ¿O es simplemente una variable?



Para iterar sobre las teclas, es más lento pero es mejor usar my_dict.keys() . Si intentaste hacer algo como esto:

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

crearía un error de tiempo de ejecución porque está cambiando las claves mientras el programa se está ejecutando. Si está absolutamente decidido a reducir el tiempo, use la for key in my_dict forma for key in my_dict , pero se le ha advertido;).


No es que la clave sea una palabra especial, sino que los diccionarios implementan el protocolo iterador. Podría hacer esto en su clase, por ejemplo, vea esta pregunta para saber cómo crear iteradores de clase.

En el caso de los diccionarios, se implementa en el nivel C. Los detalles están disponibles en PEP 234 . En particular, la sección titulada "Diccionario Iteradores":

  • Los diccionarios implementan una ranura tp_iter que devuelve un iterador eficiente que recorre las claves del diccionario. [...] Esto significa que podemos escribir

    for k in dict: ...
    

    que es equivalente a, pero mucho más rápido que

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

    siempre que no se viole la restricción de modificaciones al diccionario (ya sea por el bucle o por otro hilo).

  • Agregue métodos a los diccionarios que devuelven explícitamente diferentes tipos de iteradores:

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

    Esto significa que for x in dict es taquigrafía for x in dict.iterkeys() .


Iterar sobre un dict itera a través de sus claves sin ningún orden en particular, como puede ver aquí:

Edición: (Este ya no es el caso en Python3.6 , pero tenga en cuenta que aún no se garantiza el comportamiento)

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

Para su ejemplo, es una mejor idea usar dict.items() :

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

Esto le da una lista de tuplas. Cuando los recorres de esta manera, cada tupla se desempaqueta en k y v automáticamente:

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

Usar k y v como nombres de variables cuando se repite en un dict es bastante común si el cuerpo del bucle es solo de unas pocas líneas. Para bucles más complicados, puede ser una buena idea usar nombres más descriptivos:

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

Es una buena idea acostumbrarse a usar cadenas de formato:

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

Puedes usar esto:

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

Iterando sobre diccionarios usando bucles 'for'

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

¿Cómo reconoce Python que solo necesita leer la clave del diccionario? ¿Es clave una palabra especial en Python? ¿O es simplemente una variable?

No es solo for bucles. La palabra importante aquí es "iterando".

Un diccionario es un mapeo de claves a valores:

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

Cada vez que iteramos sobre él, iteramos sobre las teclas. La key nombre de la variable solo pretende ser descriptiva, y es bastante adecuada para este propósito.

Esto sucede en una lista de comprensión:

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

Ocurre cuando pasamos el diccionario a la lista (o cualquier otro objeto de tipo de colección):

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

La forma en que Python itera es, en un contexto donde lo necesita, llama al método __iter__ del objeto (en este caso el diccionario) que devuelve un iterador (en este caso, un objeto keyiterator):

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

No deberíamos usar estos métodos especiales nosotros, en su lugar, usar la función incorporada respectiva para llamarlo, iter :

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

Los iteradores tienen un método __next__ , pero lo llamamos con la función incorporada, a 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

Cuando un iterador se agota, provoca StopIteration . Así es como Python sabe salir de un bucle for , una lista de comprensión, una expresión generadora o cualquier otro contexto iterativo. Una vez que un iterador genera StopIteration , siempre lo hará. Si desea repetir una vez más, necesita uno nuevo.

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

Volviendo a los dictados

Hemos visto los dictados iterando en muchos contextos. Lo que hemos visto es que cada vez que repetimos un dictado, obtenemos las claves. De vuelta al ejemplo original:

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

Si cambiamos el nombre de la variable, seguimos obteniendo las claves. Vamos a intentarlo:

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

Si queremos iterar sobre los valores, necesitamos usar el método de valores de valores .values, o para ambos juntos, .items :

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

En el ejemplo dado, sería más eficiente iterar sobre los elementos como este:

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

Pero para propósitos académicos, el ejemplo de la pregunta está bien.


key es solo un nombre de variable.

for key in d:

simplemente pasará sobre las claves en el diccionario, en lugar de las claves y los valores. Para recorrer tanto la clave como el valor, puede utilizar lo siguiente:

Para Python 2.x:

for key, value in d.iteritems():

Para Python 3.x:

for key, value in d.items():

Para probar por ti mismo, cambia la palabra key a poop .

Para Python 3.x, iteritems() ha sido reemplazado por simplemente items() , que devuelve una vista de conjunto respaldada por el dict, como iteritems() pero incluso mejor. Esto también está disponible en 2.7 como viewitems() .

Los items() operación items() funcionarán tanto para 2 como para 3, pero en 2 devolverá una lista de los pares del diccionario (key, value) , que no reflejarán los cambios en el dict que suceden después de la llamada de los items() . Si desea el comportamiento 2.x en 3.x, puede llamar a la list(d.items()) .


Puedes verificar la implementación del dicttype de CPython en GitHub. Esta es la firma del método que implementa el iterador dict:

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

CPython dictobject.c


>>> d = {'key':'value'}
>>> print(d)
{'key': 'value'}
>>> d['mynewkey'] = 'mynewvalue'
>>> print(d)
{'mynewkey': 'mynewvalue', 'key': 'value'}






python python-2.7 dictionary