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




5 Answers

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.

'iteritems' object

¿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



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



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




Related

python dictionary