Apakah ada perbedaan yang berlaku antara dict.items()dan dict.iteritems()?

Dari dokumen Python :

dict.items(): Kembalikan salinan daftar pasangan (kunci, nilai) kamus.

dict.iteritems(): Kembalikan iterator melalui pasangan (kunci, nilai) kamus.

Jika saya menjalankan kode di bawah ini, masing-masing tampaknya mengembalikan referensi ke objek yang sama. Apakah ada perbedaan halus yang saya lewatkan?

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

Keluaran:

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

Itu bagian dari evolusi.

Awalnya, Python items()membuat daftar tupel dan mengembalikannya. Itu berpotensi mengambil banyak memori ekstra.

Kemudian, generator diperkenalkan ke bahasa secara umum, dan metode itu diterapkan kembali sebagai metode iterator-generator yang dinamai iteritems(). Dokumen asli tetap untuk kompatibilitas ke belakang.

Salah satu perubahan Python 3 adalah items()sekarang mengembalikan iterator, dan daftar tidak pernah sepenuhnya dibangun. The iteritems()Metode juga hilang, karena items()di Python 3 karya seperti viewitems()di Python 2.7.

dict.items()mengembalikan daftar 2-tupel ( [(key, value), (key, value), ...]), sedangkan dict.iteritems()generator yang menghasilkan 2-tupel. Yang pertama membutuhkan lebih banyak ruang dan waktu pada awalnya, tetapi mengakses setiap elemen dengan cepat, sedangkan yang kedua membutuhkan lebih sedikit ruang dan waktu pada awalnya, tetapi sedikit lebih banyak waktu dalam menghasilkan setiap elemen.

Di Py2.x

Perintah dict.items(), dict.keys()dan dict.values()mengembalikan salinan dari kamus ini daftar dari (k, v)pasangan, kunci dan nilai-nilai. Ini bisa memakan banyak memori jika daftar yang disalin sangat besar.

Perintah dict.iteritems(), dict.iterkeys()dan dict.itervalues()kembalikan iterator pada (k, v)pasangan kamus , kunci dan nilai.

Perintah dict.viewitems(), dict.viewkeys()dan dict.viewvalues()mengembalikan objek tampilan , yang dapat mencerminkan perubahan kamus. (Yaitu jika Anda delitem atau menambahkan (k,v)pasangan dalam kamus, objek tampilan dapat secara otomatis berubah pada saat yang sama.)

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

Sementara di Py3.x

Di Py3.x, segalanya lebih bersih, karena hanya ada dict.items(), dict.keys()dan dict.values()tersedia, yang mengembalikan objek tampilan seperti dict.viewitems()pada Py2.x.

Tapi

Seperti yang dicatat @lvc, objek tampilan tidak sama dengan iterator , jadi jika Anda ingin mengembalikan iterator di Py3.x, Anda bisa menggunakan 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'>

Anda bertanya: 'Apakah ada perbedaan yang berlaku antara dict.items () dan dict.iteritems ()'

Ini dapat membantu (untuk Python 2.x):

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

Anda dapat melihat bahwa d.items()mengembalikan daftar tupel kunci, pasangan nilai dand.iteritems() mengembalikan kamus-itemiterator.

Sebagai daftar, d.items () dapat diiris:

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

Tetapi tidak akan memiliki __iter__metode:

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

Sebagai iterator, d.iteritems () tidak dapat diiris:

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

Tetapi memang memiliki __iter__:

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

Jadi barangnya sendiri sama - wadah yang mengantarkan barang berbeda. Satu adalah daftar, yang lain merupakan iterator (tergantung pada versi Python ...)

Jadi perbedaan yang berlaku antara dict.items () dan dict.iteritems () sama dengan perbedaan yang berlaku antara daftar dan iterator.

dict.items()mengembalikan daftar tupel, dan dict.iteritems()mengembalikan objek itupator tupel dalam kamus sebagai (key,value). Tupelnya sama, tetapi wadahnya berbeda.

dict.items()pada dasarnya menyalin semua kamus ke dalam daftar. Coba gunakan kode berikut untuk membandingkan waktu eksekusi dict.items()dan dict.iteritems(). Anda akan melihat perbedaannya.

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

Output di mesin saya:

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

Ini jelas menunjukkan bahwa dictionary.iteritems()jauh lebih efisien.

Jika Anda memiliki

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

Dalam Python 2 , dict.items()menyalin setiap tupel dan mengembalikan daftar tupel dalam kamus yaitu [(key1,value1), (key2,value2), ...]. Implikasinya adalah bahwa seluruh kamus disalin ke daftar baru yang berisi tupel

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

dict.iteritems()mengembalikan iterator item kamus. Nilai item yang dikembalikan juga sama yaitu (key1,value1), (key2,value2), ..., tetapi ini bukan daftar. Ini hanya objek item iterator kamus. Itu berarti lebih sedikit penggunaan memori (50% lebih sedikit).

• Daftar sebagai snapshot yang bisa diubah: d.items() -> list(d.items())
• Objek Iterator: d.iteritems() -> iter(d.items())

Tupelnya sama. Anda membandingkan tupel di masing-masing sehingga Anda mendapatkan yang sama.

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

Dalam Python 3 , dict.items()mengembalikan objek iterator. dict.iteritems () dihapus sehingga tidak ada masalah lagi.

dict.iteritemshilang di Python3.x Jadi gunakan iter(dict.items())untuk mendapatkan output dan alokasi memori yang sama

Jika Anda ingin cara untuk mengulangi pasangan item kamus yang berfungsi dengan Python 2 dan 3, coba sesuatu seperti ini:

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

Gunakan seperti ini:

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

dict.iteritems(): memberi Anda sebuah iterator. Anda dapat menggunakan iterator dalam pola lain di luar loop.

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 () di python 2 sama dengan dict.items () di python 3.