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



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 requiere 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 un poco más de tiempo en la generación de cada elemento.

Question

¿Hay alguna diferencia aplicable 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 código a continuación, cada uno parece devolver una referencia al mismo objeto. ¿Hay alguna diferencia sutil que me falta?

#!/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



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 esta no es una lista. Esto es solo un objeto iterador de elemento de diccionario. Eso significa menos uso de memoria (50% menos).

  • Lista como instantáneas mutables: d.items() -> list(d.items())
  • Objetos iteradores: d.iteritems() -> iter(d.items())

Las tuplas son iguales. Usted comparó tuplas en cada una de ellas para obtener 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.




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 iterador.

Como una lista, d.items () es segmentable:

>>> 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 un iterador, d.iteritems () no es escalable:

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

Entonces, los artículos en sí mismos son los mismos: el contenedor que entrega los artículos es diferente. Una es una lista, la otra un iterador (dependiendo de 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.




Links