Có sự khác biệt áp dụng giữa dict.items()và dict.iteritems()?

Từ các tài liệu Python :

dict.items(): Trả về một bản sao của danh sách các cặp (khóa, giá trị) của từ điển.

dict.iteritems(): Trả về một trình vòng lặp qua các cặp (khóa, giá trị) của từ điển.

Nếu tôi chạy mã bên dưới, mỗi cái dường như trả về một tham chiếu đến cùng một đối tượng. Có sự khác biệt tinh tế mà tôi đang thiếu?

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

Đầu ra:

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

Đó là một phần của sự tiến hóa.

Ban đầu, Python đã items()xây dựng một danh sách các bộ dữ liệu thực sự và trả lại nó. Điều đó có khả năng có thể mất rất nhiều bộ nhớ.

Sau đó, các trình tạo được đưa vào ngôn ngữ nói chung và phương thức đó được thực hiện lại như một phương thức trình tạo vòng lặp có tên iteritems(). Bản gốc vẫn còn tương thích ngược.

Một trong những thay đổi của Python 3 là items()bây giờ trả về các trình vòng lặp và một danh sách không bao giờ được xây dựng đầy đủ. Các iteritems()phương pháp cũng đã biến mất, kể từ items()bằng Python 3 công trình như viewitems()trong Python 2.7.

dict.items()trả về một danh sách 2-tuples ( [(key, value), (key, value), ...]), trong khi đó dict.iteritems()là một trình tạo mang lại 2-tuples. Cái trước mất nhiều không gian và thời gian ban đầu, nhưng việc truy cập từng phần tử thì nhanh, trong khi phần thứ hai mất ít không gian và thời gian ban đầu hơn, nhưng tốn thêm một chút thời gian để tạo từng phần tử.

Trong Py2.x

Các lệnh dict.items(), dict.keys()và dict.values()trả về một bản sao của của từ điển danh sách của(k, v) cặp, khóa và giá trị. Điều này có thể mất rất nhiều bộ nhớ nếu danh sách sao chép là rất lớn.

Các lệnh dict.iteritems(), dict.iterkeys()và dict.itervalues()trả về một iterator qua của từ điển (k, v)cặp, khóa và giá trị.

Các lệnh dict.viewitems(), dict.viewkeys()và dict.viewvalues()trả lại đối tượng xem , có thể phản ánh những thay đổi của từ điển. (Tức là nếu bạn delmột mục hoặc thêm một (k,v)cặp trong từ điển, đối tượng xem có thể tự động thay đổi cùng một lúc.)

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

Trong khi ở Py3.x

Trong Py3.x, mọi thứ được sạch sẽ hơn, kể từ khi có chỉ là dict.items(), dict.keys()và dict.values()có sẵn, mà trả lại xem đối tượng cũng giống nhưdict.viewitems() trong Py2.x đã làm.

Nhưng

Như @lvc đã lưu ý, đối tượng xem không giống như iterator , vì vậy nếu bạn muốn trả về một iterator trong Py3.x, bạn có thể sử dụng 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'>

Bạn đã hỏi: 'Có sự khác biệt nào có thể áp dụng giữa dict.items () và dict.iteritems ()'

Điều này có thể giúp (cho Python 2.x):

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

Bạn có thể thấy rằng d.items()trả về một danh sách các bộ khóa, cặp giá trị vàd.iteritems() trả về một trình phân loại từ điển.

Là một danh sách, d.items () là lát cắt có thể:

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

Nhưng sẽ không có một __iter__phương pháp:

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

Là một trình vòng lặp, d.iteritems () không thể cắt lát:

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

Nhưng có __iter__:

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

Vì vậy, các mặt hàng là như nhau - container cung cấp các mặt hàng là khác nhau. Một là danh sách, cái còn lại là một trình vòng lặp (tùy thuộc vào phiên bản Python ...)

Vì vậy, sự khác biệt có thể áp dụng giữa dict.items () và dict.iteritems () giống như sự khác biệt có thể áp dụng giữa danh sách và iterator.

dict.items()trả về danh sách các bộ dữ liệu và dict.iteritems()trả về đối tượng lặp của bộ dữ liệu trong từ điển dưới dạng (key,value). Các bộ dữ liệu là như nhau, nhưng container là khác nhau.

dict.items()về cơ bản sao chép tất cả từ điển vào danh sách. Hãy thử sử dụng mã sau đây để so sánh thời gian thực hiện của dict.items()và dict.iteritems(). Bạn sẽ thấy sự khác biệt.

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

Đầu ra trong máy của tôi:

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

Điều này rõ ràng cho thấy rằng dictionary.iteritems()hiệu quả hơn nhiều.

Nếu bạn có

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

Trong Python 2 , dict.items()sao chép từng bộ dữ liệu và trả về danh sách các bộ dữ liệu trong từ điển tức là [(key1,value1), (key2,value2), ...]. Hàm ý là toàn bộ từ điển được sao chép vào danh sách mới chứa các bộ dữ liệu

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

dict.iteritems()trả về mục từ điển lặp. Giá trị của mục trả về cũng giống như vậy (key1,value1), (key2,value2), ..., nhưng đây không phải là danh sách. Đây chỉ là mục từ điển đối tượng lặp. Điều đó có nghĩa là sử dụng ít bộ nhớ hơn (ít hơn 50%).

• Liệt kê dưới dạng ảnh chụp nhanh có thể thay đổi: d.items() -> list(d.items())
• Các đối tượng lặp: d.iteritems() -> iter(d.items())

Các bộ dữ liệu là như nhau. Bạn so sánh các bộ dữ liệu trong mỗi bộ để bạn nhận được cùng.

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

Trong Python 3 , dict.items()trả về đối tượng iterator. dict.iteritems () đã bị xóa nên không còn vấn đề gì nữa.

dict.iteritemsđã biến mất trong Python3.x Vì vậy, hãy sử dụng iter(dict.items())để có cùng sự sắp xếp bộ nhớ và đầu ra

Nếu bạn muốn một cách lặp lại các cặp mục của một từ điển hoạt động với cả Python 2 và 3, hãy thử một cái gì đó như thế này:

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

Sử dụng nó như thế này:

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

dict.iteritems(): cung cấp cho bạn một trình vòng lặp. Bạn có thể sử dụng iterator trong các mẫu khác bên ngoài vòng lặp.

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.iteritems () trong python 2 tương đương với dict.items () trong python 3.