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 acceder a cada elemento es rápido, mientras que el segundo toma menos espacio y tiempo inicialmente, pero un poco más de tiempo en la generación de cada elemento.

En Py2.x

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

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

Los comandos dict.viewitems(), dict.viewkeys() y dict.viewvalues() devuelve el ver objetos, que puede reflejar el diccionario cambio. (Es decir, si del un elemento o agrega un par (k,v) en el diccionario, el objeto view 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() disponible, que devuelven los ver objetos al igual que dict.viewitems() en Py2.x lo hizo.

Pero

Al igual que @lvc señaló, ver objeto no es lo mismo que iterador , por lo que si desea devuelve 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'>

Usted preguntó: '¿Hay alguna diferencia aplicable 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 itemiterator de diccionario.

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

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

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

Así que los artículos en sí son los mismos the el contenedor que entrega los artículos es diferente. Uno es una lista, el otro un iterador (dependiendo de la versión de Python...)

Así que las diferencias aplicables entre dict.items () y dict.iteritems() son las mismas diferencias aplicables entre una lista y un iterador.

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 todo el diccionario 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.

Si tiene

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

En Python 2, dict.items() copia cada tuplas y devuelve la lista de tuplas en el diccionario, es decir, [(key1,value1), (key2,value2), ...]. Las implicaciones son que todo el diccionario se copia a 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 de elementos del diccionario. El valor del elemento 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 iteradores: d.iteritems() -> iter(d.items())

Las tuplas son las mismas. Comparaste tuplas en cada una 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.

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() en python 2 es equivalente a dict.items() en python 3.