Question Quelle est la difference entre dict.items () et dict.iteritems ()?


Y a-t-il des différences applicables entre dict.items() et dict.iteritems()?

À partir des documents Python:

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

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

Si je cours le code ci-dessous, chacun semble renvoyer une référence au même objet. Y a-t-il des différences subtiles qui me manquent?

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

542
2018-05-05 02:58


origine


Réponses:


Cela fait partie d'une évolution.

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

Ensuite, les générateurs ont été introduits dans le langage en général, et cette méthode a été réimplémentée comme une méthode d'itérateur-générateur nommée iteritems(). L'original reste pour la rétrocompatibilité.

Un des changements de Python 3 est que items() maintenant renvoyer des itérateurs, et une liste n'est jamais entièrement construite. le iteritems() méthode est également parti, depuis items() dans Python 3 fonctionne comme viewitems() en Python 2.7.


673
2018-05-05 03:26



dict.items() retourne une liste de 2-tuples ([(key, value), (key, value), ...]), tandis 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.


82
2018-05-05 03:00



Dans Py2.x

Les commandes dict.items(), dict.keys() et dict.values() retourner un copie du dictionnaire liste de (k, v) paire, clés et 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() retourner un itérateur sur le dictionnaire (k, v) paire, clés et valeurs.

Les commandes dict.viewitems(), dict.viewkeys() et dict.viewvalues() retourner le voir les objets, qui peut refléter les changements du dictionnaire. (C'est-à-dire si vous del un élément ou ajouter un (k,v) paire dans le dictionnaire, l'objet 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'>

Alors 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() disponible, qui renvoie le voir les objets tout comme dict.viewitems() dans Py2.x fait.

Mais

Tout comme @lvc noté, voir l'objet n'est pas la même chose 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'>

52
2017-12-02 13:33



Vous avez demandé: 'Existe-t-il des différences entre dict.items () 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'>

Tu peux voir ça d.items() retourne une liste de tuples de la clé, des paires de valeurs et d.iteritems() retourne un dictionnaire-itemiterator.

En tant que liste, d.items () est slice-able:

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

Mais 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

En tant qu'itérateur, d.iteritems () est ne pas tranche-capable:

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

Mais a-t-il __iter__:

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

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

Ainsi, les différences applicables entre dict.items () et dict.iteritems () sont les mêmes que les différences applicables entre une liste et un itérateur.


31
2018-05-05 06:29



dict.items()retourner la liste des tuples, et dict.iteritems() retourne l'objet itérateur de tuple dans le dictionnaire as (key,value). Les tuples sont identiques, mais le conteneur est différent.

dict.items() copie fondamentalement tous les dictionnaires dans la liste. Essayez d'utiliser le code suivant pour comparer les temps d'exécution de 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.


11
2017-09-11 02:26



Si tu as

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

Dans Python 2, dict.items() copie chaque tuples et renvoie la liste des tuples dans le dictionnaire, c'est-à-dire [(key1,value1), (key2,value2), ...]. Les implications sont que le dictionnaire entier est copié dans une nouvelle liste contenant des 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'itérateur de l'élément de dictionnaire. La valeur de l'article retourné est également la même. (key1,value1), (key2,value2), ..., mais ce n'est pas une liste. Ceci est uniquement un objet itérateur d'un élément de dictionnaire. Cela signifie moins d'utilisation de la mémoire (50% de moins).

  • Listes en tant qu'instantations mutables: d.items() -> list(d.items()) 
  • Objets Iterator: d.iteritems() -> iter(d.items())

Les tuples sont les mêmes. Vous avez comparé les tuples dans chacun pour que vous obteniez la même chose.

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'objet itérateur. dict.iteritems () est supprimé afin qu'il n'y ait plus de problème.


4
2017-09-11 01:37



dict.iteritems () dans python 2 est équivalent à dict.items () dans python 3.


-1
2018-01-17 14:32