Quelle est la différence entre dict.items() et dict.iteritems() ?

Question

Y sont applicables différences entre dict.items() et dict.iteritems()?

À partir du Python docs:

dict.items(): Retourner un exemplaire du dictionnaire de la liste des (clé, valeur) paires.

dict.iteritems(): Retourne un itérateur sur le dictionnaire (clé, valeur) paires.

Si j'exécute le code ci-dessous, chacun semble renvoyer une référence à l'objet même. Existe-il des différences subtiles qui me manque?

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

Sortie:

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

Il fait partie d'une évolution.

À l'origine, Python items() construit une véritable liste de tuples et retourné. Que pourrait prendre beaucoup de mémoire supplémentaire.

Ensuite, les générateurs ont été introduits à la langue en général, et que cette méthode a été réimplémentée comme un itérateur-générateur de méthode nommée iteritems(). L'original est conservé pour la compatibilité ascendante.

L'un de Python 3 changements, items() maintenant de retour des itérateurs, et une liste n'est jamais complètement construit. L' iteritems() méthode est également allé, depuis items() fonctionne désormais comme iteritems() en Python 2.

Answer 2

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 de temps et d'espace au début, mais l'accès à chaque élément est rapide, alors que le second prend moins de temps et d'espace au départ, mais un peu plus de temps à générer chaque élément.

Answer 3

Dans Py2.x :

dict.items(), dict.keys() et dict.values() retour une copie du dictionnaire de la liste d' (k, v) paire de clés et de valeurs, qui pourraient prend beaucoup de mémoire si le copié liste est très grande.

dict.iteritems(), dict.iterkeys() et dict.itervalues() retourne un itérateur sur le dictionnaire de l' (k, v) paire de clés et de valeurs

dict.viewitems(), dict.viewkeys() et dict.viewvalues() retour à la vue des objets, ce qui peut refléter le dictionnaire des modifications (par exemple, si vous del d'un élément ou d'ajouter un (k,v) paire dans le dictionnaire, le point de vue de l'objet 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'>

---

---

Alors que dans Py3.x, les choses sont plus propre, car il ya seulement

dict.items(), dict.keys() et dict.values() disponibles, dont le retour à la vue des objets tout comme dict.viewitems() dans Py2.x fait.

Mais tout comme @lvc a noté, à la vue de l'objet n'est pas la même que itérateur, donc si vous voulez retourner un itérateur dans Py3.x, vous pouvez 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'>

Answer 4

Vous avez demandé: "y at-il applicable différences entre les dict.les éléments() et dict.iteritems()'

Cela peut aider:

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

Comme une liste d.les éléments() est la tranche-mesure:

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

Mais il n'aurait pas un __iter__ méthode:

>>> 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() n'est pas de 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 ne disposent d' __iter__:

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

Donc, les éléments eux-mêmes sont même -- le récipient de fournir les éléments sont différents. L'un est une liste, l'autre un itérateur (en fonction de la version de Python...) de Sorte que le "applicable différences" sont les mêmes, car les différences entre une liste et un itérateur.