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

items() python (10)

En Py2.x

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

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

Los comandos dict.viewitems() , dict.viewkeys() y dict.viewvalues() devuelven los objetos de vista , que pueden reflejar los cambios del diccionario. (Es decir, si elimina un elemento o agrega un par (k,v) en el diccionario, el objeto de la vista puede cambiar automáticamente 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 que en Py3.x

En Py3.x, las cosas están más limpias, ya que solo hay dict.items() , dict.keys() y dict.values() disponibles, que devuelven los objetos de vista tal como dict.viewitems() en Py2.x .

Pero

Al igual que @lvc señaló, ver objeto no es lo mismo que iterador , así que si desea devolver un iterador en Py3.x, puede 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''>

¿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

Es parte de una evolución.

Originalmente, los items() Python items() crearon una lista real de tuplas y la devolvieron. Eso podría potencialmente llevar mucha memoria extra.

Luego, los generadores fueron introducidos al lenguaje en general, y ese método se reimplementó como un método de iterador-generador llamado iteritems() . El original se mantiene por compatibilidad con versiones anteriores.

Uno de los cambios de Python 3 es que los items() ahora devuelven iteradores, y una lista nunca se construye completamente. El método iteritems() también desapareció, ya que los items() en Python 3 funcionan como viewitems() en Python 2.7.

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

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.

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.

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

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

dict.items() básicamente copia todos los diccionarios en la lista. Intente usar el siguiente código para comparar los tiempos de ejecución de 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.

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.

dict.iteritems() : te da un iterador. Puede usar el iterador en otros patrones fuera del bucle.

student = {"name": "Daniel", "student_id": 2222} for key,value in student.items(): print(key,value) (''student_id'', 2222) (''name'', ''Daniel'') for key,value in student.iteritems(): print(key,value) (''student_id'', 2222) (''name'', ''Daniel'') studentIterator = student.iteritems() print(studentIterator.next()) (''student_id'', 2222) print(studentIterator.next()) (''name'', ''Daniel'')

dict.iteritems se ha ido en Python3.x. Entonces use iter(dict.iitems()) para obtener la misma asignación de memoria y salida