首页 文章

dict.items()和dict.iteritems()有什么区别?

提问于
浏览
592

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

10 回答

  • 726

    这是进化的一部分 .

    最初,Python items() 构建了一个真实的元组列表并返回了它 . 这可能会占用大量额外的内存 .

    然后,生成器被引入到该语言中,并且该方法被重新实现为名为 iteritems() 的迭代器生成器方法 . 原始保留了向后兼容性 .

    Python 3的一个变化是 items() 现在返回迭代器,并且列表永远不会完全构建 . iteritems() 方法也消失了,因为Python 3中的 items() 就像Python 2.7中的 viewitems() 一样 .

  • 58

    dict.items() 返回一个2元组列表( [(key, value), (key, value), ...] ),而 dict.iteritems() 是一个产生2元组的生成器 . 前者最初需要更多的空间和时间,但访问每个元素的速度很快,而第二个元素最初占用的空间和时间较少,但生成每个元素的时间要多一些 .

  • 88

    在Py2.x中

    命令 dict.items()dict.keys()dict.values() 返回字典的 list (k, v) 对,键和值的 copy . 如果复制的列表非常大,这可能会占用大量内存 .

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

    命令 dict.viewitems()dict.viewkeys()dict.viewvalues() 返回view objects,它可以反映字典的更改 . (即,如果您在项目中添加 (k,v) 项目或在项目中添加 (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()dict.values() 可用,它们返回 view objects ,就像Py2.x中的 dict.viewitems() 一样 .

    但是

    正如@lvc所说, view objectiterator 不同,所以如果你想在Py3.x中返回一个 iterator ,你可以使用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'>
    
  • 11

    你问:'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() 返回字典 - itemiterator .

    作为列表,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()是 not slice-able:

    >>> 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()之间的适用差异与列表和迭代器之间的适用差异相同 .

  • -2

    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() 更有效率 .

  • 32

    如果你有

    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(),因此没有更多问题 .

  • 0

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

    如果你想要一种方法来迭代兼容Python 2和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'.
    
  • 4

    dict.iteritems 在Python3.x中消失了所以使用 iter(dict.iitems()) 来获得相同的输出和内存位置

  • 0

    python 2中的dict.iteritems()等效于python 3中的dict.items() .

相关问题