Python dan bahasa lain seperti Java, C#, dan bahkan C++ memiliki fungsi lambda yang ditambahkan ke sintaksnya, sedangkan bahasa seperti LISP atau keluarga bahasa ML, Haskell, OCaml, dan F#, menggunakan lambdas sebagai konsep inti
Lambda Python kecil, fungsi anonim, tunduk pada sintaks yang lebih ketat tetapi lebih ringkas daripada fungsi Python biasa
Di akhir artikel ini, Anda akan mengetahuinya
- Bagaimana Python lambda muncul
- Bagaimana lambda dibandingkan dengan objek fungsi biasa
- Cara menulis fungsi lambda
- Yang berfungsi di perpustakaan standar Python memanfaatkan lambdas
- Kapan harus menggunakan atau menghindari fungsi lambda Python
Catatan. Anda akan melihat beberapa contoh kode menggunakan
def add_one[x]:
return x + 1
2 yang tampaknya secara terang-terangan mengabaikan praktik terbaik gaya Python. Ini hanya dimaksudkan untuk mengilustrasikan konsep kalkulus lambda atau untuk menyoroti kemampuan Python def add_one[x]:
return x + 1
2Contoh-contoh yang dipertanyakan itu akan dikontraskan dengan pendekatan atau alternatif yang lebih baik saat Anda melanjutkan artikel
Tutorial ini terutama untuk pemrogram Python tingkat menengah hingga berpengalaman, tetapi dapat diakses oleh semua orang yang penasaran dengan minat dalam pemrograman dan kalkulus lambda
Semua contoh yang disertakan dalam tutorial ini telah diuji dengan Python 3. 7
Ikuti Kuis. Uji pengetahuan Anda dengan kuis "Fungsi Python Lambda" interaktif kami. Setelah selesai Anda akan menerima skor sehingga Anda dapat melacak kemajuan belajar Anda dari waktu ke waktu
Ikuti Kuis »
Download Gratis. Dapatkan contoh bab dari Trik Python. Buku yang menunjukkan kepada Anda praktik terbaik Python dengan contoh sederhana yang dapat Anda terapkan secara instan untuk menulis kode + Pythonic yang lebih indah
Kalkulus Lambda
Ekspresi Lambda dalam Python dan bahasa pemrograman lainnya berakar pada kalkulus lambda, model komputasi yang ditemukan oleh Alonzo Church. Anda akan mengetahui kapan kalkulus lambda diperkenalkan dan mengapa ini merupakan konsep dasar yang berakhir di ekosistem Python
Hilangkan iklanSejarah
Gereja Alonzo memformalkan kalkulus lambda, sebuah bahasa yang didasarkan pada abstraksi murni, pada tahun 1930-an. Fungsi Lambda juga disebut sebagai abstraksi lambda, referensi langsung ke model abstraksi ciptaan asli Gereja Alonzo
Kalkulus Lambda dapat menyandikan perhitungan apa pun. Ini Turing lengkap, tetapi bertentangan dengan konsep mesin Turing, itu murni dan tidak mempertahankan keadaan apa pun
Bahasa fungsional berasal dari logika matematika dan kalkulus lambda, sedangkan bahasa pemrograman imperatif merangkul model perhitungan berbasis negara yang ditemukan oleh Alan Turing. Dua model komputasi, kalkulus lambda dan mesin Turing, dapat diterjemahkan satu sama lain. Persamaan ini dikenal sebagai hipotesis Church-Turing
Bahasa fungsional secara langsung mewarisi filosofi kalkulus lambda, mengadopsi pendekatan deklaratif pemrograman yang menekankan abstraksi, transformasi data, komposisi, dan kemurnian [tanpa keadaan dan tanpa efek samping]. Contoh bahasa fungsional termasuk Haskell, Lisp, atau Erlang
Sebaliknya, Mesin Turing menghasilkan pemrograman imperatif yang ditemukan dalam bahasa seperti Fortran, C, atau Python
Gaya imperatif terdiri dari pemrograman dengan pernyataan, menggerakkan aliran program langkah demi langkah dengan instruksi terperinci. Pendekatan ini mempromosikan mutasi dan membutuhkan status pengelolaan
Pemisahan dalam kedua keluarga menghadirkan beberapa nuansa, karena beberapa bahasa fungsional memasukkan fitur imperatif, seperti OCaml, sementara fitur fungsional telah menembus keluarga bahasa imperatif khususnya dengan pengenalan fungsi lambda di Java, atau Python
Python pada dasarnya bukanlah bahasa fungsional, tetapi ia mengadopsi beberapa konsep fungsional sejak awal. Pada bulan Januari 1994,
def add_one[x]:
return x + 1
_4, def add_one[x]:
return x + 1
5, def add_one[x]:
return x + 1
6, dan operator def add_one[x]:
return x + 1
2 ditambahkan ke bahasaContoh Pertama
Berikut adalah beberapa contoh untuk memberi Anda selera untuk beberapa kode Python, gaya fungsional
Fungsi identitas, fungsi yang mengembalikan argumennya, diekspresikan dengan definisi fungsi Python standar menggunakan kata kunci
def add_one[x]:
return x + 1
8 sebagai berikut>>>
>>> def identity[x]:
.. return x
_def add_one[x]:
return x + 1
_9 mengambil argumen >>> full_name = lambda first, last: f'Full name: {first.title[]} {last.title[]}'
>>> full_name['guido', 'van rossum']
'Full name: Guido Van Rossum'
0 dan mengembalikannya saat berdoaSebaliknya, jika Anda menggunakan konstruksi lambda Python, Anda akan mendapatkan yang berikut
>>>
>>> lambda x: x
_Dalam contoh di atas, ekspresi terdiri dari
- Kata kunci.
_2def add_one[x]: return x + 1
- Variabel terikat.
_0>>> full_name = lambda first, last: f'Full name: {first.title[]} {last.title[]}' >>> full_name['guido', 'van rossum'] 'Full name: Guido Van Rossum'
- Sebuah tubuh.
_0>>> full_name = lambda first, last: f'Full name: {first.title[]} {last.title[]}' >>> full_name['guido', 'van rossum'] 'Full name: Guido Van Rossum'
Catatan. Dalam konteks artikel ini, variabel terikat adalah argumen untuk fungsi lambda
Sebaliknya, variabel bebas tidak terikat dan dapat direferensikan dalam isi ekspresi. Variabel bebas dapat berupa konstanta atau variabel yang didefinisikan dalam cakupan fungsi yang terlampir
Anda dapat menulis contoh yang sedikit lebih rumit, sebuah fungsi yang menambahkan
>>> full_name = lambda first, last: f'Full name: {first.title[]} {last.title[]}'
>>> full_name['guido', 'van rossum']
'Full name: Guido Van Rossum'
4 ke argumen, sebagai berikut>>>
>>> lambda x: x + 1
_Anda dapat menerapkan fungsi di atas ke argumen dengan mengapit fungsi dan argumennya dengan tanda kurung
>>>
>>> [lambda x: x + 1][2]
3
_Pengurangan adalah strategi kalkulus lambda untuk menghitung nilai ekspresi. Dalam contoh saat ini, terdiri dari mengganti variabel terikat
>>> full_name = lambda first, last: f'Full name: {first.title[]} {last.title[]}'
>>> full_name['guido', 'van rossum']
'Full name: Guido Van Rossum'
0 dengan argumen >>> full_name = lambda first, last: f'Full name: {first.title[]} {last.title[]}'
>>> full_name['guido', 'van rossum']
'Full name: Guido Van Rossum'
6[lambda x: x + 1][2] = lambda 2: 2 + 1
= 2 + 1
= 3
Karena fungsi lambda adalah sebuah ekspresi, ia dapat diberi nama. Oleh karena itu Anda dapat menulis kode sebelumnya sebagai berikut
>>>
>>> add_one = lambda x: x + 1
>>> add_one[2]
3
_Fungsi lambda di atas sama dengan menulis ini
def add_one[x]:
return x + 1
Semua fungsi ini mengambil satu argumen. Anda mungkin telah memperhatikan bahwa, dalam definisi lambda, argumen tidak memiliki tanda kurung di sekitarnya. Fungsi multi-argumen [fungsi yang mengambil lebih dari satu argumen] diekspresikan dalam Python lambdas dengan mencantumkan argumen dan memisahkannya dengan koma [
>>> full_name = lambda first, last: f'Full name: {first.title[]} {last.title[]}'
>>> full_name['guido', 'van rossum']
'Full name: Guido Van Rossum'
7] tetapi tanpa mengelilinginya dengan tanda kurung>>>
>>> full_name = lambda first, last: f'Full name: {first.title[]} {last.title[]}'
>>> full_name['guido', 'van rossum']
'Full name: Guido Van Rossum'
_Fungsi lambda yang ditugaskan ke
>>> full_name = lambda first, last: f'Full name: {first.title[]} {last.title[]}'
>>> full_name['guido', 'van rossum']
'Full name: Guido Van Rossum'
_8 mengambil dua argumen dan mengembalikan string yang menginterpolasi dua parameter >>> full_name = lambda first, last: f'Full name: {first.title[]} {last.title[]}'
>>> full_name['guido', 'van rossum']
'Full name: Guido Van Rossum'
9 dan >>> lambda x, y: x + y
0. Seperti yang diharapkan, definisi lambda mencantumkan argumen tanpa tanda kurung, sedangkan pemanggilan fungsi dilakukan persis seperti fungsi Python normal, dengan tanda kurung mengelilingi argumenHilangkan iklanFungsi Anonim
Istilah berikut dapat digunakan secara bergantian tergantung pada jenis dan budaya bahasa pemrograman
- Fungsi anonim
- Fungsi Lambda
- Ekspresi Lambda
- Abstraksi Lambda
- bentuk Lambda
- Literal fungsi
Untuk sisa artikel ini setelah bagian ini, sebagian besar Anda akan melihat istilah fungsi lambda
Secara harfiah, fungsi anonim adalah fungsi tanpa nama. Dengan Python, fungsi anonim dibuat dengan kata kunci
def add_one[x]:
return x + 1
2. Lebih longgar, itu mungkin diberi nama atau tidak. Pertimbangkan fungsi anonim dua argumen yang didefinisikan dengan def add_one[x]:
return x + 1
2 tetapi tidak terikat pada variabel. Lambda tidak diberi nama>>>
>>> lambda x, y: x + y
_Fungsi di atas mendefinisikan ekspresi lambda yang mengambil dua argumen dan mengembalikan jumlahnya
Selain memberi Anda umpan balik bahwa Python baik-baik saja dengan formulir ini, itu tidak mengarah pada penggunaan praktis apa pun. Anda bisa menjalankan fungsi di juru bahasa Python
>>>
>>> _[1, 2]
3
_Contoh di atas memanfaatkan fitur khusus juru bahasa interaktif yang disediakan melalui garis bawah [
>>> lambda x, y: x + y
3]. Lihat catatan di bawah untuk detail lebih lanjutAnda tidak dapat menulis kode serupa di modul Python. Pertimbangkan
>>> lambda x, y: x + y
_3 dalam juru bahasa sebagai efek samping yang Anda manfaatkan. Dalam modul Python, Anda akan memberikan nama ke lambda, atau Anda akan meneruskan lambda ke suatu fungsi. Anda akan menggunakan kedua pendekatan tersebut nanti di artikel iniCatatan. Dalam interpreter interaktif, garis bawah tunggal [
>>> lambda x, y: x + y
3] terikat pada ekspresi terakhir yang dievaluasiPada contoh di atas,
>>> lambda x, y: x + y
_3 menunjuk ke fungsi lambda. Untuk detail lebih lanjut tentang penggunaan karakter khusus ini di Python, lihat Arti Garis Bawah di PythonPola lain yang digunakan dalam bahasa lain seperti JavaScript adalah dengan segera mengeksekusi fungsi lambda Python. Ini dikenal sebagai Ekspresi Fungsi yang Segera Dipanggil [IIFE, lafalkan "rapuh"]. Ini sebuah contoh
>>>
>>> lambda x: x
0Fungsi lambda di atas didefinisikan dan kemudian langsung dipanggil dengan dua argumen [
>>> full_name = lambda first, last: f'Full name: {first.title[]} {last.title[]}'
>>> full_name['guido', 'van rossum']
'Full name: Guido Van Rossum'
6 dan >>> lambda x, y: x + y
8]. Itu mengembalikan nilai >>> lambda x, y: x + y
_9, yang merupakan jumlah dari argumenBeberapa contoh dalam tutorial ini menggunakan format ini untuk menyorot aspek anonim dari fungsi lambda dan menghindari fokus pada
def add_one[x]:
return x + 1
2 dengan Python sebagai cara yang lebih singkat untuk mendefinisikan fungsiPython tidak menganjurkan penggunaan ekspresi lambda yang langsung dipanggil. Itu hanya hasil dari ekspresi lambda yang bisa dipanggil, tidak seperti badan fungsi normal
Fungsi Lambda sering digunakan dengan fungsi tingkat tinggi, yang menggunakan satu atau beberapa fungsi sebagai argumen atau mengembalikan satu atau beberapa fungsi
Fungsi lambda bisa menjadi fungsi tingkat tinggi dengan mengambil fungsi [normal atau lambda] sebagai argumen seperti pada contoh buatan berikut
>>>
>>> lambda x: x
1Python memaparkan fungsi tingkat tinggi sebagai fungsi bawaan atau di pustaka standar. Contohnya termasuk
def add_one[x]:
return x + 1
4, def add_one[x]:
return x + 1
5, >>> _[1, 2]
3
3, serta fungsi utama seperti >>> _[1, 2]
3
4, >>> _[1, 2]
3
5, >>> _[1, 2]
3
6, dan >>> _[1, 2]
3
7. Anda akan menggunakan fungsi lambda bersama dengan fungsi tingkat tinggi Python diHilangkan iklanPython Lambda dan Fungsi Reguler
Kutipan dari FAQ Desain dan Sejarah Python ini tampaknya mengatur nada tentang ekspektasi keseluruhan terkait penggunaan fungsi lambda di Python
Tidak seperti bentuk lambda dalam bahasa lain, di mana mereka menambahkan fungsionalitas, lambda Python hanyalah notasi steno jika Anda terlalu malas untuk mendefinisikan suatu fungsi. []
Namun demikian, jangan biarkan pernyataan ini menghalangi Anda menggunakan
def add_one[x]:
return x + 1
2 Python. Sekilas, Anda mungkin menerima bahwa fungsi lambda adalah fungsi dengan beberapa gula sintaksis yang memperpendek kode untuk mendefinisikan atau memanggil fungsi. Bagian berikut menyoroti kesamaan dan perbedaan kecil antara fungsi Python normal dan fungsi lambdaFungsi
Pada titik ini, Anda mungkin bertanya-tanya apa yang secara mendasar membedakan fungsi lambda yang terikat pada variabel dari fungsi biasa dengan satu baris
>>> _[1, 2]
3
9. di bawah permukaan, hampir tidak ada. Mari kita verifikasi bagaimana Python melihat fungsi yang dibuat dengan pernyataan pengembalian tunggal versus fungsi yang dibuat sebagai ekspresi [def add_one[x]:
return x + 1
2]Modul
>>> lambda x: x
_01 memperlihatkan fungsi untuk menganalisis kode byte Python yang dihasilkan oleh kompiler Python>>>
>>> lambda x: x
2Anda dapat melihat bahwa
>>> lambda x: x
_02 memaparkan versi bytecode Python yang dapat dibaca yang memungkinkan pemeriksaan instruksi tingkat rendah yang akan digunakan juru bahasa Python saat menjalankan programSekarang lihat dengan objek fungsi biasa
>>>
>>> lambda x: x
3Bytecode yang ditafsirkan oleh Python sama untuk kedua fungsi. Tetapi Anda mungkin memperhatikan bahwa penamaannya berbeda. nama fungsi adalah
>>> lambda x: x
_03 untuk fungsi yang didefinisikan dengan def add_one[x]:
return x + 1
8, sedangkan fungsi lambda Python dilihat sebagai def add_one[x]:
return x + 1
2Melacak kembali
Anda melihat di bagian sebelumnya bahwa, dalam konteks fungsi lambda, Python tidak memberikan nama fungsi, tetapi hanya
>>> lambda x: x
06. Ini bisa menjadi batasan untuk dipertimbangkan saat terjadi pengecualian, dan traceback hanya menampilkan >>> lambda x: x
06>>>
>>> lambda x: x
4Pelacakan balik pengecualian yang muncul saat fungsi lambda dijalankan hanya mengidentifikasi fungsi yang menyebabkan pengecualian sebagai
>>> lambda x: x
06Berikut pengecualian yang sama yang diajukan oleh fungsi normal
>>>
>>> lambda x: x
5Fungsi normal menyebabkan kesalahan serupa tetapi menghasilkan traceback yang lebih tepat karena memberikan nama fungsi,
>>> lambda x: x
09Sintaksis
Seperti yang Anda lihat di bagian sebelumnya, bentuk lambda menghadirkan perbedaan sintaksis dari fungsi normal. Secara khusus, fungsi lambda memiliki karakteristik sebagai berikut
- Itu hanya dapat berisi ekspresi dan tidak dapat menyertakan pernyataan di tubuhnya
- Itu ditulis sebagai satu baris eksekusi
- Itu tidak mendukung anotasi jenis
- Itu dapat segera dipanggil [IIFE]
Tidak Ada Pernyataan
Fungsi lambda tidak dapat berisi pernyataan apa pun. Dalam fungsi lambda, pernyataan seperti
>>> _[1, 2]
3
_9, >>> lambda x: x
11, >>> lambda x: x
12, atau >>> lambda x: x
13 akan memunculkan pengecualian >>> lambda x: x
14. Berikut adalah contoh menambahkan >>> lambda x: x
_12 ke badan lambda>>>
>>> lambda x: x
6Contoh yang dibuat-buat ini dimaksudkan untuk
>>> lambda x: x
_12 bahwa parameter >>> full_name = lambda first, last: f'Full name: {first.title[]} {last.title[]}'
>>> full_name['guido', 'van rossum']
'Full name: Guido Van Rossum'
0 memiliki nilai >>> full_name = lambda first, last: f'Full name: {first.title[]} {last.title[]}'
>>> full_name['guido', 'van rossum']
'Full name: Guido Van Rossum'
6. Namun, penerjemah mengidentifikasi >>> lambda x: x
_14 saat mengurai kode yang melibatkan pernyataan >>> lambda x: x
12 di badan def add_one[x]:
return x + 1
2Ekspresi Tunggal
Berbeda dengan fungsi normal, fungsi lambda Python adalah ekspresi tunggal. Meskipun, dalam isi
def add_one[x]:
return x + 1
_2, Anda dapat menyebarkan ekspresi ke beberapa baris menggunakan tanda kurung atau string multibaris, ekspresi tetap menjadi ekspresi tunggal>>>
>>> lambda x: x
7Contoh di atas mengembalikan string
>>> lambda x: x
_23 saat argumen lambda ganjil, dan >>> lambda x: x
24 saat argumen genap. Itu menyebar di dua baris karena terkandung dalam satu set tanda kurung, tetapi tetap satu ekspresiKetik Anotasi
Jika Anda sudah mulai mengadopsi petunjuk tipe, yang sekarang tersedia di Python, maka Anda memiliki alasan bagus lainnya untuk memilih fungsi normal daripada fungsi lambda Python. Lihat untuk mempelajari lebih lanjut tentang petunjuk tipe Python dan pengecekan tipe. Dalam fungsi lambda, tidak ada padanan untuk yang berikut ini
>>> lambda x: x
_8Kesalahan jenis apa pun dengan
>>> lambda x: x
_25 dapat ditangkap oleh alat seperti >>> lambda x: x
26 atau >>> lambda x: x
27, sedangkan >>> lambda x: x
14 dengan fungsi lambda yang setara dimunculkan saat runtime>>>
>>> lambda x: x
9Seperti mencoba memasukkan pernyataan dalam lambda, menambahkan anotasi jenis segera menghasilkan
>>> lambda x: x
14 saat runtimeIIFE
Anda telah melihat beberapa contoh eksekusi fungsi yang langsung dipanggil
>>>
>>> lambda x: x + 1
0Di luar juru bahasa Python, fitur ini mungkin tidak digunakan dalam praktik. Ini adalah konsekuensi langsung dari fungsi lambda yang dapat dipanggil seperti yang didefinisikan. Misalnya, ini memungkinkan Anda meneruskan definisi ekspresi lambda Python ke fungsi tingkat tinggi seperti
def add_one[x]:
return x + 1
4, def add_one[x]:
return x + 1
5, atau >>> _[1, 2]
3
3, atau ke fungsi kunciHilangkan iklanArgumen
Seperti objek fungsi normal yang didefinisikan dengan
def add_one[x]:
return x + 1
_8, ekspresi lambda Python mendukung semua cara berbeda untuk menyampaikan argumen. Ini termasuk- Argumen posisi
- Argumen bernama [terkadang disebut argumen kata kunci]
- Daftar variabel argumen [sering disebut sebagai varargs]
- Daftar variabel argumen kata kunci
- Argumen khusus kata kunci
Contoh berikut mengilustrasikan opsi yang terbuka untuk Anda guna meneruskan argumen ke ekspresi lambda
>>>
>>> lambda x: x + 1
1Dekorator
Di Python, dekorator adalah implementasi dari pola yang memungkinkan penambahan perilaku ke fungsi atau kelas. Biasanya diekspresikan dengan sintaks
>>> lambda x: x
_34 yang mengawali sebuah fungsi. Ini contoh yang dibuat-buat>>> lambda x: x + 1
2Pada contoh di atas,
>>> lambda x: x
35 adalah fungsi yang menambahkan perilaku ke >>> lambda x: x
36, sehingga memanggil >>> lambda x: x
37 menghasilkan keluaran berikut>>> lambda x: x + 1
_3>>> lambda x: x
_36 hanya mencetak >>> lambda x: x
39, tetapi dekorator menambahkan perilaku tambahan yang juga mencetak >>> lambda x: x
40Dekorator dapat diterapkan ke lambda. Meskipun tidak mungkin untuk menghias lambda dengan sintaks
>>> lambda x: x
34, dekorator hanyalah sebuah fungsi, sehingga dapat memanggil fungsi lambda>>> lambda x: x + 1
4>>> lambda x: x
_42, dihiasi dengan >>> lambda x: x
43 pada baris 11, dipanggil dengan argumen >>> lambda x, y: x + y
8 pada baris 15. Sebaliknya, pada baris 18, fungsi lambda segera dilibatkan dan disematkan dalam panggilan ke >>> lambda x: x
45, dekorator. Ketika Anda menjalankan kode di atas, Anda mendapatkan yang berikut ini>>> lambda x: x + 1
5Lihat bagaimana, seperti yang telah Anda lihat, nama fungsi lambda muncul sebagai
>>> lambda x: x
06, sedangkan >>> lambda x: x
47 diidentifikasi dengan jelas untuk fungsi normalMendekorasi fungsi lambda dengan cara ini dapat berguna untuk tujuan debug, mungkin untuk men-debug perilaku fungsi lambda yang digunakan dalam konteks fungsi tingkat tinggi atau fungsi kunci. Mari kita lihat contoh dengan
def add_one[x]:
return x + 1
4>>> lambda x: x + 1
6Argumen pertama dari
def add_one[x]:
return x + 1
4 adalah lambda yang mengalikan argumennya dengan >>> full_name = lambda first, last: f'Full name: {first.title[]} {last.title[]}'
>>> full_name['guido', 'van rossum']
'Full name: Guido Van Rossum'
6. Lambda ini dihiasi dengan >>> lambda x: x
_45. Saat dieksekusi, contoh di atas menghasilkan yang berikut ini>>> lambda x: x + 1
7Hasilnya
>>> lambda x: x
_52 adalah daftar yang diperoleh dari mengalikan setiap elemen dari >>> lambda x: x
53. Untuk saat ini, pertimbangkan >>> lambda x: x
_53 setara dengan daftar >>> lambda x: x
55Anda akan melihat
def add_one[x]:
return x + 1
_4 secara lebih rinci diLambda juga bisa menjadi dekorator, tetapi tidak disarankan. Jika Anda merasa perlu melakukan ini, konsultasikan
Untuk informasi lebih lanjut tentang dekorator Python, lihat Primer tentang Dekorator Python
Hilangkan iklanPenutup
Penutupan adalah fungsi di mana setiap variabel bebas, semuanya kecuali parameter, yang digunakan dalam fungsi itu terikat pada nilai tertentu yang ditentukan dalam lingkup terlampir dari fungsi itu. Akibatnya, penutupan menentukan lingkungan di mana mereka berjalan, dan dapat dipanggil dari mana saja
Konsep lambda dan closure tidak harus terkait, meskipun fungsi lambda bisa menjadi closure dengan cara yang sama seperti fungsi normal juga bisa menjadi closure. Beberapa bahasa memiliki konstruksi khusus untuk penutupan atau lambda [misalnya, Groovy dengan blok kode anonim sebagai objek Penutupan], atau ekspresi lambda [misalnya, ekspresi Java Lambda dengan opsi terbatas untuk penutupan]
Inilah penutupan yang dibangun dengan fungsi Python normal
>>> lambda x: x + 1
8>>> lambda x: x
_57 mengembalikan >>> lambda x: x
58, fungsi bersarang yang menghitung jumlah dari tiga argumen
_0 diteruskan sebagai argumen ke>>> full_name = lambda first, last: f'Full name: {first.title[]} {last.title[]}' >>> full_name['guido', 'van rossum'] 'Full name: Guido Van Rossum'
57>>> lambda x: x
_61 adalah variabel lokal untuk>>> lambda x: x
57>>> lambda x: x
_63 adalah argumen yang diteruskan ke>>> lambda x: x
58>>> lambda x: x
Untuk menguji perilaku
>>> lambda x: x
_57 dan >>> lambda x: x
58, >>> lambda x: x
57 dipanggil tiga kali dalam >>> lambda x: x
68 loop yang mencetak berikut ini>>> lambda x: x + 1
_9Pada baris 9 kode,
>>> lambda x: x
_58 dikembalikan dengan permintaan >>> lambda x: x
57 terikat dengan nama >>> lambda x: x
71. Pada baris 5, >>> lambda x: x
_58 menangkap >>> full_name = lambda first, last: f'Full name: {first.title[]} {last.title[]}'
>>> full_name['guido', 'van rossum']
'Full name: Guido Van Rossum'
0 dan >>> lambda x: x
61 karena ia memiliki akses ke lingkungan embeddingnya, sedemikian rupa sehingga setelah pemanggilan penutupan, ia dapat beroperasi pada dua variabel bebas >>> full_name = lambda first, last: f'Full name: {first.title[]} {last.title[]}'
>>> full_name['guido', 'van rossum']
'Full name: Guido Van Rossum'
0 dan >>> lambda x: x
61Demikian pula,
def add_one[x]:
return x + 1
2 juga bisa menjadi penutup. Ini contoh yang sama dengan fungsi lambda Python>>> [lambda x: x + 1][2]
3
_0Ketika Anda mengeksekusi kode di atas, Anda mendapatkan output berikut
>>> [lambda x: x + 1][2]
3
_1Pada baris 6,
>>> lambda x: x
_57 mengembalikan lambda dan menugaskannya ke variabel >>> lambda x: x
71. Pada baris 3, isi fungsi lambda mereferensikan >>> full_name = lambda first, last: f'Full name: {first.title[]} {last.title[]}'
>>> full_name['guido', 'van rossum']
'Full name: Guido Van Rossum'
0 dan >>> lambda x: x
61. Variabel >>> lambda x: x
_61 tersedia pada waktu definisi, sedangkan >>> full_name = lambda first, last: f'Full name: {first.title[]} {last.title[]}'
>>> full_name['guido', 'van rossum']
'Full name: Guido Van Rossum'
0 didefinisikan pada waktu proses ketika >>> lambda x: x
57 dipanggilDalam situasi ini, baik fungsi normal maupun lambda berperilaku serupa. Di bagian selanjutnya, Anda akan melihat situasi di mana perilaku lambda dapat menipu karena waktu evaluasinya [waktu definisi vs waktu proses]
Waktu Evaluasi
Dalam beberapa situasi yang melibatkan perulangan, perilaku fungsi lambda Python sebagai penutup mungkin berlawanan dengan intuisi. Ini membutuhkan pemahaman ketika variabel bebas terikat dalam konteks lambda. Contoh berikut menunjukkan perbedaan saat menggunakan fungsi biasa vs menggunakan lambda Python
Uji skenario terlebih dahulu menggunakan fungsi reguler
>>>
>>> [lambda x: x + 1][2]
3
2Dalam fungsi normal,
>>> lambda x: x
85 dievaluasi pada waktu definisi, pada baris 9, saat fungsi ditambahkan ke daftar. >>> lambda x: x
_86Sekarang, dengan penerapan logika yang sama dengan fungsi lambda, amati perilaku yang tidak terduga
>>>
>>> [lambda x: x + 1][2]
3
3Hasil tak terduga terjadi karena variabel bebas
>>> lambda x: x
85, seperti yang diterapkan, terikat pada waktu eksekusi ekspresi lambda. Fungsi lambda Python pada baris 4 adalah penutupan yang menangkap >>> lambda x: x
85, variabel bebas terikat saat runtime. Saat runtime, saat menjalankan fungsi >>> lambda x: x
89 pada baris 7, nilai >>> lambda x: x
85 adalah >>> lambda x: x
91Untuk mengatasi masalah ini, Anda dapat menetapkan variabel bebas pada waktu definisi sebagai berikut
>>>
>>> [lambda x: x + 1][2]
3
4Fungsi lambda Python berperilaku seperti fungsi normal sehubungan dengan argumen. Oleh karena itu, parameter lambda dapat diinisialisasi dengan nilai default. parameter
>>> lambda x: x
_85 mengambil >>> lambda x: x
85 luar sebagai nilai default. Fungsi lambda Python dapat ditulis sebagai >>> lambda x: x
94 dan memiliki hasil yang samaFungsi lambda Python dipanggil tanpa argumen apa pun pada baris 7, dan menggunakan nilai default
>>> lambda x: x
85 yang ditetapkan pada waktu definisiHilangkan iklanMenguji Lambda
Python lambda dapat diuji dengan cara yang mirip dengan fungsi biasa. Anda dapat menggunakan
>>> lambda x: x
_96 dan >>> lambda x: x
97>>> lambda x: x
_96Modul
>>> lambda x: x
_96 menangani fungsi lambda Python mirip dengan fungsi biasa>>> [lambda x: x + 1][2]
3
_5>>> lambda x: x + 1
00 mendefinisikan kasus pengujian dengan tiga metode pengujian, masing-masing menggunakan skenario pengujian untuk >>> lambda x: x + 1
01 diimplementasikan sebagai fungsi lambda. Eksekusi file Python >>> lambda x: x + 1
_02 yang berisi >>> lambda x: x + 1
00 menghasilkan yang berikut>>> [lambda x: x + 1][2]
3
_6Seperti yang diharapkan, kami memiliki dua kasus uji yang berhasil dan satu kegagalan untuk
>>> lambda x: x + 1
04. hasilnya adalah >>> lambda x, y: x + y
_9, tetapi hasil yang diharapkan adalah >>> lambda x: x + 1
06. Kegagalan ini disebabkan oleh kesalahan yang disengaja dalam kasus uji. Mengubah hasil yang diharapkan dari >>> lambda x: x + 1
_06 menjadi >>> lambda x, y: x + y
9 akan memenuhi semua tes untuk >>> lambda x: x + 1
00>>> lambda x: x
_97Modul
>>> lambda x: x
_97 mengekstraksi kode Python interaktif dari >>> lambda x: x + 1
12 untuk menjalankan tes. Meskipun sintaks fungsi lambda Python tidak mendukung >>> lambda x: x + 1
12 tipikal, dimungkinkan untuk menetapkan string ke elemen >>> lambda x: x + 1
14 dari lambda bernama>>> [lambda x: x + 1][2]
3
_7>>> lambda x: x
_97 dalam komentar dokumen lambda >>> lambda x: x + 1
01 menjelaskan kasus uji yang sama seperti di bagian sebelumnyaSaat Anda menjalankan tes melalui
>>> lambda x: x + 1
_17, Anda mendapatkan yang berikut ini>>> [lambda x: x + 1][2]
3
_8Hasil pengujian yang gagal dari kegagalan yang sama dijelaskan dalam pelaksanaan pengujian unit di bagian sebelumnya
Anda dapat menambahkan
>>> lambda x: x + 1
_12 ke lambda Python melalui penugasan ke >>> lambda x: x + 1
14 untuk mendokumentasikan fungsi lambda. Meskipun memungkinkan, sintaks Python lebih baik mengakomodasi >>> lambda x: x + 1
12 untuk fungsi normal daripada fungsi lambdaUntuk ikhtisar komprehensif pengujian unit dengan Python, Anda mungkin ingin merujuk ke Memulai Pengujian dengan Python
Penyalahgunaan Ekspresi Lambda
Beberapa contoh dalam artikel ini, jika ditulis dalam konteks kode Python profesional, akan memenuhi syarat sebagai penyalahgunaan
Jika Anda menemukan diri Anda mencoba mengatasi sesuatu yang tidak didukung oleh ekspresi lambda, ini mungkin merupakan tanda bahwa fungsi normal akan lebih cocok.
>>> lambda x: x + 1
_12 untuk ekspresi lambda di bagian sebelumnya adalah contoh yang bagus. Mencoba mengatasi fakta bahwa fungsi lambda Python tidak mendukung pernyataan adalah tanda bahaya lainnyaBagian selanjutnya mengilustrasikan beberapa contoh penggunaan lambda yang harus dihindari. Contoh-contoh itu mungkin situasi di mana, dalam konteks Python lambda, kode menunjukkan pola berikut
- Itu tidak mengikuti panduan gaya Python [PEP 8]
- Ini rumit dan sulit untuk dibaca
- Itu tidak perlu pintar dengan mengorbankan keterbacaan yang sulit
Meningkatkan Pengecualian
Mencoba memunculkan pengecualian dalam Python lambda seharusnya membuat Anda berpikir dua kali. Ada beberapa cara cerdas untuk melakukannya, tetapi bahkan hal seperti berikut ini sebaiknya dihindari
>>>
>>> [lambda x: x + 1][2]
3
9Karena sebuah pernyataan tidak benar secara sintaksis dalam tubuh lambda Python, solusi pada contoh di atas terdiri dari mengabstraksi panggilan pernyataan dengan fungsi khusus
>>> lambda x: x + 1
22. Menggunakan jenis solusi ini harus dihindari. Jika Anda menemukan jenis kode ini, Anda harus mempertimbangkan untuk memfaktorkan ulang kode untuk menggunakan fungsi biasaGaya samar
Seperti dalam bahasa pemrograman apa pun, Anda akan menemukan kode Python yang sulit dibaca karena gaya yang digunakan. Fungsi Lambda, karena keringkasannya, dapat mendukung penulisan kode yang sulit dibaca
Contoh lambda berikut berisi beberapa pilihan gaya yang buruk
>>>
[lambda x: x + 1][2] = lambda 2: 2 + 1
= 2 + 1
= 3
0Garis bawah [
>>> lambda x, y: x + y
3] mengacu pada variabel yang tidak perlu Anda rujuk secara eksplisit. Namun dalam contoh ini, tiga >>> lambda x, y: x + y
_3 mengacu pada variabel yang berbeda. Pembaruan awal untuk kode lambda ini bisa berupa nama variabel>>>
[lambda x: x + 1][2] = lambda 2: 2 + 1
= 2 + 1
= 3
1Memang, masih sulit untuk dibaca. Dengan tetap memanfaatkan
def add_one[x]:
return x + 1
_2, fungsi reguler akan membuat kode ini lebih mudah dibaca, menyebarkan logika ke beberapa baris dan pemanggilan fungsi>>>
[lambda x: x + 1][2] = lambda 2: 2 + 1
= 2 + 1
= 3
2Ini masih belum optimal tetapi menunjukkan kepada Anda kemungkinan jalur untuk membuat kode, dan fungsi lambda Python khususnya, lebih mudah dibaca. Di , Anda akan belajar mengganti
def add_one[x]:
return x + 1
4 dan def add_one[x]:
return x + 1
2 dengan pemahaman daftar atau ekspresi generator. Ini secara drastis akan meningkatkan keterbacaan kodeKelas Python
Anda bisa tetapi tidak boleh menulis metode kelas sebagai fungsi lambda Python. Contoh berikut adalah kode Python yang benar-benar legal tetapi memperlihatkan kode Python yang tidak konvensional yang mengandalkan
def add_one[x]:
return x + 1
2. Misalnya, alih-alih mengimplementasikan >>> lambda x: x + 1
_29 sebagai fungsi biasa, ia menggunakan def add_one[x]:
return x + 1
2. Demikian pula, >>> lambda x: x + 1
31 dan >>> lambda x: x + 1
32 juga diimplementasikan dengan fungsi lambda, bukan fungsi biasa atau dekorator[lambda x: x + 1][2] = lambda 2: 2 + 1
= 2 + 1
= 3
_3Menjalankan alat seperti
>>> lambda x: x + 1
33, alat penerapan panduan gaya, akan menampilkan kesalahan berikut untuk >>> lambda x: x + 1
29 dan >>> lambda x: x + 1
35[lambda x: x + 1][2] = lambda 2: 2 + 1
= 2 + 1
= 3
_4Meskipun
>>> lambda x: x + 1
_33 tidak menunjukkan masalah penggunaan fungsi lambda Python di properti, mereka sulit dibaca dan rentan terhadap kesalahan karena penggunaan banyak string seperti >>> lambda x: x + 1
37 dan >>> lambda x: x + 1
38Implementasi yang tepat dari
>>> lambda x: x + 1
_29 diharapkan sebagai berikut[lambda x: x + 1][2] = lambda 2: 2 + 1
= 2 + 1
= 3
_5>>> lambda x: x + 1
31 akan ditulis sebagai berikut[lambda x: x + 1][2] = lambda 2: 2 + 1
= 2 + 1
= 3
_6Sebagai aturan umum, dalam konteks kode yang ditulis dengan Python, lebih suka fungsi reguler daripada ekspresi lambda. Meskipun demikian, ada beberapa kasus yang mendapat manfaat dari sintaks lambda, seperti yang akan Anda lihat di bagian selanjutnya
Hilangkan iklanPenggunaan Ekspresi Lambda yang Tepat
Lambdas dengan Python cenderung menjadi subyek kontroversi. Beberapa argumen yang menentang lambda di Python adalah
- Masalah dengan keterbacaan
- Pengenaan cara berpikir fungsional
- Sintaks yang berat dengan kata kunci
2def add_one[x]: return x + 1
Terlepas dari perdebatan sengit yang mempertanyakan keberadaan fitur ini di Python, fungsi lambda memiliki properti yang terkadang memberikan nilai pada bahasa Python dan pengembang
Contoh berikut mengilustrasikan skenario di mana penggunaan fungsi lambda tidak hanya cocok tetapi juga dianjurkan dalam kode Python
Konstruksi Fungsional Klasik
Fungsi Lambda biasanya digunakan dengan fungsi bawaan dan , serta , diekspos dalam modul
>>> lambda x: x + 1
45. Tiga contoh berikut adalah masing-masing ilustrasi penggunaan fungsi tersebut dengan ekspresi lambda sebagai pengiring>>>
[lambda x: x + 1][2] = lambda 2: 2 + 1
= 2 + 1
= 3
7Anda mungkin harus membaca kode yang mirip dengan contoh di atas, meskipun dengan data yang lebih relevan. Oleh karena itu, penting untuk mengenali konstruksi tersebut. Namun demikian, konstruksi tersebut memiliki alternatif setara yang dianggap lebih Pythonic. Di , Anda akan mempelajari cara mengonversi fungsi tingkat tinggi dan lambda yang menyertainya ke dalam bentuk lain yang lebih idiomatis
Fungsi utama
Fungsi kunci di Python adalah fungsi tingkat tinggi yang menggunakan parameter
>>> lambda x: x + 1
46 sebagai argumen bernama. >>> lambda x: x + 1
46 menerima fungsi yang dapat berupa def add_one[x]:
return x + 1
2. Fungsi ini secara langsung memengaruhi algoritme yang didorong oleh fungsi kunci itu sendiri. Berikut adalah beberapa fungsi utama
4. metode daftar>>> _[1, 2] 3
5,>>> _[1, 2] 3
6,>>> _[1, 2] 3
7. fungsi bawaan>>> _[1, 2] 3
53 dan>>> lambda x: x + 1
54. dalam modul algoritma antrian Heap>>> lambda x: x + 1
55>>> lambda x: x + 1
Bayangkan Anda ingin mengurutkan daftar ID yang direpresentasikan sebagai string. Setiap ID adalah gabungan dari string
>>> lambda x: x + 1
56 dan nomor. Menyortir daftar ini dengan fungsi bawaan >>> _[1, 2]
3
5, secara default, menggunakan urutan leksikografis karena elemen dalam daftar adalah stringUntuk memengaruhi eksekusi pengurutan, Anda dapat menetapkan lambda ke argumen bernama
>>> lambda x: x + 1
46, sehingga pengurutan akan menggunakan nomor yang terkait dengan ID>>> ________19______8
Kerangka UI
Kerangka kerja UI seperti Tkinter, wxPython, atau. .NET Windows Forms dengan IronPython memanfaatkan fungsi lambda untuk tindakan pemetaan sebagai respons terhadap peristiwa UI
Program Tkinter yang naif di bawah ini menunjukkan penggunaan
def add_one[x]:
return x + 1
2 yang ditugaskan ke perintah tombol Reverse[lambda x: x + 1][2] = lambda 2: 2 + 1
= 2 + 1
= 3
_9Mengklik tombol Membalikkan mengaktifkan peristiwa yang memicu fungsi lambda, mengubah label dari Kalkulus Lambda menjadi suluclaC adbmaL*
Baik wxPython dan IronPython di. Platform .NET berbagi pendekatan serupa untuk menangani acara. Perhatikan bahwa
def add_one[x]:
return x + 1
_2 adalah salah satu cara untuk menangani peristiwa pengaktifan, tetapi suatu fungsi dapat digunakan untuk tujuan yang sama. Itu akhirnya menjadi mandiri dan kurang bertele-tele untuk menggunakan def add_one[x]:
return x + 1
2 ketika jumlah kode yang dibutuhkan sangat singkatUntuk menjelajahi wxPython, lihat Cara Membangun Aplikasi GUI Python Dengan wxPython
Hilangkan iklanPenerjemah Python
Saat Anda bermain dengan kode Python di interpreter interaktif, fungsi lambda Python seringkali merupakan berkah. Sangat mudah untuk membuat fungsi one-liner cepat untuk menjelajahi beberapa potongan kode yang tidak akan pernah terungkap di luar penerjemah. Lambda yang tertulis di penerjemah, demi penemuan yang cepat, seperti kertas bekas yang dapat Anda buang setelah digunakan
>>> lambda x: x + 1
_62
>>> lambda x: x + 1
Dalam semangat yang sama seperti percobaan dalam juru bahasa Python, modul
>>> lambda x: x + 1
62 menyediakan fungsi untuk mengatur waktu fragmen kode kecil. >>> lambda x: x + 1
64 khususnya dapat dipanggil secara langsung, meneruskan beberapa kode Python dalam sebuah string. Ini sebuah contoh>>>
>>> add_one = lambda x: x + 1
>>> add_one[2]
3
0Saat pernyataan diteruskan sebagai string,
>>> lambda x: x + 1
65 membutuhkan konteks lengkap. Dalam contoh di atas, ini disediakan oleh argumen kedua yang mengatur lingkungan yang dibutuhkan oleh fungsi utama untuk diatur waktunya. Tidak melakukannya akan memunculkan pengecualian >>> lambda x: x + 1
_66Pendekatan lain adalah dengan menggunakan
def add_one[x]:
return x + 1
2>>>
>>> add_one = lambda x: x + 1
>>> add_one[2]
3
1Solusi ini lebih bersih, lebih mudah dibaca, dan lebih cepat mengetikkan juru bahasa. Meskipun waktu eksekusi sedikit lebih singkat untuk versi
def add_one[x]:
return x + 1
2, menjalankan kembali fungsi mungkin menunjukkan sedikit keuntungan untuk versi >>> lambda x: x + 1
69. Waktu eksekusi >>> lambda x: x + 1
_70 dikecualikan dari keseluruhan waktu eksekusi dan tidak akan berdampak pada hasilMenambal Monyet
Untuk pengujian, terkadang perlu bergantung pada hasil yang dapat diulang, meskipun selama eksekusi normal perangkat lunak tertentu, hasil yang sesuai diharapkan berbeda, atau bahkan benar-benar acak
Katakanlah Anda ingin menguji fungsi yang, saat runtime, menangani nilai acak. Namun, selama eksekusi pengujian, Anda perlu menegaskan terhadap nilai yang dapat diprediksi secara berulang. Contoh berikut menunjukkan bagaimana, dengan fungsi
def add_one[x]:
return x + 1
2, patch monyet dapat membantu Anda>>> add_one = lambda x: x + 1
>>> add_one[2]
3
2Manajer konteks membantu mengisolasi operasi monyet menambal fungsi dari perpustakaan standar [, dalam contoh ini]. Fungsi lambda yang ditetapkan ke
>>> lambda x: x + 1
_73 menggantikan perilaku default dengan mengembalikan nilai statisIni memungkinkan pengujian fungsi apa pun yang bergantung pada
>>> lambda x: x + 1
_74 dengan cara yang dapat diprediksi. Sebelum keluar dari manajer konteks, perilaku default >>> lambda x: x + 1
74 dibangun kembali untuk menghilangkan efek samping tak terduga yang akan memengaruhi area pengujian lainnya yang mungkin bergantung pada perilaku default >>> lambda x: x + 1
74Kerangka pengujian unit seperti
>>> lambda x: x
_96 dan >>> lambda x: x + 1
78 membawa konsep ini ke tingkat kecanggihan yang lebih tinggiDengan
>>> lambda x: x + 1
_78, masih menggunakan fungsi def add_one[x]:
return x + 1
2, contoh yang sama menjadi lebih elegan dan ringkas>>> add_one = lambda x: x + 1
>>> add_one[2]
3
3Dengan perlengkapan
>>> lambda x: x + 1
_81 pytest, >>> lambda x: x + 1
73 ditimpa dengan lambda yang akan mengembalikan nilai deterministik, >>> lambda x: x + 1
83, memungkinkan untuk memvalidasi tes. Fixture >>> lambda x: x + 1
81 pytest memungkinkan Anda untuk mengontrol ruang lingkup penggantian. Dalam contoh di atas, memanggil >>> lambda x: x + 1
73 dalam pengujian berikutnya, tanpa menggunakan patching monyet, akan menjalankan implementasi normal dari fungsi iniMenjalankan tes
>>> lambda x: x + 1
_78 memberikan hasil sebagai berikut>>> add_one = lambda x: x + 1
>>> add_one[2]
3
4Tes lulus saat kami memvalidasi bahwa
>>> lambda x: x + 1
87 dilakukan, dan hasilnya adalah yang diharapkan dalam konteks tesHilangkan iklanAlternatif untuk Lambdas
Meskipun ada alasan bagus untuk menggunakan
def add_one[x]:
return x + 1
2, ada beberapa kasus di mana penggunaannya tidak disukai. Jadi apa saja alternatifnya?Fungsi tingkat tinggi seperti
def add_one[x]:
return x + 1
4, def add_one[x]:
return x + 1
5, dan >>> _[1, 2]
3
3 dapat diubah menjadi bentuk yang lebih elegan dengan sedikit sentuhan kreativitas, khususnya dengan pemahaman daftar atau ekspresi generatorUntuk mempelajari lebih lanjut tentang pemahaman daftar, lihat Kapan Menggunakan Pemahaman Daftar dengan Python. Untuk mempelajari lebih lanjut tentang ekspresi generator, lihat Cara Menggunakan Generator dan menghasilkan dengan Python
Peta
Fungsi bawaan
def add_one[x]:
return x + 1
4 mengambil fungsi sebagai argumen pertama dan menerapkannya ke setiap elemen argumen kedua, sebuah iterable. Contoh iterables adalah string, list, dan tuple. Untuk informasi lebih lanjut tentang iterables dan iterator, lihat Iterables dan Iteratorsdef add_one[x]:
return x + 1
4 mengembalikan iterator yang sesuai dengan koleksi yang diubah. Sebagai contoh, jika Anda ingin mengubah daftar string menjadi daftar baru dengan setiap string dikapitalisasi, Anda dapat menggunakan def add_one[x]:
return x + 1
4, sebagai berikut>>>
>>> add_one = lambda x: x + 1
>>> add_one[2]
3
5Anda perlu memanggil
>>> lambda x: x + 1
_95 untuk mengonversi iterator yang dikembalikan oleh def add_one[x]:
return x + 1
4 menjadi daftar yang diperluas yang dapat ditampilkan di juru bahasa Shell PythonMenggunakan pemahaman daftar menghilangkan kebutuhan untuk mendefinisikan dan menjalankan fungsi lambda
>>>
>>> add_one = lambda x: x + 1
>>> add_one[2]
3
6Saring
Fungsi bawaan
def add_one[x]:
return x + 1
5, konstruksi fungsional klasik lainnya, dapat diubah menjadi pemahaman daftar. Dibutuhkan predikat sebagai argumen pertama dan iterable sebagai argumen kedua. Itu membangun iterator yang berisi semua elemen koleksi awal yang memenuhi fungsi predikat. Berikut adalah contoh yang memfilter semua bilangan genap dalam daftar bilangan bulat tertentu>>> ________20______7
Perhatikan bahwa
def add_one[x]:
return x + 1
_5 mengembalikan iterator, oleh karena itu kebutuhan untuk memanggil tipe bawaan >>> lambda x: x + 1
99 yang membuat daftar dengan iteratorImplementasi yang memanfaatkan konstruksi pemahaman daftar memberikan yang berikut ini
>>> ________20______8
Mengurangi
Sejak Python 3,
def add_one[x]:
return x + 1
_6 telah berubah dari fungsi bawaan menjadi fungsi modul >>> lambda x: x + 1
45. Sebagai def add_one[x]:
return x + 1
4 dan def add_one[x]:
return x + 1
5, dua argumen pertamanya masing-masing adalah fungsi dan iterable. Ini juga dapat mengambil penginisialisasi sebagai argumen ketiga yang digunakan sebagai nilai awal dari akumulator yang dihasilkan. Untuk setiap elemen iterable, def add_one[x]:
return x + 1
6 menerapkan fungsi dan mengakumulasi hasil yang dikembalikan saat iterable habisUntuk menerapkan
def add_one[x]:
return x + 1
_6 ke daftar pasangan dan menghitung jumlah item pertama dari setiap pasangan, Anda dapat menulis ini>>> ________20______9
Pendekatan yang lebih idiomatis menggunakan ekspresi generator, sebagai argumen untuk
>>> [lambda x: x + 1][2]
3
06 dalam contoh, adalah sebagai berikut>>>
def add_one[x]:
return x + 1
0Solusi yang sedikit berbeda dan mungkin lebih bersih menghilangkan kebutuhan untuk mengakses elemen pertama dari pasangan secara eksplisit dan sebagai gantinya menggunakan pembongkaran
>>>
def add_one[x]:
return x + 1
1Penggunaan garis bawah [
>>> lambda x, y: x + y
_3] adalah konvensi Python yang menunjukkan bahwa Anda dapat mengabaikan nilai kedua dari pasangan>>> [lambda x: x + 1][2]
3
_06 mengambil argumen unik, sehingga ekspresi generator tidak perlu dalam tanda kurungApakah Lambdas Pythonic atau Tidak?
PEP 8, yang merupakan panduan gaya untuk kode Python, berbunyi
Selalu gunakan pernyataan def alih-alih pernyataan penugasan yang mengikat ekspresi lambda langsung ke pengidentifikasi. []
Ini sangat tidak menyarankan penggunaan lambda yang terikat pada pengenal, terutama di mana fungsi harus digunakan dan memiliki lebih banyak manfaat. PEP 8 tidak menyebutkan penggunaan lain dari
def add_one[x]:
return x + 1
2. Seperti yang telah Anda lihat di bagian sebelumnya, fungsi lambda mungkin memiliki kegunaan yang baik, meskipun terbatasCara yang mungkin untuk menjawab pertanyaan adalah bahwa fungsi lambda sempurna Pythonic jika tidak ada lagi Pythonic yang tersedia. Saya menghindari mendefinisikan apa arti "Pythonic", memberi Anda definisi yang paling sesuai dengan pola pikir Anda, serta gaya pengkodean pribadi atau tim Anda
Di luar cakupan sempit Python
def add_one[x]:
return x + 1
_2, Cara Menulis Kode Python yang Indah Dengan PEP 8 adalah sumber yang bagus yang mungkin ingin Anda periksa mengenai gaya kode di PythonKesimpulan
Anda sekarang tahu cara menggunakan fungsi
def add_one[x]:
return x + 1
2 Python dan bisa- Tulis lambda Python dan gunakan fungsi anonim
- Pilih dengan bijak antara lambda atau fungsi Python normal
- Hindari penggunaan lambda yang berlebihan
- Gunakan lambda dengan fungsi tingkat tinggi atau fungsi kunci Python
Jika Anda menyukai matematika, Anda mungkin bersenang-senang menjelajahi dunia kalkulus lambda yang menakjubkan
Lambda python seperti garam. Sedikit spam, ham, dan telur Anda akan meningkatkan rasa, tetapi terlalu banyak akan merusak hidangan
Ikuti Kuis. Uji pengetahuan Anda dengan kuis "Fungsi Python Lambda" interaktif kami. Setelah selesai Anda akan menerima skor sehingga Anda dapat melacak kemajuan belajar Anda dari waktu ke waktu
Ikuti Kuis »
Catatan. Bahasa pemrograman Python, dinamai Monty Python, lebih suka menggunakan
>>> [lambda x: x + 1][2]
3
12, >>> [lambda x: x + 1][2]
3
13, dan >>> [lambda x: x + 1][2]
3
14 sebagai variabel metasyntactic, bukan >>> [lambda x: x + 1][2]
3
15 tradisional, >>> [lambda x: x + 1][2]
3
16, dan >>> [lambda x: x + 1][2]
3
17Tandai sebagai Selesai
Tonton Sekarang Tutorial ini memiliki kursus video terkait yang dibuat oleh tim Real Python. Tonton bersama dengan tutorial tertulis untuk memperdalam pemahaman Anda. Cara Menggunakan Fungsi Python Lambda
🐍 Trik Python 💌
Dapatkan Trik Python singkat & manis yang dikirim ke kotak masuk Anda setiap beberapa hari. Tidak pernah ada spam. Berhenti berlangganan kapan saja. Dikuratori oleh tim Real Python
Kirimi Saya Trik Python »
Tentang Andre Burgaud
Andre adalah seorang insinyur perangkat lunak berpengalaman yang bersemangat tentang teknologi dan bahasa pemrograman, khususnya, Python
» Lebih lanjut tentang AndreSetiap tutorial di Real Python dibuat oleh tim pengembang sehingga memenuhi standar kualitas tinggi kami. Anggota tim yang mengerjakan tutorial ini adalah
Aldren
Jon
Joanna
Master Keterampilan Python Dunia Nyata Dengan Akses Tanpa Batas ke Python Nyata
Bergabunglah dengan kami dan dapatkan akses ke ribuan tutorial, kursus video langsung, dan komunitas pakar Pythonista
Tingkatkan Keterampilan Python Anda »
Guru Keterampilan Python Dunia Nyata
Dengan Akses Tak Terbatas ke Real Python
Bergabunglah dengan kami dan dapatkan akses ke ribuan tutorial, kursus video langsung, dan komunitas ahli Pythonista
Tingkatkan Keterampilan Python Anda »
Bagaimana menurutmu?
Nilai artikel ini
Tweet Bagikan Bagikan EmailApa takeaway # 1 Anda atau hal favorit yang Anda pelajari?
Kiat Berkomentar. Komentar yang paling berguna adalah yang ditulis dengan tujuan belajar dari atau membantu siswa lain. dan dapatkan jawaban atas pertanyaan umum di portal dukungan kami