Apa manfaat lambda di python?

Sejarah

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

def add_one(x):
    return x + 1

def add_one(x):
    return x + 1

def add_one(x):
    return x + 1

Contoh 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

>>>

>>> def identity(x):
..     return x

def add_one(x):
    return x + 1

>>> full_name = lambda first, last: f'Full name: {first.title()} {last.title()}'
>>> full_name('guido', 'van rossum')
'Full name: Guido Van Rossum'

Sebaliknya, jika Anda menggunakan konstruksi lambda Python, Anda akan mendapatkan yang berikut

>>>

>>> lambda x: x

Dalam contoh di atas, ekspresi terdiri dari

• Kata kunci.

  def add_one(x):
      return x + 1
  

  _2
• 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
• Sebuah tubuh.

  >>> full_name = lambda first, last: f'Full name: {first.title()} {last.title()}'
  >>> full_name('guido', 'van rossum')
  'Full name: Guido Van Rossum'
  

  _0

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'

>>>

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

>>> full_name = lambda first, last: f'Full name: {first.title()} {last.title()}'
>>> full_name('guido', 'van rossum')
'Full name: Guido Van Rossum'

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

>>>

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

>>> full_name = lambda first, last: f'Full name: {first.title()} {last.title()}'
>>> full_name('guido', 'van rossum')
'Full name: Guido Van Rossum'

>>> lambda x, y: x + y

Fungsi

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

def add_one(x):
    return x + 1

Modul

>>> lambda x: x

>>>

>>> lambda x: x

Anda dapat melihat bahwa

>>> lambda x: x

Sekarang lihat dengan objek fungsi biasa

>>>

>>> lambda x: x

Bytecode yang ditafsirkan oleh Python sama untuk kedua fungsi. Tetapi Anda mungkin memperhatikan bahwa penamaannya berbeda. nama fungsi adalah

>>> lambda x: x

def add_one(x):
    return x + 1

def add_one(x):
    return x + 1

Melacak kembali

Anda melihat di bagian sebelumnya bahwa, dalam konteks fungsi lambda, Python tidak memberikan nama fungsi, tetapi hanya

>>> lambda x: x

>>> lambda x: x

>>>

>>> lambda x: x

Pelacakan balik pengecualian yang muncul saat fungsi lambda dijalankan hanya mengidentifikasi fungsi yang menyebabkan pengecualian sebagai

>>> lambda x: x

Berikut pengecualian yang sama yang diajukan oleh fungsi normal

>>>

>>> lambda x: x

Fungsi normal menyebabkan kesalahan serupa tetapi menghasilkan traceback yang lebih tepat karena memberikan nama fungsi,

>>> lambda x: x

Sintaksis

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

>>> lambda x: x

>>> lambda x: x

>>> lambda x: x

>>> lambda x: x

>>> lambda x: x

>>>

>>> lambda x: x

Contoh yang dibuat-buat ini dimaksudkan untuk

>>> lambda x: x

>>> full_name = lambda first, last: f'Full name: {first.title()} {last.title()}'
>>> full_name('guido', 'van rossum')
'Full name: Guido Van Rossum'

>>> full_name = lambda first, last: f'Full name: {first.title()} {last.title()}'
>>> full_name('guido', 'van rossum')
'Full name: Guido Van Rossum'

>>> lambda x: x

>>> lambda x: x

def add_one(x):
    return x + 1

Ekspresi Tunggal

Berbeda dengan fungsi normal, fungsi lambda Python adalah ekspresi tunggal. Meskipun, dalam isi

def add_one(x):
    return x + 1

>>>

>>> lambda x: x

Contoh di atas mengembalikan string

>>> lambda x: x

>>> lambda x: x

Ketik 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

Kesalahan jenis apa pun dengan

>>> lambda x: x

>>> lambda x: x

>>> lambda x: x

>>> lambda x: x

>>>

>>> lambda x: x

Seperti mencoba memasukkan pernyataan dalam lambda, menambahkan anotasi jenis segera menghasilkan

>>> lambda x: x

IIFE

Anda telah melihat beberapa contoh eksekusi fungsi yang langsung dipanggil

>>>

>>> lambda x: x + 1

Di 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

def add_one(x):
    return x + 1

>>> _(1, 2)
3

Argumen

Seperti objek fungsi normal yang didefinisikan dengan

def add_one(x):
    return x + 1

• 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

Dekorator

Di Python, dekorator adalah implementasi dari pola yang memungkinkan penambahan perilaku ke fungsi atau kelas. Biasanya diekspresikan dengan sintaks

>>> lambda x: x

>>> lambda x: x + 1

Pada contoh di atas,

>>> lambda x: x

>>> lambda x: x

>>> lambda x: x

>>> lambda x: x + 1

>>> lambda x: x

>>> lambda x: x

>>> lambda x: x

Dekorator dapat diterapkan ke lambda. Meskipun tidak mungkin untuk menghias lambda dengan sintaks

>>> lambda x: x

>>> lambda x: x + 1

>>> lambda x: x

>>> lambda x: x

>>> lambda x, y: x + y

>>> lambda x: x

>>> lambda x: x + 1

Lihat bagaimana, seperti yang telah Anda lihat, nama fungsi lambda muncul sebagai

>>> lambda x: x

>>> lambda x: x

Mendekorasi 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

>>> lambda x: x + 1

Argumen pertama dari

def add_one(x):
    return x + 1

>>> full_name = lambda first, last: f'Full name: {first.title()} {last.title()}'
>>> full_name('guido', 'van rossum')
'Full name: Guido Van Rossum'

>>> lambda x: x

>>> lambda x: x + 1

Hasilnya

>>> lambda x: x

>>> lambda x: x

>>> lambda x: x

>>> lambda x: x

Anda akan melihat

def add_one(x):
    return x + 1

Lambda 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

Penutup

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

>>> lambda x: x

>>> lambda x: x

• >>> full_name = lambda first, last: f'Full name: {first.title()} {last.title()}'
  >>> full_name('guido', 'van rossum')
  'Full name: Guido Van Rossum'
  

  _0 diteruskan sebagai argumen ke

  >>> lambda x: x
  

  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

Untuk menguji perilaku

>>> lambda x: x

>>> lambda x: x

>>> lambda x: x

>>> lambda x: x

>>> lambda x: x + 1

Pada baris 9 kode,

>>> lambda x: x

>>> lambda x: x

>>> lambda x: x

>>> lambda x: x

>>> full_name = lambda first, last: f'Full name: {first.title()} {last.title()}'
>>> full_name('guido', 'van rossum')
'Full name: Guido Van Rossum'

>>> lambda x: x

>>> full_name = lambda first, last: f'Full name: {first.title()} {last.title()}'
>>> full_name('guido', 'van rossum')
'Full name: Guido Van Rossum'

>>> lambda x: x

Demikian pula,

def add_one(x):
    return x + 1

>>> (lambda x: x + 1)(2)
3

Ketika Anda mengeksekusi kode di atas, Anda mendapatkan output berikut

>>> (lambda x: x + 1)(2)
3

Pada baris 6,

>>> lambda x: x

>>> lambda x: x

>>> full_name = lambda first, last: f'Full name: {first.title()} {last.title()}'
>>> full_name('guido', 'van rossum')
'Full name: Guido Van Rossum'

>>> lambda x: x

>>> lambda x: x

>>> full_name = lambda first, last: f'Full name: {first.title()} {last.title()}'
>>> full_name('guido', 'van rossum')
'Full name: Guido Van Rossum'

>>> lambda x: x

Dalam 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

Dalam fungsi normal,

>>> lambda x: x

>>> lambda x: x

Sekarang, dengan penerapan logika yang sama dengan fungsi lambda, amati perilaku yang tidak terduga

>>>

>>> (lambda x: x + 1)(2)
3

Hasil tak terduga terjadi karena variabel bebas

>>> lambda x: x

>>> lambda x: x

>>> lambda x: x

>>> lambda x: x

>>> lambda x: x

Untuk mengatasi masalah ini, Anda dapat menetapkan variabel bebas pada waktu definisi sebagai berikut

>>>

>>> (lambda x: x + 1)(2)
3

Fungsi lambda Python berperilaku seperti fungsi normal sehubungan dengan argumen. Oleh karena itu, parameter lambda dapat diinisialisasi dengan nilai default. parameter

>>> lambda x: x

>>> lambda x: x

>>> lambda x: x

Fungsi lambda Python dipanggil tanpa argumen apa pun pada baris 7, dan menggunakan nilai default

>>> lambda x: x

Menguji Lambda

Python lambda dapat diuji dengan cara yang mirip dengan fungsi biasa. Anda dapat menggunakan

>>> lambda x: x

>>> lambda x: x

>>> lambda x: x

Modul

>>> lambda x: x

>>> (lambda x: x + 1)(2)
3

>>> lambda x: x + 1

>>> lambda x: x + 1

>>> lambda x: x + 1

>>> lambda x: x + 1

>>> (lambda x: x + 1)(2)
3

Seperti yang diharapkan, kami memiliki dua kasus uji yang berhasil dan satu kegagalan untuk

>>> lambda x: x + 1

>>> lambda x, y: x + y

>>> lambda x: x + 1

>>> lambda x: x + 1

>>> lambda x, y: x + y

>>> lambda x: x + 1

>>> lambda x: x

Modul

>>> lambda x: x

>>> lambda x: x + 1

>>> lambda x: x + 1

>>> lambda x: x + 1

>>> (lambda x: x + 1)(2)
3

>>> lambda x: x

>>> lambda x: x + 1

Saat Anda menjalankan tes melalui

>>> lambda x: x + 1

>>> (lambda x: x + 1)(2)
3

Hasil pengujian yang gagal dari kegagalan yang sama dijelaskan dalam pelaksanaan pengujian unit di bagian sebelumnya

Anda dapat menambahkan

>>> lambda x: x + 1

>>> lambda x: x + 1

>>> lambda x: x + 1

Untuk ikhtisar komprehensif pengujian unit dengan Python, Anda mungkin ingin merujuk ke Memulai Pengujian dengan Python

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

Karena 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

Gaya 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

Garis bawah (

>>> lambda x, y: x + y

>>> lambda x, y: x + y

>>>

(lambda x: x + 1)(2) = lambda 2: 2 + 1
                     = 2 + 1
                     = 3

Memang, masih sulit untuk dibaca. Dengan tetap memanfaatkan

def add_one(x):
    return x + 1

>>>

(lambda x: x + 1)(2) = lambda 2: 2 + 1
                     = 2 + 1
                     = 3

Ini 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

def add_one(x):
    return x + 1

Kelas 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

>>> lambda x: x + 1

def add_one(x):
    return x + 1

>>> lambda x: x + 1

>>> lambda x: x + 1

(lambda x: x + 1)(2) = lambda 2: 2 + 1
                     = 2 + 1
                     = 3

Menjalankan alat seperti

>>> lambda x: x + 1

>>> lambda x: x + 1

>>> lambda x: x + 1

(lambda x: x + 1)(2) = lambda 2: 2 + 1
                     = 2 + 1
                     = 3

Meskipun

>>> lambda x: x + 1

>>> lambda x: x + 1

>>> lambda x: x + 1

Implementasi yang tepat dari

>>> lambda x: x + 1

(lambda x: x + 1)(2) = lambda 2: 2 + 1
                     = 2 + 1
                     = 3

>>> lambda x: x + 1

(lambda x: x + 1)(2) = lambda 2: 2 + 1
                     = 2 + 1
                     = 3

Sebagai 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

Konstruksi Fungsional Klasik

Fungsi Lambda biasanya digunakan dengan fungsi bawaan dan , serta , diekspos dalam modul

>>> lambda x: x + 1

>>>

(lambda x: x + 1)(2) = lambda 2: 2 + 1
                     = 2 + 1
                     = 3

Anda 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

>>> lambda x: x + 1

def add_one(x):
    return x + 1

• >>> _(1, 2)
  3
  

  4. metode daftar

• >>> _(1, 2)
  3
  

  5,

  >>> _(1, 2)
  3
  

  6,

  >>> _(1, 2)
  3
  

  7. fungsi bawaan

• >>> lambda x: x + 1
  

  53 dan

  >>> lambda x: x + 1
  

  54. dalam modul algoritma antrian Heap

  >>> lambda x: x + 1
  

  55

Bayangkan Anda ingin mengurutkan daftar ID yang direpresentasikan sebagai string. Setiap ID adalah gabungan dari string

>>> lambda x: x + 1

>>> _(1, 2)
3

Untuk memengaruhi eksekusi pengurutan, Anda dapat menetapkan lambda ke argumen bernama

>>> lambda x: x + 1

>>> ________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

(lambda x: x + 1)(2) = lambda 2: 2 + 1
                     = 2 + 1
                     = 3

Mengklik 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

def add_one(x):
    return x + 1

Untuk menjelajahi wxPython, lihat Cara Membangun Aplikasi GUI Python Dengan wxPython

Penerjemah 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

Dalam semangat yang sama seperti percobaan dalam juru bahasa Python, modul

>>> lambda x: x + 1

>>> lambda x: x + 1

>>>

>>> add_one = lambda x: x + 1
>>> add_one(2)
3

Saat pernyataan diteruskan sebagai string,

>>> lambda x: x + 1

>>> lambda x: x + 1

Pendekatan lain adalah dengan menggunakan

def add_one(x):
    return x + 1

>>>

>>> add_one = lambda x: x + 1
>>> add_one(2)
3

Solusi 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

>>> lambda x: x + 1

>>> lambda x: x + 1

Menambal 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

>>> add_one = lambda x: x + 1
>>> add_one(2)
3

Manajer konteks membantu mengisolasi operasi monyet menambal fungsi dari perpustakaan standar (, dalam contoh ini). Fungsi lambda yang ditetapkan ke

>>> lambda x: x + 1

Ini memungkinkan pengujian fungsi apa pun yang bergantung pada

>>> lambda x: x + 1

>>> lambda x: x + 1

>>> lambda x: x + 1

Kerangka pengujian unit seperti

>>> lambda x: x

>>> lambda x: x + 1

Dengan

>>> lambda x: x + 1

def add_one(x):
    return x + 1

>>> add_one = lambda x: x + 1
>>> add_one(2)
3

Dengan perlengkapan

>>> lambda x: x + 1

>>> lambda x: x + 1

>>> lambda x: x + 1

>>> lambda x: x + 1

>>> lambda x: x + 1

Menjalankan tes

>>> lambda x: x + 1

>>> add_one = lambda x: x + 1
>>> add_one(2)
3

Tes lulus saat kami memvalidasi bahwa

>>> lambda x: x + 1

Peta

Fungsi bawaan

def add_one(x):
    return x + 1

def add_one(x):
    return x + 1

def add_one(x):
    return x + 1

>>>

>>> add_one = lambda x: x + 1
>>> add_one(2)
3

Anda perlu memanggil

>>> lambda x: x + 1

def add_one(x):
    return x + 1

Menggunakan pemahaman daftar menghilangkan kebutuhan untuk mendefinisikan dan menjalankan fungsi lambda

>>>

>>> add_one = lambda x: x + 1
>>> add_one(2)
3

Saring

Fungsi bawaan

def add_one(x):
    return x + 1

>>> ________20______7

Perhatikan bahwa

def add_one(x):
    return x + 1

>>> lambda x: x + 1

Implementasi yang memanfaatkan konstruksi pemahaman daftar memberikan yang berikut ini

>>> ________20______8

Mengurangi

Sejak Python 3,

def add_one(x):
    return x + 1

>>> lambda x: x + 1

def add_one(x):
    return x + 1

def add_one(x):
    return x + 1

def add_one(x):
    return x + 1

Untuk menerapkan

def add_one(x):
    return x + 1

>>> ________20______9

Pendekatan yang lebih idiomatis menggunakan ekspresi generator, sebagai argumen untuk

>>> (lambda x: x + 1)(2)
3

>>>

def add_one(x):
    return x + 1

Solusi 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

Penggunaan garis bawah (

>>> lambda x, y: x + y

>>> (lambda x: x + 1)(2)
3