Mengapa Python lambdas bermanfaat? [Tutup]

Saya mencoba mencari tahu Python lambdas. Apakah lambda salah satu item bahasa "menarik" yang dalam kehidupan nyata harus dilupakan?

Saya yakin ada beberapa kasus tepi di mana mungkin diperlukan, tetapi mengingat ketidakjelasan itu, potensi itu didefinisikan ulang dalam rilis mendatang (asumsi saya berdasarkan berbagai definisi itu) dan kejelasan pengkodean yang dikurangi - jika dihindari?

Ini mengingatkan saya pada overflow (buffer overflow) dari tipe C - menunjuk ke variabel teratas dan overloading untuk mengatur nilai field lainnya. Rasanya seperti semacam kecakapan memainkan pertunjukan teknisi tapi pemeliharaan mimpi buruk coder.

Apakah Anda berbicara tentang fungsi lambda ? Suka

lambda x: x**2 + 2*x - 5

Hal-hal itu sebenarnya cukup bermanfaat. Python mendukung gaya pemrograman yang disebut pemrograman fungsional di mana Anda dapat meneruskan fungsi ke fungsi lain untuk melakukan sesuatu. Contoh:

mult3 = filter(lambda x: x % 3 == 0, [1, 2, 3, 4, 5, 6, 7, 8, 9])

set mult3ke [3, 6, 9], elemen-elemen dari daftar asli yang merupakan kelipatan dari 3. Ini lebih pendek (dan, orang bisa berpendapat, lebih jelas) daripada

def filterfunc(x):
    return x % 3 == 0
mult3 = filter(filterfunc, [1, 2, 3, 4, 5, 6, 7, 8, 9])

Tentu saja, dalam kasus khusus ini, Anda dapat melakukan hal yang sama dengan pemahaman daftar:

mult3 = [x for x in [1, 2, 3, 4, 5, 6, 7, 8, 9] if x % 3 == 0]

(atau bahkan sama range(3,10,3)), tetapi ada banyak kasus penggunaan lain yang lebih canggih di mana Anda tidak dapat menggunakan pemahaman daftar dan fungsi lambda mungkin merupakan cara terpendek untuk menulis sesuatu.

• Mengembalikan fungsi dari fungsi lain

  >>> def transform(n):
  ...     return lambda x: x + n
  ...
  >>> f = transform(3)
  >>> f(4)
  7

  Ini sering digunakan untuk membuat pembungkus fungsi, seperti dekorator Python.

• Menggabungkan elemen dari urutan yang dapat diubah dengan reduce()

  >>> reduce(lambda a, b: '{}, {}'.format(a, b), [1, 2, 3, 4, 5, 6, 7, 8, 9])
  '1, 2, 3, 4, 5, 6, 7, 8, 9'

• Menyortir dengan tombol alternatif

  >>> sorted([1, 2, 3, 4, 5, 6, 7, 8, 9], key=lambda x: abs(5-x))
  [5, 4, 6, 3, 7, 2, 8, 1, 9]

Saya menggunakan fungsi lambda secara teratur. Butuh beberapa saat bagi saya untuk terbiasa dengan mereka, tetapi akhirnya saya mengerti bahwa mereka adalah bagian yang sangat berharga dari bahasa tersebut.

lambdahanyalah cara mewah untuk mengatakan function. Selain namanya, tidak ada yang tidak jelas, mengintimidasi atau samar tentang hal itu. Ketika Anda membaca baris berikut, gantikan lambdadengan functiondalam pikiran Anda:

>>> f = lambda x: x + 1
>>> f(3)
4

Itu hanya mendefinisikan fungsi x. Beberapa bahasa lain, seperti R, mengatakannya secara eksplisit:

> f = function(x) { x + 1 }
> f(3)
4

Kamu melihat? Ini adalah salah satu hal paling alami untuk dilakukan dalam pemrograman.

Ringkasan dua baris:

1. Penutupan : Sangat bermanfaat. Pelajari mereka, gunakan, cintai.
2. lambdaKata kunci Python : tidak perlu, terkadang berguna. Jika Anda menemukan diri Anda melakukan sesuatu yang jauh rumit dengannya, simpan dan tentukan fungsi yang sebenarnya.

Lambda adalah bagian dari mekanisme abstraksi yang sangat penting yang berkaitan dengan fungsi-fungsi tingkat tinggi. Untuk mendapatkan pemahaman yang benar tentang nilainya, silakan lihat pelajaran berkualitas tinggi dari Abelson dan Sussman , dan baca buku SICP

Ini adalah masalah yang relevan dalam bisnis perangkat lunak modern, dan menjadi semakin populer.

lambdas sangat berguna dalam pemrograman GUI. Misalnya, katakanlah Anda sedang membuat grup tombol dan Anda ingin menggunakan satu panggilan balik paramaterized daripada satu panggilan balik unik per tombol. Lambda memungkinkan Anda melakukannya dengan mudah:

for value in ["one","two","three"]:
    b = tk.Button(label=value, command=lambda arg=value: my_callback(arg))
    b.pack()

(Catatan: meskipun pertanyaan ini khusus ditanyakan lambda, Anda juga dapat menggunakan functools.partial untuk mendapatkan jenis hasil yang sama)

Alternatifnya adalah membuat panggilan balik terpisah untuk setiap tombol yang dapat menyebabkan kode digandakan.

Saya ragu lambda akan pergi. Lihat posting Guido tentang akhirnya menyerah mencoba menghapusnya. Juga lihat garis besar konflik .

Anda dapat memeriksa posting ini untuk mengetahui lebih banyak tentang sejarah tentang kesepakatan di balik fitur fungsional Python: http://python-history.blogspot.com/2009/04/origins-of-pythons-functional-features.html

Anehnya, peta, filter, dan mengurangi fungsi yang awalnya memotivasi pengenalan lambda dan fitur fungsional lainnya sebagian besar telah digantikan oleh daftar pemahaman dan ekspresi generator. Bahkan, fungsi pengurangan telah dihapus dari daftar fungsi builtin di Python 3.0. (Namun, tidak perlu mengirim keluhan tentang penghapusan lambda, peta, atau filter: mereka tetap ada. :-)

Dua sen saya sendiri: Jarang adalah nilai lambda sejauh kejelasannya. Secara umum ada solusi yang lebih jelas yang tidak termasuk lambda.

Dalam Python, lambdahanyalah cara mendefinisikan fungsi inline,

a = lambda x: x + 1
print a(1)

dan..

def a(x): return x + 1
print a(1)

..adalah persis sama.

Tidak ada yang dapat Anda lakukan dengan lambda yang tidak dapat Anda lakukan dengan fungsi biasa — dalam fungsi Python adalah objek seperti yang lainnya, dan lambdas hanya mendefinisikan fungsi:

>>> a = lambda x: x + 1
>>> type(a)
<type 'function'>

Jujur saya pikir itu lambda kata kunci itu berlebihan di Python — saya tidak pernah memiliki kebutuhan untuk menggunakannya (atau melihat yang digunakan di mana fungsi biasa, pemahaman daftar atau salah satu dari banyak fungsi builtin bisa lebih baik digunakan sebagai gantinya)

Untuk contoh yang benar-benar acak, dari artikel "lambda Python rusak!" :

Untuk melihat bagaimana lambda rusak, coba buat daftar fungsi di fs=[f0,...,f9]mana fi(n)=i+n. Percobaan pertama:

>>> fs = [(lambda n: i + n) for i in range(10)]
>>> fs[3](4)
13

Saya berpendapat, bahkan jika itu berhasil, itu mengerikan dan "unpythonic", fungsi yang sama dapat ditulis dalam banyak cara lain, misalnya:

>>> n = 4
>>> [i + n for i in range(10)]
[4, 5, 6, 7, 8, 9, 10, 11, 12, 13]

Ya, itu tidak sama, tetapi saya belum pernah melihat penyebab di mana menghasilkan sekelompok fungsi lambda dalam daftar telah diperlukan. Mungkin masuk akal dalam bahasa lain, tetapi Python bukan Haskell (atau Lisp, atau ...)

Harap dicatat bahwa kami dapat menggunakan lambda dan masih mencapai hasil yang diinginkan dengan cara ini:

>>> fs = [(lambda n,i=i: i + n) for i in range(10)]
>>> fs[3](4)
7

Edit:

Ada beberapa kasus di mana lambda berguna, misalnya sering nyaman ketika menghubungkan sinyal dalam aplikasi PyQt, seperti ini:

w = PyQt4.QtGui.QLineEdit()
w.textChanged.connect(lambda event: dothing())

Melakukan sesuatu w.textChanged.connect(dothing)akan memanggil dothingmetode dengan eventargumen tambahan dan menyebabkan kesalahan. Menggunakan lambda berarti kita dapat dengan mudah menjatuhkan argumen tanpa harus mendefinisikan fungsi pembungkus.

Saya menemukan lambda berguna untuk daftar fungsi yang melakukan hal yang sama, tetapi untuk keadaan yang berbeda.

Seperti aturan jamak Mozilla :

plural_rules = [
    lambda n: 'all',
    lambda n: 'singular' if n == 1 else 'plural',
    lambda n: 'singular' if 0 <= n <= 1 else 'plural',
    ...
]
# Call plural rule #1 with argument 4 to find out which sentence form to use.
plural_rule[1](4) # returns 'plural'

Jika Anda harus mendefinisikan fungsi untuk semua yang Anda akan menjadi gila pada akhir itu.
Juga, itu tidak akan bagus dengan nama fungsi seperti plural_rule_1, plural_rule_2, dll Dan Anda akan perlu untuk eval()itu ketika Anda tergantung pada fungsi variabel id.

Cukup banyak hal yang dapat Anda lakukan lambda dapat dilakukan dengan fungsi atau daftar dan ekspresi generator.

Akibatnya, untuk sebagian besar Anda harus hanya salah satu dari mereka yang pada dasarnya situasi apa pun (kecuali mungkin untuk kode awal yang ditulis dalam interpreter interaktif).

Saya telah menggunakan Python selama beberapa tahun dan saya tidak pernah menjalankan kasus dimana saya membutuhkan lambda. Sungguh, seperti yang dinyatakan dalam tutorial , itu hanya untuk gula sintaksis.

Saya tidak dapat berbicara dengan implementasi lambda dari python, tetapi secara umum fungsi lambda sangat berguna. Mereka adalah teknik inti (bahkan mungkin THE teknik) pemrograman fungsional, dan mereka juga sangat berguna dalam program berorientasi objek. Untuk jenis masalah tertentu, mereka adalah solusi terbaik, jadi tentunya tidak boleh dilupakan!

Saya sarankan Anda membaca tentang penutupan dan fungsi peta (yang menghubungkan ke python docs, tetapi ada di hampir setiap bahasa yang mendukung konstruksi fungsional) untuk melihat mengapa itu berguna.

Fungsi Lambda ini adalah cara non-birokratis untuk membuat fungsi.

Itu dia. Sebagai contoh, mari kita anggap Anda memiliki fungsi utama dan perlu menguadratkan nilai. Mari kita lihat cara tradisional dan cara lambda untuk melakukan ini:

Cara tradisional:

def main():
...
...
y = square(some_number)
...
return something

def square(x):
    return x**2

Cara lambda:

def main():
...
square = lambda x: x**2
y = square(some_number)
return something

Lihat perbedaannya?

Fungsi Lambda berjalan sangat baik dengan daftar, seperti daftar pemahaman atau peta. Bahkan, pemahaman daftar itu adalah cara "pythonic" untuk mengekspresikan diri menggunakan lambda. Ex:

>>>a = [1,2,3,4]
>>>[x**2 for x in a]
[1,4,9,16]

Mari kita lihat apa arti setiap elemen dari sintaks:

[]: "Beri aku daftar"

x ** 2: "menggunakan fungsi yang baru lahir ini"

untuk x in a: "ke dalam setiap elemen dalam"

Itu nyaman, eh? Menciptakan fungsi seperti ini. Mari kita menulis ulang menggunakan lambda:

>>> square = lambda x: x**2
>>> [square(s) for x in a]
[1,4,9,16]

Sekarang mari kita gunakan peta, yang merupakan hal yang sama, tetapi lebih netral bahasa. Peta membutuhkan 2 argumen:

(i) satu fungsi

(ii) iterable

Dan memberi Anda daftar di mana setiap elemen itu fungsi yang diterapkan untuk setiap elemen iterable.

Jadi, dengan menggunakan peta kita akan memiliki:

>>> a = [1,2,3,4]
>>> squared_list = map(lambda x: x**2, a)

Jika Anda menguasai lambda dan pemetaan, Anda akan memiliki kekuatan besar untuk memanipulasi data dan secara ringkas. Fungsi Lambda tidak jelas atau menghilangkan kejelasan kode. Jangan membingungkan sesuatu yang keras dengan sesuatu yang baru. Setelah Anda mulai menggunakannya, Anda akan merasa sangat jelas.

Salah satu hal yang menyenangkan tentang lambdaitu menurut pendapat saya kurang penting adalah cara menunda evaluasi untuk formulir sederhana sampai nilainya diperlukan. Biarkan saya jelaskan.

Banyak rutin perpustakaan diimplementasikan sehingga memungkinkan parameter tertentu menjadi callable (di antaranya lambda adalah satu). Idenya adalah bahwa nilai aktual akan dihitung hanya pada saat itu akan digunakan (bukan ketika itu disebut). Contoh (dibuat-buat) mungkin bisa membantu menggambarkan hal tersebut. Misalkan Anda memiliki rutinitas yang akan melakukan log cap waktu tertentu. Anda ingin rutin menggunakan waktu saat ini minus 30 menit. Anda akan menyebutnya seperti itu

log_timestamp(datetime.datetime.now() - datetime.timedelta(minutes = 30))

Sekarang anggap fungsi aktual akan dipanggil hanya ketika peristiwa tertentu terjadi dan Anda ingin cap waktu dihitung hanya pada waktu itu. Anda dapat melakukan ini seperti itu

log_timestamp(lambda : datetime.datetime.now() - datetime.timedelta(minutes = 30))

Dengan asumsi log_timestamp kaleng menangani callable seperti ini, itu akan mengevaluasi ini ketika dibutuhkan dan Anda akan mendapatkan cap waktu pada waktu itu.

Tentu saja ada cara alternatif untuk melakukan ini (menggunakan operator modul misalnya) tapi saya harap saya telah menyampaikan intinya.

Perbarui : Di Sini adalah contoh dunia nyata yang sedikit lebih konkret.

Pembaruan 2 : Saya pikir ini adalah contoh dari apa yang disebut thunk .

Seperti yang dinyatakan di atas, operator lambda di Python mendefinisikan fungsi anonim, dan dalam fungsi Python adalah penutupan. Penting untuk tidak membingungkan konsep penutupan dengan lambda operator, yang hanya metadon sintaksis bagi mereka.

Ketika saya mulai dengan Python beberapa tahun yang lalu, saya banyak menggunakan lambdas, berpikir mereka keren, bersama dengan daftar pemahaman. Namun, saya menulis dan harus memelihara situs web besar yang ditulis dengan Python, dengan urutan beberapa ribu poin fungsi. Saya telah belajar dari pengalaman bahwa lambdas mungkin baik-baik saja untuk membuat prototipe dengan, tetapi tidak menawarkan apa pun atas fungsi inline (bernama penutupan) kecuali untuk menyimpan beberapa kunci-stoke, atau kadang-kadang tidak.

Pada dasarnya ini bermuara pada beberapa poin:

• lebih mudah untuk membaca perangkat lunak yang ditulis secara eksplisit menggunakan nama yang bermakna. Penutupan anonim menurut definisi tidak dapat memiliki nama yang bermakna, karena mereka tidak memiliki nama. Keringkasan ini tampaknya, untuk beberapa alasan, juga menginfeksi parameter lambda, maka kita sering melihat contoh seperti lambda x: x + 1
• lebih mudah untuk menggunakan kembali penutupan yang disebut, karena mereka dapat disebut dengan nama lebih dari sekali, ketika ada nama untuk merujuk mereka.
• lebih mudah untuk men-debug kode yang menggunakan penutupan bernama daripada lambdas, karena nama akan muncul di tracebacks, dan di sekitar kesalahan.

Itu alasan yang cukup untuk mengumpulkan mereka dan mengubahnya menjadi penutupan bernama. Namun, saya menyimpan dua dendam lain terhadap penutupan anonim.

Dendam pertama hanyalah bahwa mereka hanyalah kata kunci lain yang tidak perlu mengacaukan bahasa.

Dendam kedua lebih dalam dan pada tingkat paradigma, yaitu saya tidak suka bahwa mereka mempromosikan gaya pemrograman fungsional, karena gaya itu kurang fleksibel daripada pesan yang lewat, berorientasi objek atau gaya prosedural, karena kalkulus lambda tidak Turing- selesai (untungnya dengan Python, kita masih bisa keluar dari pembatasan itu bahkan di dalam lambda). Alasan saya merasa lambdas mempromosikan gaya ini adalah:

• Ada pengembalian tersirat, yaitu mereka sepertinya 'harus' menjadi fungsi.

• Mereka adalah alternatif mekanisme penyembunyian negara ke mekanisme lain, lebih eksplisit, lebih mudah dibaca, lebih dapat digunakan kembali dan lebih umum: metode.

Saya berusaha keras untuk menulis Python bebas lambda, dan menghapus lambdas saat dilihat. Saya pikir Python akan menjadi bahasa yang sedikit lebih baik tanpa lambda, tapi itu hanya pendapat saya.

Lambdas sebenarnya adalah konstruksi yang sangat kuat yang berasal dari ide-ide dalam pemrograman fungsional, dan itu adalah sesuatu yang tidak akan mudah direvisi, didefinisikan ulang atau dihapus dalam waktu dekat Python. Mereka membantu Anda menulis kode yang lebih kuat karena memungkinkan Anda untuk lulus fungsi sebagai parameter, sehingga gagasan fungsi sebagai warga negara kelas satu.

Lambdas memang cenderung membingungkan, tetapi begitu pemahaman yang kuat diperoleh, Anda dapat menulis kode elegan yang bersih seperti ini:

squared = map(lambda x: x*x, [1, 2, 3, 4, 5])

Baris kode di atas mengembalikan daftar kotak angka-angka dalam daftar. Tentu, Anda juga bisa melakukannya seperti:

def square(x):
    return x*x

squared = map(square, [1, 2, 3, 4, 5])

Jelas kode sebelumnya lebih pendek, dan ini terutama benar jika Anda bermaksud untuk menggunakan fungsi peta (atau fungsi serupa lainnya yang mengambil fungsi sebagai parameter) hanya di satu tempat. Ini juga membuat kode lebih intuitif dan elegan.

Juga, seperti yang disebutkan @David Zaslavsky dalam jawabannya, pemahaman daftar tidak selalu merupakan jalan yang harus ditempuh terutama jika daftar Anda harus mendapatkan nilai dari beberapa cara matematika yang tidak jelas.

Dari sudut pandang yang lebih praktis, salah satu keuntungan terbesar lambda bagi saya baru-baru ini adalah dalam pemrograman GUI dan event-driven. Jika Anda melihat callback di Tkinter, yang mereka ambil sebagai argumen adalah peristiwa yang memicu mereka. Misalnya

def define_bindings(widget):
    widget.bind("<Button-1>", do-something-cool)

def do-something-cool(event):
    #Your code to execute on the event trigger

Sekarang bagaimana jika Anda memiliki beberapa argumen untuk dilewati? Sesuatu yang sederhana seperti melewati 2 argumen untuk menyimpan koordinat klik-mouse. Anda dapat dengan mudah melakukannya seperti ini:

def main():
    # define widgets and other imp stuff
    x, y = None, None
    widget.bind("<Button-1>", lambda event: do-something-cool(x, y))

def do-something-cool(event, x, y):
    x = event.x
    y = event.y
    #Do other cool stuff

Sekarang Anda dapat berargumen bahwa ini dapat dilakukan dengan menggunakan variabel global, tetapi apakah Anda benar-benar ingin memukul kepala Anda khawatir tentang manajemen memori dan kebocoran terutama jika variabel global hanya akan digunakan di satu tempat tertentu? Itu hanya gaya pemrograman yang buruk.

Singkatnya, lambda itu luar biasa dan tidak boleh dianggap remeh. Python lambdas tidak sama dengan LISP lambdas (yang lebih kuat), tetapi Anda benar-benar dapat melakukan banyak hal ajaib dengan mereka.

Lambdas sangat terkait dengan gaya pemrograman fungsional secara umum. Gagasan bahwa Anda dapat memecahkan masalah dengan menerapkan fungsi ke beberapa data, dan menggabungkan hasilnya, adalah apa yang digunakan Google untuk mengimplementasikan sebagian besar algoritmanya.

Program yang ditulis dalam gaya pemrograman fungsional, mudah diparalelkan dan karenanya menjadi semakin penting dengan mesin multi-core modern. Jadi singkatnya, TIDAK Anda tidak boleh melupakan mereka.

Selamat pertama yang berhasil menemukan lambda. Menurut pendapat saya ini adalah konstruksi yang sangat kuat untuk bertindak. Tren akhir-akhir ini terhadap bahasa pemrograman fungsional jelas merupakan indikator bahwa hal itu tidak harus dihindari atau akan didefinisikan ulang dalam waktu dekat.

Anda hanya perlu berpikir sedikit berbeda. Saya yakin Anda akan segera menyukainya. Tapi hati-hati jika Anda hanya berurusan dengan python. Karena lambda bukan merupakan penutupan nyata, itu entah bagaimana "rusak": ular sanca lambda rusak

Saya baru saja memulai Python dan menjalankan kepala pertama ke Lambda- yang butuh waktu beberapa saat untuk mencari tahu.

Perhatikan bahwa ini bukan suatu penghukuman terhadap apa pun. Setiap orang memiliki serangkaian hal berbeda yang tidak mudah datang.

Apakah lambda salah satu item bahasa yang 'menarik' yang dalam kehidupan nyata harus dilupakan?

Tidak.

Saya yakin ada beberapa kasus tepi di mana mungkin diperlukan, tetapi mengingat ketidakjelasan itu,

Itu tidak jelas. 2 tim terakhir yang saya kerjakan, semua orang menggunakan fitur ini sepanjang waktu.

potensi itu didefinisikan ulang dalam rilis mendatang (asumsi saya berdasarkan berbagai definisi itu)

Saya telah melihat tidak ada proposal serius untuk mendefinisikannya kembali dengan Python, di luar memperbaiki semantik penutupan beberapa tahun yang lalu.

dan kejelasan coding yang berkurang - haruskah itu dihindari?

Tidak kalah jelas, jika Anda menggunakannya dengan benar. Sebaliknya, memiliki lebih banyak konstruksi bahasa yang tersedia meningkatkan kejelasan.

Ini mengingatkan saya pada overflow (buffer overflow) dari tipe C - menunjuk ke variabel teratas dan overloading untuk mengatur nilai-nilai bidang lainnya ... semacam kecakapan memainkan pertunjukan techie tapi mimpi buruk coder maintenance ..

Lambda seperti buffer overflow? Wow. Saya tidak bisa membayangkan bagaimana Anda menggunakan lambda jika Anda pikir itu adalah "mimpi buruk pemeliharaan".

Saya menggunakan lambdas untuk menghindari duplikasi kode. Ini akan membuat fungsinya dengan mudah dipahami. Misalnya:

def a_func()
  ...
  if some_conditon:
     ...
     call_some_big_func(arg1, arg2, arg3, arg4...)
  else
     ...
     call_some_big_func(arg1, arg2, arg3, arg4...)

Saya menggantinya dengan temp lambda

def a_func()
  ...
  call_big_f = lambda args_that_change: call_some_big_func(arg1, arg2, arg3, args_that_change)
  if some_conditon:
     ...
     call_big_f(argX)
  else
     ...
     call_big_f(argY)

Saya mulai membaca buku David Mertz hari ini 'Text Processing in Python.' Sementara ia memiliki deskripsi yang cukup singkat tentang Lambda, contoh-contoh dalam bab pertama dikombinasikan dengan penjelasan dalam Lampiran A membuat mereka melompat dari halaman untuk saya (akhirnya) dan tiba-tiba saya mengerti nilai mereka. Itu tidak berarti penjelasannya akan bekerja untuk Anda dan saya masih pada tahap penemuan jadi saya tidak akan mencoba untuk menambahkan tanggapan ini selain dari yang berikut: Saya baru di Python Saya baru di OOP Lambdas adalah perjuangan untuk saya Sekarang saya membaca Mertz, saya pikir saya mendapatkannya dan saya melihat mereka sangat berguna karena saya pikir mereka memungkinkan pendekatan yang lebih bersih untuk pemrograman.

Dia mereproduksi Zen Python, satu baris yang Sederhana lebih baik daripada kompleks. Sebagai programmer non-OOP membaca kode dengan lambdas (dan sampai minggu lalu daftar pemahaman) saya pikir- ini sederhana? . Saya akhirnya menyadari hari ini bahwa sebenarnya fitur-fitur ini membuat kode jauh lebih mudah dibaca, dan dapat dimengerti daripada alternatif-yang selalu merupakan semacam loop. Saya juga menyadari bahwa seperti laporan keuangan-Python tidak dirancang untuk pengguna pemula, melainkan dirancang untuk pengguna yang ingin mendapatkan pendidikan. Saya tidak percaya betapa kuatnya bahasa ini. Ketika saya sadar (akhirnya) tujuan dan nilai lambda saya ingin meringkas sekitar 30 program dan mulai memasukkan lambda di mana sesuai.

Kasus yang berguna untuk menggunakan lambdas adalah untuk meningkatkan keterbacaan pemahaman daftar panjang . Dalam contoh loop_dicini singkat untuk kejelasan tetapi bayangkan loop_dicsangat panjang. Jika Anda hanya akan menggunakan nilai polos yang mencakup ialih-alih versi lambda dari nilai itu, Anda akan mendapatkan NameError.

>>> lis = [{"name": "Peter"}, {"name": "Josef"}]

>>> loop_dic = lambda i: {"name": i["name"] + " Wallace" }
>>> new_lis = [loop_dic(i) for i in lis]

>>> new_lis
[{'name': 'Peter Wallace'}, {'name': 'Josef Wallace'}]

Dari pada

>>> lis = [{"name": "Peter"}, {"name": "Josef"}]

>>> new_lis = [{"name": i["name"] + " Wallace"} for i in lis]

>>> new_lis
[{'name': 'Peter Wallace'}, {'name': 'Josef Wallace'}]

Saya dapat memberikan contoh di mana saya benar-benar membutuhkan lambda. Saya membuat program grafis, di mana penggunaan klik kanan pada file dan menetapkan salah satu dari tiga opsi. Ternyata di Tkinter (program antarmuka GUI saya menulis ini), ketika seseorang menekan tombol, itu tidak dapat ditugaskan ke perintah yang mengambil argumen. Jadi jika saya memilih salah satu opsi dan ingin hasil dari pilihan saya adalah:

print 'hi there'

Maka bukan masalah besar. Tetapi bagaimana jika saya membutuhkan pilihan saya untuk memiliki detail tertentu. Sebagai contoh, jika saya memilih pilihan A, itu memanggil fungsi yang mengambil dalam beberapa argumen yang bergantung pada pilihan A, B atau C, TKinter tidak dapat mendukung ini. Lamda adalah satu-satunya pilihan untuk menyiasati ini ...

Saya sering menggunakannya, terutama sebagai objek nol atau untuk sebagian mengikat parameter ke suatu fungsi.

Berikut ini contohnya:

untuk menerapkan pola objek nol:

{
    DATA_PACKET: self.handle_data_packets
    NET_PACKET: self.handle_hardware_packets
}.get(packet_type, lambda x : None)(payload)

untuk pengikatan parameter:

katakanlah saya memiliki API berikut

def dump_hex(file, var)
    # some code
    pass

class X(object):
    #...
    def packet_received(data):
        # some kind of preprocessing
        self.callback(data)
    #...

Lalu, ketika saya tidak ingin dengan cepat membuang data yang diterima ke file saya melakukan itu:

dump_file = file('hex_dump.txt','w')
X.callback = lambda (x): dump_hex(dump_file, x)
...
dump_file.close()

saya menggunakan lambda untuk membuat panggilan balik yang menyertakan parameter. Lebih bersih menulis lambda dalam satu baris daripada menulis metode untuk melakukan fungsi yang sama.

Sebagai contoh:

import imported.module

def func():
    return lambda: imported.module.method("foo", "bar")

sebagai lawan:

import imported.module

def func():
    def cb():
        return imported.module.method("foo", "bar")
    return cb

Saya pemula python, jadi untuk mendapatkan ide yang jelas tentang lambda saya membandingkannya dengan loop 'untuk'; dalam hal efisiensi. Berikut kodenya (python 2.7) -

import time
start = time.time() # Measure the time taken for execution

def first():
    squares = map(lambda x: x**2, range(10))
    # ^ Lambda
    end = time.time()
    elapsed = end - start
    print elapsed + ' seconds'
    return elapsed # gives 0.0 seconds

def second():
    lst = []
    for i in range(10):
        lst.append(i**2)
    # ^ a 'for' loop
    end = time.time()
    elapsed = end - start
    print elapsed + ' seconds'
    return elapsed # gives 0.0019998550415 seconds.

print abs(second() - first()) # Gives 0.0019998550415 seconds!(duh)

Lambda adalah pembangun prosedur. Anda dapat mensintesis program saat dijalankan, meskipun lambda Python tidak terlalu kuat. Perhatikan bahwa hanya sedikit orang yang mengerti pemrograman semacam itu.