Python 2 中 dict.items() 和 dict.iteritems() 有什么区别？
- 2024-12-25 08:51:00
- admin 原创
- 118
问题描述：
dict.items()和之间是否存在适用的区别dict.iteritems()？
来自Python 文档：
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 ' they are the same object'
else: print ' they are different'
print 'd.iteritems():'
for k,v in d.iteritems():
if d[k] is v: print ' they are the same object'
else: print ' they 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
解决方案 1：
这是进化的一部分。
最初，Pythonitems()会构建一个真正的元组列表并返回它。这可能会占用大量额外内存。
然后，将生成器引入到语言中，并将该方法重新实现为名为 的迭代器生成器方法iteritems()。原始方法保留下来以实现向后兼容。
Python 3 的一项变化是 items()现在返回视图，并且list永远不会完全构建。该iteritems()方法也消失了，因为items()在 Python 3 中它的工作方式与viewitems()在 Python 2.7 中一样。
解决方案 2：
dict.items()返回 2 元组的列表 ( [(key, value), (key, value), ...])，而dict.iteritems()是生成 2 元组的生成器。前者最初占用更多空间和时间，但访问每个元素的速度很快，而第二个最初占用较少空间和时间，但生成每个元素的时间稍长。
解决方案 3：
在 Py2.x 中
命令dict.items()和返回字典对、键和值列表的副本dict.keys()。如果复制的列表非常大，这可能会占用大量内存。dict.values()`(k, v)`
命令dict.iteritems()，dict.iterkeys()并dict.itervalues()返回字典对、键和值的迭代器(k, v)。
命令dict.viewitems()、dict.viewkeys()和dict.viewvalues()返回视图对象，这些对象可以反映字典的变化。 （即，如果您在字典中del添加一个项目或一对，则视图对象可以同时自动更改。）(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'>
在 Py3.x 中
在 Py3.x 中，事情变得更加清晰，因为只有dict.items()和可用，它们返回视图对象，dict.keys()就像在Py2.x 中一样。dict.values()`dict.viewitems()`
但
正如@lvc 指出的那样，视图对象与迭代器不同，因此如果您想在 Py3.x 中返回迭代器，则可以使用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'>
解决方案 4：
你问：“dict.items() 和 dict.iteritems() 之间有什么适用的区别吗？”
这可能会有帮助（对于 Python 2.x）：
>>> d={1:'one',2:'two',3:'three'}
>>> type(d.items())
<type 'list'>
>>> type(d.iteritems())
<type 'dictionary-itemiterator'>
您可以看到d.items()返回一个由键、值对组成的元组列表，并d.iteritems()返回一个字典项生成器。
作为列表，d.items() 是可切片的：
>>> 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
作为迭代器，d.iteritems()不可切片：
>>> 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!
因此项目本身是相同的——运送项目的容器不同。一个是列表，另一个是迭代器（取决于 Python 版本...）
因此，dict.items() 和 dict.iteritems() 之间的适用差异与列表和迭代器之间的适用差异相同。
解决方案 5：
dict.items()返回元组列表，并dict.iteritems()返回字典中元组的迭代器对象为(key,value)。元组相同，但容器不同。
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()效率更高。
解决方案 6：
dict.iteritems在 Python3.x 中已经消失，因此使用iter(dict.items())可以获得相同的输出和内存分配
解决方案 7：
如果你有
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()返回字典项迭代器。返回项的值也相同，即(key1,value1), (key2,value2), ...，但这不是列表。这只是字典项迭代器对象。这意味着更少的内存使用量（减少 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() 已被删除，因此不再存在问题。
解决方案 8：
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')
解决方案 9：
python 2 中的 dict.iteritems() 相当于 python 3 中的 dict.items()。
