dict.items() возвращает список из 2-кортежей ([(key, value), (key, value), ...]), а dict.iteritems() - это генератор, который дает 2-кортежей. Первый занимает больше места и времени изначально, но доступ к каждому элементу происходит быстро, тогда как второй занимает меньше места и времени изначально, но немного больше времени при создании каждого элемента.

В 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() и dict.values() доступно, что вернет посмотреть объекты как dict.viewitems() в Py2.Икс сделал это.

но

так же, как @ 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'>

вы спросили: "есть ли какие-либо применимые различия между 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() является slice-able:

>>> 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 () является не 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.пункты () и дикт.iteritems () - это то же самое, что и применимые различия между списком и итератором.

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() гораздо эффективнее.

если у вас

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

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

In Python 3,dict.items() возвращает итератор объекта. словарь.iteritems () удаляется, поэтому больше нет проблем.

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

дикт.iteritems () в python 2 эквивалентно dict.элементы() в Python 3.