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


¿Hay alguna diferencia aplicable entre dict.items() y dict.iteritems()?

De los documentos de Python:

dict.items(): Devuelve un dupdo 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

542
2018-05-05 02:58


origen


Respuestas:


Es parte de una evolución.

Originalmente, Python items() construyó una lista real de tuplas y devolvió eso. Eso podría tomar mucha memoria extra.

Luego, los generadores fueron introducidos al lenguaje en general, y ese método se volvió a implementar como un método iterador-generador llamado iteritems(). El original permanece para compatibilidad con versiones anteriores.

Uno de los cambios de Python 3 es que items() ahora devuelve iteradores, y una lista nunca se construye por completo. los iteritems() método también se ha ido, ya que items() en Python 3 funciona como viewitems() en Python 2.7.


673
2018-05-05 03:26



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.


82
2018-05-05 03:00



En Py2.x

Los comandos dict.items(), dict.keys() y dict.values() devolver un dupdo del diccionario lista de (k, v) par, claves y valores. Esto podría llevar mucha memoria si la lista copiada es muy grande.

Los comandos dict.iteritems(), dict.iterkeys() y dict.itervalues() devolver un iterador sobre el diccionario (k, v) par, claves y valores.

Los comandos dict.viewitems(), dict.viewkeys() y dict.viewvalues() devuelve el ver objetos, que puede reflejar los cambios del diccionario. (Es decir, si del un artículo o agregar un (k,v) par en el diccionario, el objeto de vista puede automáticamente cambiar al mismo tiempo)

$ python2.7

>>> d = {'one':1, 'two':2}
>>> type(d.items())
<type 'list'>
>>> type(d.keys())
<type 'list'>
>>> 
>>> 
>>> type(d.iteritems())
<type 'dictionary-itemiterator'>
>>> type(d.iterkeys())
<type 'dictionary-keyiterator'>
>>> 
>>> 
>>> type(d.viewitems())
<type 'dict_items'>
>>> type(d.viewkeys())
<type 'dict_keys'>

Mientras está en Py3.x

En Py3.x, las cosas están más limpias, ya que solo hay dict.items(), dict.keys() y dict.values() disponible, que devuelve el ver objetos Tal como dict.viewitems() en Py2.x lo hizo.

Pero

Tal como señaló @lvc, ver objeto no es lo mismo que iterador, entonces si quieres devolver un iterador en Py3.x, podrías usar iter(dictview) :

$ python3.3

>>> d = {'one':'1', 'two':'2'}
>>> type(d.items())
<class 'dict_items'>
>>>
>>> type(d.keys())
<class 'dict_keys'>
>>>
>>>
>>> ii = iter(d.items())
>>> type(ii)
<class 'dict_itemiterator'>
>>>
>>> ik = iter(d.keys())
>>> type(ik)
<class 'dict_keyiterator'>

52
2017-12-02 13:33



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

Puedes ver eso 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 una __iter__ método:

>>> 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 () es no rebanable-capaz:

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


31
2018-05-05 06:29



dict.items()devolver la lista de tuplas, y dict.iteritems() devolver iterador objeto de tupla en el diccionario como (key,value). Las tuplas son iguales, pero el contenedor es diferente.

dict.items() básicamente copia todo el diccionario en la lista. Intente usar el siguiente código para comparar los tiempos de ejecución de la dict.items() y dict.iteritems(). Verás la diferencia.

import timeit

d = {i:i*2 for i in xrange(10000000)}  
start = timeit.default_timer() #more memory intensive
for key,value in d.items():
    tmp = key + value #do something like print
t1 = timeit.default_timer() - start

start = timeit.default_timer()
for key,value in d.iteritems(): #less memory intensive
    tmp = key + value
t2 = timeit.default_timer() - start

Salida en mi máquina:

Time with d.items(): 9.04773592949
Time with d.iteritems(): 2.17707300186

Esto muestra claramente que dictionary.iteritems() es mucho más eficiente.


11
2017-09-11 02:26



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 de 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 del iterador: 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.


4
2017-09-11 01:37



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


-1
2018-01-17 14:32