Was ist der Unterschied zwischen dict.items() und dict.iteritems() in Python2?

Question

Gibt es relevante Unterschiede zwischen dict.items() y dict.iteritems() ?

De la Python-Dokumente :

dict.items() : Rückgabe a kopieren. der Liste der Paare (Schlüssel, Wert) des Wörterbuchs.

dict.iteritems() : Rückgabe eines Iterator über die Paare des Wörterbuchs (Schlüssel, Wert).

Wenn ich den folgenden Code ausführe, scheint jeder einen Verweis auf dasselbe Objekt zurückzugeben. Gibt es irgendwelche feinen Unterschiede, die ich übersehe?

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

Ausgabe:

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

Answer 1

Es ist Teil einer Evolution.

Ursprünglich war Python items() eine echte Liste von Tupeln erstellt und diese zurückgegeben. Das könnte möglicherweise eine Menge zusätzlichen Speicherplatz beanspruchen.

Dann wurden Generatoren in die Sprache im Allgemeinen eingeführt, und diese Methode wurde als Iterator-Generator-Methode namens iteritems() . Das Original bleibt aus Gründen der Abwärtskompatibilität erhalten.

Eine der Änderungen in Python 3 ist, dass items() geben nun Ansichten zurück, und eine list wird nie vollständig aufgebaut. Die iteritems() Methode ist ebenfalls verschwunden, da items() in Python 3 funktioniert wie viewitems() in Python 2.7.

Answer 2

dict.items() gibt eine Liste von 2-Tupeln ( [(key, value), (key, value), ...] ), während dict.iteritems() ist ein Generator, der 2-Tupel ergibt. Der erste benötigt anfangs mehr Platz und Zeit, aber der Zugriff auf jedes Element ist schnell, während der zweite anfangs weniger Platz und Zeit benötigt, aber etwas mehr Zeit für die Erzeugung jedes Elements.

Answer 3

In Py2.x

Die Befehle dict.items() , dict.keys() y dict.values() ein zurückgeben kopieren. des Wörterbuchs Liste de (k, v) Paar, Schlüssel und Werte. Dies kann viel Speicherplatz beanspruchen, wenn die kopierte Liste sehr groß ist.

Die Befehle dict.iteritems() , dict.iterkeys() y dict.itervalues() ein zurückgeben Iterator über die Wörterbucheinträge (k, v) Paar, Schlüssel und Werte.

Die Befehle dict.viewitems() , dict.viewkeys() y dict.viewvalues() Rückgabe der Objekte anzeigen die die Änderungen des Wörterbuchs widerspiegeln können. (D.h. wenn Sie del einen Artikel oder ein (k,v) Paar im Wörterbuch, kann das View-Objekt automatisch gleichzeitig ändern).

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

---

Während in Py3.x

In Py3.x sind die Dinge sauberer, da es nur noch dict.items() , dict.keys() y dict.values() verfügbar, die die Objekte anzeigen ebenso wie dict.viewitems() in Py2.x getan hat.

Aber

Genau wie @lvc bemerkt hat, Objekt anzeigen ist nicht dasselbe wie Iterator Wenn Sie also eine Iterator in Py3.x könnten Sie verwenden 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'>

Answer 4

Sie fragten: "Gibt es irgendwelche anwendbaren Unterschiede zwischen dict.items() und dict.iteritems()?

Dies kann helfen (für Python 2.x):

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

Sie können sehen, dass d.items() gibt eine Liste von Tupeln der Schlüssel-Werte-Paare und d.iteritems() gibt einen Wörterbuch-Itemiterator zurück.

Als Liste ist d.items() aufteilbar:

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

Hätte aber nicht eine __iter__ Methode:

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

Als Iterator ist d.iteritems() pas schneidbar:

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

Hat aber auch __iter__ :

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

Die Gegenstände selbst sind also dieselben - der Behälter, in dem die Gegenstände geliefert werden, ist unterschiedlich. Der eine ist eine Liste, der andere ein Iterator (abhängig von der Python-Version...)

Die Unterschiede zwischen dict.items() und dict.iteritems() sind also die gleichen wie die Unterschiede zwischen einer Liste und einem Iterator.

Answer 5

dict.items() gibt eine Liste von Tupeln zurück, und dict.iteritems() Rückgabe des Iterator-Objekts des Tupels im Wörterbuch als (key,value) . Die Tupel sind dieselben, aber der Container ist anders.

dict.items() kopiert grundsätzlich alle Wörterbücher in die Liste. Versuchen Sie, mit dem folgenden Code die Ausführungszeiten der dict.items() y dict.iteritems() . Sie werden den Unterschied sehen.

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

Ausgabe auf meiner Maschine:

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

Dies zeigt deutlich, dass dictionary.iteritems() ist viel effizienter.