daftar pemahaman vs lambda + filter

Saya kebetulan menemukan diri saya memiliki kebutuhan penyaringan dasar: Saya punya daftar dan saya harus menyaringnya dengan atribut item.

Kode saya terlihat seperti ini:

my_list = [x for x in my_list if x.attribute == value]

Tapi kemudian saya berpikir, bukankah lebih baik menulis seperti ini?

my_list = filter(lambda x: x.attribute == value, my_list)

Ini lebih mudah dibaca, dan jika diperlukan untuk kinerja lambda dapat diambil untuk mendapatkan sesuatu.

Pertanyaannya adalah: apakah ada peringatan dalam menggunakan cara kedua? Adakah perbedaan kinerja? Apakah saya kehilangan Pythonic Way ™ sepenuhnya dan harus melakukannya dengan cara lain (seperti menggunakan itemgetter bukan lambda)?

Sungguh aneh betapa banyak keindahan bervariasi untuk orang yang berbeda. Saya menemukan pemahaman daftar jauh lebih jelas daripada filter+ lambda, tetapi gunakan mana yang Anda temukan lebih mudah.

Ada dua hal yang dapat memperlambat penggunaan Anda filter.

Yang pertama adalah overhead panggilan fungsi: segera setelah Anda menggunakan fungsi Python (apakah dibuat oleh defatau lambda), kemungkinan filter akan lebih lambat daripada pemahaman daftar. Ini hampir pasti tidak cukup untuk masalah, dan Anda tidak harus berpikir banyak tentang kinerja sampai Anda menghitung waktu kode Anda dan menemukan itu menjadi hambatan, tetapi perbedaannya ada di sana.

Overhead lain yang mungkin berlaku adalah bahwa lambda dipaksa untuk mengakses variabel scoped ( value). Itu lebih lambat daripada mengakses variabel lokal dan dalam Python 2.x daftar pemahaman hanya mengakses variabel lokal. Jika Anda menggunakan Python 3.x pemahaman daftar berjalan dalam fungsi terpisah sehingga juga akan mengakses valuemelalui penutupan dan perbedaan ini tidak akan berlaku.

Pilihan lain untuk dipertimbangkan adalah menggunakan generator alih-alih pemahaman daftar:

def filterbyvalue(seq, value):
   for el in seq:
       if el.attribute==value: yield el

Kemudian dalam kode utama Anda (yang mana keterbacaan sangat penting) Anda telah mengganti pemahaman daftar dan filter dengan nama fungsi yang diharapkan bermakna.

Ini adalah masalah yang agak religius dalam Python. Meskipun Guido mempertimbangkan untuk menghapus map, filterdan reducedari Python 3 , ada cukup serangan balik yang pada akhirnya hanya reducedipindahkan dari built-in ke functools.reduce .

Secara pribadi saya menemukan daftar pemahaman lebih mudah dibaca. Lebih eksplisit apa yang terjadi dari ekspresi [i for i in list if i.attribute == value]karena semua perilaku di permukaan bukan di dalam fungsi filter.

Saya tidak akan terlalu khawatir tentang perbedaan kinerja antara kedua pendekatan karena marjinal. Saya benar-benar hanya akan mengoptimalkan ini jika terbukti menjadi hambatan dalam aplikasi Anda yang tidak mungkin.

Juga karena BDFL ingin filterpergi dari bahasa maka pasti itu secara otomatis membuat daftar pemahaman lebih Pythonic ;-)

Karena perbedaan kecepatan apa pun pasti sangat kecil, apakah menggunakan filter atau daftar pemahaman menjadi masalah selera. Secara umum saya cenderung menggunakan pemahaman (yang tampaknya setuju dengan sebagian besar jawaban lain di sini), tetapi ada satu kasus di mana saya lebih suka filter.

Kasus penggunaan yang sangat sering adalah menarik keluar nilai dari beberapa subjek X yang dapat diubah ke predikat P (x):

[x for x in X if P(x)]

tetapi terkadang Anda ingin menerapkan beberapa fungsi ke nilai terlebih dahulu:

[f(x) for x in X if P(f(x))]

Sebagai contoh spesifik, pertimbangkan

primes_cubed = [x*x*x for x in range(1000) if prime(x)]

Saya pikir ini terlihat sedikit lebih baik daripada menggunakan filter. Tapi sekarang pertimbangkan

prime_cubes = [x*x*x for x in range(1000) if prime(x*x*x)]

Dalam hal ini kami ingin filtermenentang nilai pasca-perhitungan. Selain masalah menghitung kubus dua kali (bayangkan perhitungan yang lebih mahal), ada masalah menulis ekspresi dua kali, melanggar estetika KERING . Dalam hal ini saya akan cenderung menggunakan

prime_cubes = filter(prime, [x*x*x for x in range(1000)])

Meskipun filtermungkin merupakan "jalan tercepat", "jalan Pythonic" tidak akan peduli tentang hal-hal seperti itu kecuali kinerja sangat penting (dalam hal ini Anda tidak akan menggunakan Python!).

Saya pikir saya hanya akan menambahkan bahwa di python 3, filter () sebenarnya adalah objek iterator, jadi Anda harus melewati metode panggilan Anda ke daftar () untuk membangun daftar yang difilter. Jadi dengan python 2:

lst_a = range(25) #arbitrary list
lst_b = [num for num in lst_a if num % 2 == 0]
lst_c = filter(lambda num: num % 2 == 0, lst_a)

daftar b dan c memiliki nilai yang sama, dan diselesaikan dalam waktu yang hampir bersamaan dengan filter () sama dengan [x untuk x dalam y jika z]. Namun, dalam 3, kode yang sama ini akan meninggalkan daftar c yang berisi objek filter, bukan daftar yang difilter. Untuk menghasilkan nilai yang sama dalam 3:

lst_a = range(25) #arbitrary list
lst_b = [num for num in lst_a if num % 2 == 0]
lst_c = list(filter(lambda num: num %2 == 0, lst_a))

Masalahnya adalah list () mengambil iterable sebagai argumennya, dan membuat daftar baru dari argumen itu. Hasilnya adalah bahwa menggunakan filter dengan cara ini di python 3 membutuhkan waktu hingga dua kali lebih lama daripada metode [x untuk x in y jika z] karena Anda harus beralih pada output dari filter () serta daftar asli.

Perbedaan penting adalah bahwa pemahaman daftar akan mengembalikan beberapa listsaat filter mengembalikan a filter, yang Anda tidak dapat memanipulasi seperti a list(yaitu: panggil len, yang tidak bekerja dengan pengembalian filter).

Belajar mandiri saya sendiri membawa saya ke beberapa masalah serupa.

Yang sedang berkata, jika ada cara untuk memiliki hasil listdari filter, sedikit seperti yang Anda lakukan di. NET ketika Anda melakukannya lst.Where(i => i.something()).ToList(), saya ingin tahu.

EDIT: Ini adalah kasus untuk Python 3, bukan 2 (lihat diskusi dalam komentar).

Saya menemukan cara kedua lebih mudah dibaca. Ini memberitahu Anda apa maksudnya: filter daftar.
PS: jangan gunakan 'daftar' sebagai nama variabel

umumnya filtersedikit lebih cepat jika menggunakan fungsi builtin.

Saya berharap pemahaman daftar menjadi sedikit lebih cepat dalam kasus Anda

Filter hanya itu. Ini menyaring elemen daftar. Anda dapat melihat definisi menyebutkan hal yang sama (di tautan dokumen resmi yang saya sebutkan sebelumnya). Sedangkan, pemahaman daftar adalah sesuatu yang menghasilkan daftar baru setelah bertindak atas sesuatu pada daftar sebelumnya. (Kedua filter dan pemahaman daftar membuat daftar baru dan tidak melakukan operasi di tempat daftar yang lebih lama. Daftar baru di sini adalah sesuatu seperti daftar dengan , katakanlah, tipe data yang sama sekali baru. Seperti mengonversi bilangan bulat menjadi string, dll)

Dalam contoh Anda, lebih baik menggunakan filter daripada pemahaman daftar, sesuai definisi. Namun, jika Anda ingin, katakan other_attribute dari elemen daftar, dalam contoh Anda akan diambil sebagai daftar baru, maka Anda dapat menggunakan pemahaman daftar.

return [item.other_attribute for item in my_list if item.attribute==value]

Ini adalah bagaimana saya benar-benar ingat tentang pemahaman filter dan daftar. Hapus beberapa hal dalam daftar dan jaga elemen lainnya tetap utuh, gunakan filter. Gunakan beberapa logika Anda sendiri di elemen dan buat daftar encer yang cocok untuk beberapa tujuan, gunakan pemahaman daftar.

Berikut adalah bagian pendek yang saya gunakan ketika saya perlu memfilter sesuatu setelah pemahaman daftar. Hanya kombinasi filter, lambda, dan daftar (atau dikenal sebagai kesetiaan kucing dan kebersihan anjing).

Dalam hal ini saya membaca file, menghapus garis kosong, mengomentari baris, dan apa pun setelah komentar pada baris:

# Throw out blank lines and comments
with open('file.txt', 'r') as lines:        
    # From the inside out:
    #    [s.partition('#')[0].strip() for s in lines]... Throws out comments
    #   filter(lambda x: x!= '', [s.part... Filters out blank lines
    #  y for y in filter... Converts filter object to list
    file_contents = [y for y in filter(lambda x: x != '', [s.partition('#')[0].strip() for s in lines])]

Selain jawaban yang diterima, ada sudut kasus saat Anda harus menggunakan filter alih-alih pemahaman daftar. Jika daftar itu tidak dapat dilanggar, Anda tidak dapat langsung memprosesnya dengan pemahaman daftar. Contoh dunia nyata adalah jika Anda menggunakan pyodbcuntuk membaca hasil dari database. The fetchAll()Hasil dari cursoradalah daftar unhashable. Dalam situasi ini, untuk secara langsung memanipulasi hasil yang dikembalikan, filter harus digunakan:

cursor.execute("SELECT * FROM TABLE1;")
data_from_db = cursor.fetchall()
processed_data = filter(lambda s: 'abc' in s.field1 or s.StartTime >= start_date_time, data_from_db) 

Jika Anda menggunakan pemahaman daftar di sini Anda akan mendapatkan kesalahan:

TypeError: tipe yang tidak dapat ditemukan: 'list'

Butuh beberapa waktu untuk membiasakan diri dengan higher order functions filterdan map. Jadi saya terbiasa dengan mereka dan saya benar-benar suka filterkarena secara eksplisit itu menyaring dengan menjaga apa pun yang benar dan saya merasa keren bahwa saya tahu beberapa functional programmingistilah.

Lalu saya membaca bagian ini (Fluent Python Book):

Fungsi peta dan filter masih dibangun di Python 3, tetapi karena pengenalan daftar komprehensif dan ekspresi generator, mereka tidak begitu penting. Listcomp atau genexp melakukan pekerjaan peta dan filter dikombinasikan, tetapi lebih mudah dibaca.

Dan sekarang saya pikir, mengapa repot-repot dengan konsep filter/ mapjika Anda dapat mencapainya dengan idiom yang sudah menyebar luas seperti daftar pemahaman. Lebih jauh lagi mapsdan filterssemacam fungsi. Dalam hal ini saya lebih suka menggunakan Anonymous functionslambdas.

Akhirnya, hanya untuk menguji, saya menghitung waktu kedua metode ( mapdan listComp) dan saya tidak melihat perbedaan kecepatan yang relevan yang akan membenarkan membuat argumen tentang hal itu.

from timeit import Timer

timeMap = Timer(lambda: list(map(lambda x: x*x, range(10**7))))
print(timeMap.timeit(number=100))

timeListComp = Timer(lambda:[(lambda x: x*x) for x in range(10**7)])
print(timeListComp.timeit(number=100))

#Map:                 166.95695265199174
#List Comprehension   177.97208347299602

Anehnya pada Python 3, saya melihat filter berkinerja lebih cepat daripada daftar pemahaman.

Saya selalu berpikir bahwa pemahaman daftar akan lebih baik. Sesuatu seperti: [nama untuk nama di brand_names_db jika nama tidak ada] Bytecode yang dihasilkan sedikit lebih baik.

>>> def f1(seq):
...     return list(filter(None, seq))
>>> def f2(seq):
...     return [i for i in seq if i is not None]
>>> disassemble(f1.__code__)
2         0 LOAD_GLOBAL              0 (list)
          2 LOAD_GLOBAL              1 (filter)
          4 LOAD_CONST               0 (None)
          6 LOAD_FAST                0 (seq)
          8 CALL_FUNCTION            2
         10 CALL_FUNCTION            1
         12 RETURN_VALUE
>>> disassemble(f2.__code__)
2           0 LOAD_CONST               1 (<code object <listcomp> at 0x10cfcaa50, file "<stdin>", line 2>)
          2 LOAD_CONST               2 ('f2.<locals>.<listcomp>')
          4 MAKE_FUNCTION            0
          6 LOAD_FAST                0 (seq)
          8 GET_ITER
         10 CALL_FUNCTION            1
         12 RETURN_VALUE

Tapi mereka sebenarnya lebih lambat:

   >>> timeit(stmt="f1(range(1000))", setup="from __main__ import f1,f2")
   21.177661532000116
   >>> timeit(stmt="f2(range(1000))", setup="from __main__ import f1,f2")
   42.233950221000214

Saya ambil

def filter_list(list, key, value, limit=None):
    return [i for i in list if i[key] == value][:limit]