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

和之间是否存在任何适用的差异

从：

dict.items（）

：返回字典（键、值）对列表的副本

dict.iteritems（）

：在字典的（键、值）对上返回一个迭代器

如果我运行下面的代码，每个代码似乎都返回对同一对象的引用。有没有我遗漏的细微差别

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

---

dict.items（）

返回2元组列表（

[（键，值），（键，值），…]）

），而

dict.iteritems（）

是生成2元组的生成器。前者最初需要更多的空间和时间，但访问每个元素的速度很快，而第二个最初需要更少的空间和时间，但生成每个元素的时间稍长。

这是进化的一部分

最初，Python

items（）

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

然后，生成器被引入到语言中，该方法被重新实现为名为

iteritems（）

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

---

Python3的一个变化是

items（）

现在返回视图，而

列表从来没有完全构建过。
iteritems（）

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

但不会有一个
\uuuuuuuuuuuuuuuuuuuuuuu
方法：

>>> 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（）之间的适用差异与列表和迭代器之间的适用差异相同
 在Py2.x中
命令
dict.items（）
、
dict.keys（）
和
dict.values（）
返回字典的列表的副本，该列表包含
（k，v）
对、键和值。
如果复制的列表非常大，这可能会占用大量内存

命令
dict.iteritems（）
、
dict.iterkeys（）
和
dict.itervalues（）
返回字典的
（k，v）
对、键和值的迭代器

命令
dict.viewitems（）
、
dict.viewkeys（）
和
dict.viewvalues（）
返回，这可以反映字典的更改。
（也就是说，如果在字典中删除一个项目或添加一个
（k，v）
对，视图对象可以同时自动更改。）

如果你有

dict={key1:value1，key2:value2，key3:value3，…}

在Python 2中，
dict.items（）
复制每个元组并返回字典中的元组列表，即
[（key1，value1），（key2，value2），…]
。
这意味着整个字典被复制到包含元组的新列表中

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

dict.iteritems（）
返回字典项迭代器。返回的项的值也相同，即
（键1，值1），（键2，值2），…
，但这不是一个列表。这是唯一的字典项迭代器对象。这意味着更少的内存使用（减少50%）


作为可变快照列出：
d.items（）->list（d.items（））
迭代器对象：
d.iteritems（）->iter（d.items（））

元组是相同的。比较每个元组中的元组，得到相同的结果

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

在Python 3中，dict.items（）返回迭代器对象。dict.iteritems（）已删除，因此不再存在问题。
dict.items（）
返回元组列表，并且
dict.iteritems（）
将字典中元组的迭代器对象返回为
（键，值）
。元组相同，但容器不同

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

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

我的机器中的输出：

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

这清楚地表明
dictionary.iteritems（）
的效率要高得多。
python 2中的dict.iteritems（）相当于python 3中的dict.items（）。
dict.iteritems（）
：为您提供了一个迭代器。您可以在循环之外的其他模式中使用迭代器

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

如果您想要一种迭代同时适用于Python 2和Python 3的字典项对的方法，请尝试以下方法：

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

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

像这样使用它：

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

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

dict.iteritems
在Python3.x中消失了，所以使用
iter（dict.items（））
来获得相同的输出和内存位置
为什么您希望它们有所不同呢？文档中的“复制”并不意味着元素被复制（如果您需要，请使用
copy.deepcopy
）。这意味着它是字典项的副本：如果你做了
items=dct.items（）
，然后通过添加/删除键或
dct[k]=other_v
来修改
dct
，
项将保持不变。Python中的任何内容都不是深度副本，除非有明确的文档记录。@IgnacioVazquez Abrams“更多的空间和时间”：它们在多大的字典中开始起作用。假设我有一个“大”字典
{1:'one'，2:'two'，…}
，我想在Web服务器上迭代并呈现结果。我应该以多大的规模开始考虑选择
.items（）
vs
.iterms（）
对于Python 2.7？@buffer:不太确定。我估计会有15-20项，但我还没有测试过。它们的计算方式基本上是不同的。
item
Time with d.items(): 9.04773592949
Time with d.iteritems(): 2.17707300186

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_ITER_ITEMS = (lambda d: d.iteritems()) if hasattr(dict, 'iteritems') else (lambda d: iter(d.items()))

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