python - ¿Cuál es la diferencia entre dict.items () y dict.iteritems ()?



5 Answers

dict.items() devuelve una lista de 2-tuplas ( [(key, value), (key, value), ...] ), mientras que dict.iteritems() es un generador que produce 2-tuplas. El primero toma más espacio y tiempo inicialmente, pero el acceso a cada elemento es rápido, mientras que el segundo requiere menos espacio y tiempo inicialmente, pero requiere un poco más de tiempo para generar cada elemento.

python dictionary

¿Hay diferencias aplicables entre dict.items() y dict.iteritems() ?

De los documentos de Python:

dict.items() : devuelve una copia de la lista del diccionario de pares (clave, valor).

dict.iteritems() : devuelve un iterador sobre los pares del diccionario (clave, valor).

Si ejecuto el siguiente código, cada uno parece devolver una referencia al mismo objeto. ¿Hay diferencias sutiles que me faltan?

#!/usr/bin/python

d={1:'one',2:'two',3:'three'}
print 'd.items():'
for k,v in d.items():
   if d[k] is v: print '\tthey are the same object' 
   else: print '\tthey are different'

print 'd.iteritems():'   
for k,v in d.iteritems():
   if d[k] is v: print '\tthey are the same object' 
   else: print '\tthey are different'   

Salida:

d.items():
    they are the same object
    they are the same object
    they are the same object
d.iteritems():
    they are the same object
    they are the same object
    they are the same object



Usted preguntó: '¿Existen diferencias aplicables entre dict.items () y dict.iteritems ()'

Esto puede ayudar (para Python 2.x):

>>> d={1:'one',2:'two',3:'three'}
>>> type(d.items())
<type 'list'>
>>> type(d.iteritems())
<type 'dictionary-itemiterator'>

Puede ver que d.items() devuelve una lista de tuplas de la clave, pares de valores y d.iteritems() devuelve un diccionario-itemiterator.

Como lista, d.items () es capaz de dividir:

>>> l1=d.items()[0]
>>> l1
(1, 'one')   # an unordered value!

Pero no tendría un método __iter__ :

>>> next(d.items())
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: list object is not an iterator

Como iterador, d.iteritems () no es capaz de dividir:

>>> i1=d.iteritems()[0]
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'dictionary-itemiterator' object is not subscriptable

Pero tiene __iter__ :

>>> next(d.iteritems())
(1, 'one')               # an unordered value!

Por lo tanto, los elementos son los mismos: el contenedor que entrega los elementos es diferente. Uno es una lista, el otro es un iterador (según la versión de Python ...)

Por lo tanto, las diferencias aplicables entre dict.items () y dict.iteritems () son las mismas que las diferencias aplicables entre una lista y un iterador.




Si usted tiene

dict = {key1:value1, key2:value2, key3:value3,...}

En Python 2 , dict.items() copia cada tupla y devuelve la lista de tuplas en el diccionario, es decir [(key1,value1), (key2,value2), ...] . Las implicaciones son que todo el diccionario se copia en una nueva lista que contiene tuplas

dict = {i: i * 2 for i in xrange(10000000)}  
# Slow and memory hungry.
for key, value in dict.items():
    print(key,":",value)

dict.iteritems() devuelve el iterador del elemento del diccionario. El valor del artículo devuelto también es el mismo, es decir (key1,value1), (key2,value2), ... , pero esto no es una lista. Este es solo el objeto iterador del elemento del diccionario. Eso significa menos uso de memoria (50% menos).

  • Listas como instantáneas mutables: d.items() -> list(d.items())
  • Objetos de iterador: d.iteritems() -> iter(d.items())

Las tuplas son las mismas. Comparaste tuplas en cada una para que obtengas lo mismo.

dict = {i: i * 2 for i in xrange(10000000)}  
# More memory efficient.
for key, value in dict.iteritems():
    print(key,":",value)

En Python 3 , dict.items() devuelve el objeto iterador. dict.iteritems () se elimina para que no haya más problemas.




Si desea una forma de iterar los pares de elementos de un diccionario que funciona con Python 2 y 3, intente algo como esto:

DICT_ITER_ITEMS = (lambda d: d.iteritems()) if hasattr(dict, 'iteritems') else (lambda d: iter(d.items()))

Úsalo así:

for key, value in DICT_ITER_ITEMS(myDict):
    # Do something with 'key' and/or 'value'.



dict.iteritems () en python 2 es equivalente a dict.items () en python 3.




Related