Gibt es anwendbare Unterschiede zwischen dict.items()und dict.iteritems()?

Aus den Python-Dokumenten :

dict.items(): Gibt eine Kopie der Wörterbuchliste der (Schlüssel-, Wert-) Paare zurück.

dict.iteritems(): Gibt einen Iterator über die Paare des Wörterbuchs (Schlüssel, Wert) zurück.

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

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

Es ist Teil einer Evolution.

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

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

Eine der Änderungen von Python 3 besteht darin, dass items()jetzt Iteratoren zurückgegeben werden und eine Liste nie vollständig erstellt wird. Die iteritems()Methode ist auch weg, da items()in Python 3 wie viewitems()in Python 2.7 funktioniert .

dict.items()Gibt eine Liste von 2-Tupeln ( [(key, value), (key, value), ...]) zurück, während dict.iteritems()ein Generator 2-Tupel liefert. Ersteres benötigt anfangs mehr Platz und Zeit, aber der Zugriff auf jedes Element ist schnell, während das zweite anfangs weniger Platz und Zeit benötigt, aber etwas mehr Zeit für die Generierung jedes Elements.

In Py2.x.

Die Befehle dict.items(), dict.keys()und dict.values()geben eine Kopie der Wörterbuchliste von (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()und dict.itervalues()geben ein Iterator über das (k, v)Wörterbuchpaar, Schlüssel und Werte.

Die Befehle dict.viewitems(), dict.viewkeys()und dict.viewvalues()geben die Ansicht Objekte , die das Wörterbuch der Änderungen reflektieren kann. (Wenn Sie also delein Element oder ein (k,v)Paar zum Wörterbuch hinzufügen , kann sich das Ansichtsobjekt gleichzeitig automatisch ä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 sauber, da es nur gibt dict.items(), dict.keys()und zur dict.values()Verfügung, die die Rückansicht Objekte als nur dict.viewitems()in Py2.x tat.

Aber

Wie @lvc bemerkt hat, ist das Ansichtsobjekt nicht dasselbe wie der Iterator . Wenn Sie also einen Iterator in Py3.x zurückgeben möchten, können Sie Folgendes 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'>

Sie haben gefragt: "Gibt es anwendbare 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()eine Liste von Tupeln der Schlüssel- und Wertepaare und d.iteritems()ein Wörterbuch-Elementiterator zurückgegeben werden.

Als Liste ist d.items () Slice-fähig:

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

Hätte aber keine __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 kann d.iteritems () nicht geschnitten werden :

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

Hat aber __iter__:

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

Die Artikel selbst sind also gleich - der Container, der die Artikel liefert, ist unterschiedlich. Eine ist eine Liste, die andere ein Iterator (abhängig von der Python-Version ...)

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

dict.items()Liste der Tupel zurückgeben und dict.iteritems()Iteratorobjekt des Tupels im Wörterbuch als zurückgeben (key,value). Die Tupel sind gleich, aber der Container ist unterschiedlich.

dict.items()kopiert grundsätzlich alle Wörterbücher in die Liste. Versuchen Sie, den folgenden Code zu verwenden, um die Ausführungszeiten von dict.items()und zu vergleichen 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 in meiner Maschine:

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

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

Wenn Sie haben

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

In Python 2 , dict.items()Kopien jedes Tupel und gibt die Liste von Tupeln im Wörterbuch dh [(key1,value1), (key2,value2), ...]. Implikationen sind, dass das gesamte Wörterbuch in eine neue Liste mit Tupeln kopiert wird

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

dict.iteritems()Gibt den Iterator für Wörterbuchelemente zurück. Der Wert des zurückgegebenen Elements ist ebenfalls derselbe, dh (key1,value1), (key2,value2), ...dies ist keine Liste. Dies ist nur ein Iteratorobjekt für Wörterbuchelemente. Das bedeutet weniger Speicherbedarf (50% weniger).

• Listen als veränderbare Schnappschüsse: d.items() -> list(d.items())
• Iteratorobjekte: d.iteritems() -> iter(d.items())

Die Tupel sind die gleichen. Sie haben jeweils Tupel verglichen, damit Sie gleich sind.

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()iterator kehrt Objekt. dict.iteritems () wird entfernt, sodass kein Problem mehr auftritt.

dict.iteritemsist in Python3.x verschwunden. Verwenden Sie also iter(dict.items()), um die gleiche Ausgabe- und Speicherzuordnung zu erhalten

Wenn Sie die Elementpaare eines Wörterbuchs iterieren möchten, das sowohl mit Python 2 als auch mit Python 3 funktioniert, versuchen Sie Folgendes:

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

Verwenden Sie es so:

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

dict.iteritems(): gibt Ihnen einen Iterator. Sie können den Iterator in anderen Mustern außerhalb der Schleife verwenden.

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 entspricht dict.items () in Python 3.