Ci sono differenze applicabili tra dict.items()e dict.iteritems()?

Dai documenti di Python :

dict.items(): Restituisce una copia dell'elenco di coppie (chiave, valore) del dizionario.

dict.iteritems(): Restituisce un iteratore sulle coppie (chiave, valore) del dizionario.

Se eseguo il codice qui sotto, ognuno sembra restituire un riferimento allo stesso oggetto. Ci sono delle sottili differenze che mi mancano?

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

Produzione:

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

Fa parte di un'evoluzione.

Inizialmente, Python ha items()creato un vero elenco di tuple e l'ha restituito. Ciò potrebbe potenzialmente richiedere molta memoria aggiuntiva.

Quindi, i generatori sono stati introdotti al linguaggio in generale e quel metodo è stato reimplementato come un metodo generatore di iteratore denominato iteritems(). L'originale rimane per compatibilità con le versioni precedenti.

Una delle modifiche di Python 3 è che items()ora restituiscono iteratori e un elenco non è mai completamente compilato. Anche il iteritems()metodo è andato, poiché items()in Python 3 funziona come viewitems()in Python 2.7.

dict.items()restituisce un elenco di 2 tuple ( [(key, value), (key, value), ...]), mentre dict.iteritems()è un generatore che produce 2 tuple. Il primo richiede più spazio e tempo inizialmente, ma l'accesso a ciascun elemento è veloce, mentre il secondo richiede meno spazio e tempo inizialmente, ma un po 'più tempo nella generazione di ciascun elemento.

In Py2.x

I comandi dict.items(), dict.keys()e dict.values()restituiscono una copia del dizionario della lista di (k, v)coppia, chiavi e valori. Ciò potrebbe richiedere molta memoria se l'elenco copiato è molto grande.

I comandi dict.iteritems(), dict.iterkeys()e dict.itervalues()restituiscono un iteratore sopra del dizionario (k, v)coppia, chiavi e valori.

I comandi dict.viewitems(), dict.viewkeys()e dict.viewvalues()restituiscono gli oggetti vista , in grado di riflettere i cambiamenti del dizionario. (Vale a dire se si inserisce delun elemento o si aggiunge una (k,v)coppia nel dizionario, l'oggetto vista può cambiare automaticamente allo stesso tempo.)

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

Mentre in Py3.x

In Py3.x, le cose sono più puliti, dal momento che ci sono solo dict.items(), dict.keys()e dict.values()disponibile, che restituisce la vista oggetti proprio come dict.viewitems()in fatto Py2.x.

Ma

Proprio come ha notato @lvc, l' oggetto view non è lo stesso dell'iteratore , quindi se vuoi restituire un iteratore in Py3.x, puoi usare 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'>

Hai chiesto: "Esistono differenze applicabili tra dict.items () e dict.iteritems ()"

Questo può aiutare (per Python 2.x):

>>> d={1:'one',2:'two',3:'three'}
>>> type(d.items())
<type 'list'>
>>> type(d.iteritems())
<type 'dictionary-itemiterator'>

Puoi vedere che d.items()restituisce un elenco di tuple della chiave, coppie di valori e d.iteritems()restituisce un dizionario-itemiterator.

Come elenco, d.items () è suddivisibile:

>>> l1=d.items()[0]
>>> l1
(1, 'one')   # an unordered value!

Ma non avrebbe un __iter__metodo:

>>> next(d.items())
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: list object is not an iterator

Come iteratore, d.iteritems () non è suddivisibile :

>>> i1=d.iteritems()[0]
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'dictionary-itemiterator' object is not subscriptable

Ma ha __iter__:

>>> next(d.iteritems())
(1, 'one')               # an unordered value!

Quindi gli articoli stessi sono gli stessi - il contenitore che consegna gli articoli è diverso. Uno è un elenco, l'altro un iteratore (a seconda della versione di Python ...)

Quindi le differenze applicabili tra dict.items () e dict.iteritems () sono le stesse delle differenze applicabili tra un elenco e un iteratore.

dict.items()restituisce un elenco di tuple e dict.iteritems()restituisce l'oggetto iteratore di tupla nel dizionario come (key,value). Le tuple sono uguali, ma il contenitore è diverso.

dict.items()fondamentalmente copia tutto il dizionario nell'elenco. Prova a utilizzare il seguente codice per confrontare i tempi di esecuzione di dict.items()e dict.iteritems(). Vedrai la differenza.

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

Uscita nella mia macchina:

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

Ciò dimostra chiaramente che dictionary.iteritems()è molto più efficiente.

Se hai

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

In Python 2 , dict.items()copia ogni tupla e restituisce l'elenco delle tuple nel dizionario, ad es [(key1,value1), (key2,value2), ...]. Le implicazioni sono che l'intero dizionario viene copiato in un nuovo elenco contenente tuple

dict = {i: i * 2 for i in xrange(10000000)}  
# Slow and memory hungry.
for key, value in dict.items():
    print(key,":",value)

dict.iteritems()restituisce l'iteratore dell'elemento del dizionario. Anche il valore dell'articolo restituito è lo stesso (key1,value1), (key2,value2), ..., ad esempio , ma questo non è un elenco. Questo è solo l'oggetto iteratore di voci di dizionario. Ciò significa meno utilizzo della memoria (50% in meno).

• Elenchi come istantanee mutabili: d.items() -> list(d.items())
• Oggetti Iteratore: d.iteritems() -> iter(d.items())

Le tuple sono uguali. Hai confrontato le tuple in ognuna per ottenere lo stesso.

dict = {i: i * 2 for i in xrange(10000000)}  
# More memory efficient.
for key, value in dict.iteritems():
    print(key,":",value)

In Python 3 , dict.items()restituisce l'oggetto iteratore. dict.iteritems () è stato rimosso, quindi non ci sono più problemi.

dict.iteritemsè andato in Python3.x Quindi usa iter(dict.items())per ottenere lo stesso output e memoria alocation

Se vuoi un modo per iterare le coppie di elementi di un dizionario che funziona con Python 2 e 3, prova qualcosa del genere:

DICT_ITER_ITEMS = (lambda d: d.iteritems()) if hasattr(dict, 'iteritems') else (lambda d: iter(d.items()))

Usalo in questo modo:

for key, value in DICT_ITER_ITEMS(myDict):
    # Do something with 'key' and/or 'value'.

dict.iteritems(): ti dà un iteratore. È possibile utilizzare l'iteratore in altri schemi al di fuori del ciclo.

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