dict.items() retourne une liste de 2-tuples ( [(key, value), (key, value), ...] ), alors que dict.iteritems() est un générateur qui produit 2-tuples. Le premier prend plus d'espace et de temps au départ, mais l'accès à chaque élément est rapide, tandis que le second prend moins d'espace et de temps au départ, mais un peu plus de temps pour générer chaque élément.

Dans Py2.x

Les commandes dict.items() , dict.keys() et dict.values() retour copie du dictionnaire liste de (k, v) paire de clés et de valeurs. Cela pourrait prendre beaucoup de mémoire si la liste copiée est très grande.

Les commandes dict.iteritems() , dict.iterkeys() et dict.itervalues() retour d'un itérateur sur le dictionnaire (k, v) paire de clés et les valeurs.

Les commandes dict.viewitems() , dict.viewkeys() et dict.viewvalues() retour visualiser les objets , ce qui peut refléter le dictionnaire de changements. (C'est-à-dire: si vous del un article ou ajouter une paire (k,v) dans le dictionnaire, l'objet de la vue peut automatiquement changer en même temps.)

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

, Tandis que dans Py3.x

Dans Py3.x, les choses sont plus propres, car il n'y a que dict.items() , dict.keys() et dict.values() disponibles, qui renvoient les view objects tout comme dict.viewitems() dans Py2.x fait.

mais

comme @lvc l'a noté, voir l'objet n'est pas la même chose que iterator , donc si vous voulez retourner un iterator dans Py3.x, vous pourrait utiliser 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'>

vous avez demandé: "y a-t-il des différences applicables entre les dict?les éléments() et dict.iteritems ()

cela peut aider (pour Python 2.x):

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

vous pouvez voir que d.items() renvoie une liste de tuples de la clé, des paires de valeurs et d.iteritems() renvoie un dictionnaire-itemiterator.

en tant que liste, D. items () is slice-able:

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

mais n'aurait pas de méthode __iter__ :

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

Comme un itérateur, d.iteritems() est pas tranche-mesure:

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

mais a __iter__ :

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

donc les articles eux-mêmes sont les mêmes -- le conteneur livrant les articles sont différents. L'un est une liste, l'autre un itérateur (selon la version de Python)...)

Donc applicables les différences entre les dict.les éléments() et dict.iteritems() sont les mêmes, car les différences entre une liste et un itérateur.

dict.items() retour liste de tuples, et dict.iteritems() retour itérateur objet de tuple dans le dictionnaire comme (key,value) . Les tuples sont les mêmes, mais le conteneur est différent.

dict.items() essentiellement des copies de tous les dictionnaires dans la liste. Essayez d'utiliser le code suivant pour comparer les temps d'exécution des dict.items() et dict.iteritems() . Vous verrez la différence.

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

sortie dans ma machine:

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

Cela montre clairement que dictionary.iteritems() est beaucoup plus efficace.

si vous avez

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

Dans Python 2 , dict.items() exemplaires de chacun des n-uplets et renvoie la liste des n-uplets dans le dictionnaire, c'est à dire [(key1,value1), (key2,value2), ...] . Les conséquences sont que l'ensemble du dictionnaire est copié dans la nouvelle liste contenant les tuples

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

dict.iteritems() renvoie l'item iterator du dictionnaire. La valeur de l'article retourné est aussi le même, c'est à dire (key1,value1), (key2,value2), ... , mais c'est pas une liste. Ce n'est qu'élément de dictionnaire itérateur objet. Cela signifie moins d'utilisation de la mémoire (50% de moins).

• liste des snapshots mutables: d.items() -> list(d.items())
• Itérateur objets: d.iteritems() -> iter(d.items())

Les tuples sont les mêmes. Tu as comparé des tuples pour en arriver là.

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

Dans Python 3 , dict.items() renvoie l'itérateur de l'objet. dict.iteritems() est supprimé, donc il n'y a plus aucun problème.

dict.iteritems() : vous donne un itérateur. Vous pouvez utiliser l'itérateur dans d'autres modèles à l'extérieur de la boucle.

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 est équivalent à dict.les éléments de() en python 3.