Ekspresi Generator vs. Pemahaman Daftar

Kapan Anda harus menggunakan ekspresi generator dan kapan Anda harus menggunakan daftar pemahaman dalam Python?

# Generator expression
(x*2 for x in range(256))

# List comprehension
[x*2 for x in range(256)]

Jawaban John adalah baik (daftar itu lebih baik bila Anda ingin mengulangi sesuatu berulang kali). Namun, perlu dicatat bahwa Anda harus menggunakan daftar jika Anda ingin menggunakan salah satu metode daftar. Misalnya, kode berikut tidak akan berfungsi:

def gen():
    return (something for something in get_some_stuff())

print gen()[:2]     # generators don't support indexing or slicing
print [5,6] + gen() # generators can't be added to lists

Pada dasarnya, gunakan ekspresi generator jika semua yang Anda lakukan adalah iterasi satu kali. Jika Anda ingin menyimpan dan menggunakan hasil yang dihasilkan, maka Anda mungkin lebih baik dengan pemahaman daftar.

Karena kinerja adalah alasan paling umum untuk memilih satu di atas yang lain, saran saya adalah jangan khawatir tentang itu dan hanya memilih satu; jika Anda menemukan bahwa program Anda berjalan terlalu lambat, maka dan hanya kemudian Anda harus kembali dan khawatir tentang penyetelan kode Anda.

Iterasi atas ekspresi generator atau pemahaman daftar akan melakukan hal yang sama. Namun, pemahaman daftar akan membuat seluruh daftar di memori terlebih dahulu sementara ekspresi generator akan membuat item dengan cepat, sehingga Anda dapat menggunakannya untuk urutan yang sangat besar (dan juga tak terbatas!).

Gunakan pemahaman daftar ketika hasilnya perlu diulang beberapa kali, atau di mana kecepatan sangat penting. Gunakan ekspresi generator di mana kisarannya besar atau tidak terbatas.

Lihat Ekspresi generator dan daftar pemahaman untuk info lebih lanjut.

Poin penting adalah bahwa pemahaman daftar membuat daftar baru. Generator menciptakan objek yang dapat diubah yang akan "memfilter" bahan sumber saat Anda mengkonsumsi bit.

Bayangkan Anda memiliki file log 2TB yang disebut "hugefile.txt", dan Anda menginginkan konten dan panjang untuk semua baris yang dimulai dengan kata "ENTRY".

Jadi Anda mencoba memulai dengan menulis daftar pemahaman:

logfile = open("hugefile.txt","r")
entry_lines = [(line,len(line)) for line in logfile if line.startswith("ENTRY")]

Ini menyeruput seluruh file, memproses setiap baris, dan menyimpan baris yang cocok dalam array Anda. Oleh karena itu array ini dapat memuat konten hingga 2TB. Itu banyak RAM, dan mungkin tidak praktis untuk keperluan Anda.

Jadi alih-alih, kita dapat menggunakan generator untuk menerapkan "filter" ke konten kita. Tidak ada data yang benar-benar dibaca sampai kita mulai mengulangi hasilnya.

logfile = open("hugefile.txt","r")
entry_lines = ((line,len(line)) for line in logfile if line.startswith("ENTRY"))

Bahkan satu baris pun belum dibaca dari file kami. Bahkan, katakanlah kami ingin memfilter hasil kami lebih jauh:

long_entries = ((line,length) for (line,length) in entry_lines if length > 80)

Masih belum ada yang dibaca, tetapi kami telah menentukan sekarang dua generator yang akan bertindak berdasarkan data kami seperti yang kami inginkan.

Mari kita menulis baris yang difilter ke file lain:

outfile = open("filtered.txt","a")
for entry,length in long_entries:
    outfile.write(entry)

Sekarang kita membaca file input. Ketika forloop kami terus meminta jalur tambahan, long_entriesgenerator meminta jalur dari entry_linesgenerator, hanya mengembalikan yang panjangnya lebih dari 80 karakter. Dan pada gilirannya, entry_linesgenerator meminta baris (difilter seperti yang ditunjukkan) dari logfileiterator, yang pada gilirannya membaca file.

Jadi, alih-alih "mendorong" data ke fungsi output Anda dalam bentuk daftar yang terisi penuh, Anda memberikan fungsi output cara untuk "menarik" data hanya saat dibutuhkan. Ini dalam kasus kami jauh lebih efisien, tetapi tidak cukup fleksibel. Generator adalah satu arah, satu lintasan; data dari file log yang telah kita baca segera dibuang, jadi kita tidak bisa kembali ke baris sebelumnya. Di sisi lain, kita tidak perlu khawatir tentang menyimpan data setelah kita selesai dengan itu.

Manfaat dari ekspresi generator adalah ia menggunakan lebih sedikit memori karena tidak membangun seluruh daftar sekaligus. Ekspresi generator paling baik digunakan ketika daftar adalah perantara, seperti menjumlahkan hasil, atau membuat dict dari hasil.

Sebagai contoh:

sum(x*2 for x in xrange(256))

dict( (k, some_func(k)) for k in some_list_of_keys )

Keuntungannya adalah bahwa daftar tersebut tidak sepenuhnya dihasilkan, dan dengan demikian sedikit memori yang digunakan (dan juga harus lebih cepat)

Namun, Anda harus menggunakan pemahaman daftar ketika produk akhir yang diinginkan adalah daftar. Anda tidak akan menyimpan memeory menggunakan ekspresi generator, karena Anda ingin daftar yang dihasilkan. Anda juga mendapatkan manfaat dari dapat menggunakan salah satu fungsi daftar seperti diurutkan atau dibalik.

Sebagai contoh:

reversed( [x*2 for x in xrange(256)] )

Saat membuat generator dari objek yang bisa berubah-ubah (seperti daftar), ketahuilah bahwa generator akan dievaluasi pada keadaan daftar saat menggunakan generator, bukan pada saat pembuatan generator:

>>> mylist = ["a", "b", "c"]
>>> gen = (elem + "1" for elem in mylist)
>>> mylist.clear()
>>> for x in gen: print (x)
# nothing

Jika ada kemungkinan daftar Anda diubah (atau objek yang bisa berubah di dalam daftar itu) tetapi Anda memerlukan status saat membuat generator, Anda harus menggunakan pemahaman daftar.

Kadang-kadang Anda dapat pergi dengan fungsi tee dari itertools , ia mengembalikan beberapa iterator untuk generator yang sama yang dapat digunakan secara mandiri.

Saya menggunakan modul Hadoop Mincemeat . Saya pikir ini adalah contoh yang bagus untuk mencatat:

import mincemeat

def mapfn(k,v):
    for w in v:
        yield 'sum',w
        #yield 'count',1


def reducefn(k,v): 
    r1=sum(v)
    r2=len(v)
    print r2
    m=r1/r2
    std=0
    for i in range(r2):
       std+=pow(abs(v[i]-m),2)  
    res=pow((std/r2),0.5)
    return r1,r2,res

Di sini generator mengeluarkan angka dari file teks (sebesar 15GB) dan menerapkan matematika sederhana pada angka-angka tersebut menggunakan pengurangan peta Hadoop. Jika saya tidak menggunakan fungsi hasil, tetapi sebagai daftar pemahaman, itu akan memakan waktu lebih lama menghitung jumlah dan rata-rata (belum lagi kompleksitas ruang).

Hadoop adalah contoh yang bagus untuk menggunakan semua keunggulan Generator.