Python2中dict.items（）和dict.iteritems（）有什么区别？

Question

dict.items()和dict.items()之间是否有适用的区别？

从dict.iteritems()：

dict.iteritems()：返回字典的（键，值）对列表的副本。

Python docs：在字典的（键，值）对上返回一个iterator。

如果我运行下面的代码，每个函数似乎都返回对同一对象的引用。我缺少任何细微的差异吗？

dict.items()

输出：

dict.iteritems()

Answer 1

这是演变的一部分。

最初，Python

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

构建了一个真正的元组列表，并将其返回。这可能会占用大量额外的内存。

然后，一般将生成器引入该语言，并且将该方法重新实现为名为

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

的迭代器-生成器方法。保留原始版本是为了向后兼容。

Python 3的一项更改是items()现在返回了迭代器，并且列表从未完全构建。 iteritems()方法也消失了，因为Python 3中的items()与Python 2.7中的iteritems()相似。

Answer 2

Python 2中的dict.iteritems（）与Python 3中的dict.items（）等效。

Answer 3

items()返回2元组的列表（viewitems()），而dict.items()是产生2元组的生成器。前者最初占用更多空间和时间，但是访问每个元素的速度很快，而前者最初占用较少的空间和时间，但是在生成每个元素时花费的时间要多一些。

Answer 4

在Py2.x中

[(key, value), (key, value), ...]，dict.iteritems()和dict.items()命令返回字典的dict.keys()对，键和值的列表的副本。如果复制的列表很大，这可能会占用大量内存。

dict.values()，(k, v)和dict.iteritems()命令在字典的dict.iterkeys()对，键和值上返回iterator。

dict.itervalues()，(k, v)和dict.viewitems()命令返回dict.viewkeys()，它可以反映字典的变化。（即，如果您在字典中dict.viewvalues()一个项目或添加一个view objects对，则视图对象可以自动同时更改。）

del

---

在Py3.x中时

在Py3.x中，情况更干净，因为只有(k,v)，

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

和dict.items()可用，它们返回view objects就像在Py2.x中的dict.keys()一样。

但是

就像@lvc指出的那样，视图对象与迭代器不同，因此，如果要在Py3.x中返回迭代器，则可以使用dict.values()：

dict.viewitems()

Answer 5

您问：'dict.items（）和dict.iteritems（）之间是否有适用的区别？

这可能有帮助（对于Python 2.x）：

iter(dictview)

[您可以看到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'>

返回一个字典-迭代器。

作为列表，d.items（）是可切片的：

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

但是没有d.items()方法：

d.iteritems()

作为迭代器，d.iteritems（）是not可切片的：

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

但是确实有__iter__：

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

所以物品本身是相同的-运送物品的容器是不同的。一个是列表，另一个是迭代器（取决于Python版本...）

因此dict.items（）和dict.iteritems（）之间的适用差异与列表和迭代器之间的适用差异相同。

Answer 6

[

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

]返回元组列表，[__iter__返回字典中元组的迭代器对象为

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

。元组相同，但容器不同。

dict.items()基本上将所有字典复制到列表中。尝试使用以下代码比较dict.iteritems()和(key,value)的执行时间。您会看到区别。

dict.items()

我的机器上的输出：

dict.items()

这清楚表明dict.iteritems()效率更高。

Answer 7

如果有

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

在Python 2]中，

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

复制每个元组并返回字典中的元组列表，即dictionary.iteritems()。这意味着整个字典将被复制到包含元组的新列表中。

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

dict.items()返回字典项迭代器。返回的项目值也相同，即[(key1,value1), (key2,value2), ...]，但这不是列表。这只是字典项迭代器对象。这意味着更少的内存使用量（减少了50％）。

• 作为可变快照列表：

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

• 迭代器对象：dict.iteritems()

元组相同。您将每个元组进行了比较，所以您得到的相同。

(key1,value1), (key2,value2), ...
在Python 3]中，d.items() -> list(d.items())返回迭代器对象。 dict.iteritems（）已删除，因此不再有问题。

d.iteritems() -> iter(d.items())在Python3.x中不存在，因此使用

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

获得相同的输出和内存分配

dict.items()：给您一个迭代器。您可以在循环外的其他模式中使用迭代器。

dict.iteritems

[如果您希望有一种方法可以迭代同时适用于Python 2和3的字典的项目对，请尝试如下操作：

iter(dict.iitems())

像这样使用它：

dict.iteritems()

Python 2中的dict.iteritems（）与Python 3中的dict.items（）等效。

Answer 8

d.iteritems() -> iter(d.items())在Python3.x中不存在，因此使用

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

获得相同的输出和内存分配

Answer 9

dict.items()：给您一个迭代器。您可以在循环外的其他模式中使用迭代器。

Answer 10

[如果您希望有一种方法可以迭代同时适用于Python 2和3的字典的项目对，请尝试如下操作：

iter(dict.iitems())

像这样使用它：