Anda perlu mengurutkan produk berdasarkan harga. Menulis fungsi bernama terpisah hanya untuk mengatakan “gunakan harga” terasa seperti banyak upacara. Fungsi python lambda memungkinkan Anda menentukan bagian kecil logika sebaris, tepat di tempat Anda menggunakannya.

Lambda memang berguna, tetapi juga mudah digunakan secara berlebihan. Panduan ini menunjukkan bagian mana yang benar-benar membantu dan bagian mana yang membuat kode lebih sulit dibaca. Kami menjalankan setiap contoh di Python 3.13, dan output yang ditampilkan berasal dari proses tersebut.

Apa itu lambda?

Lambda adalah fungsi tanpa nama, ditulis dengan kata kunci lambda:

lambda arguments: expression

Dibutuhkan sejumlah argumen dan mengembalikan nilai ekspresi tunggal, secara otomatis. Tidak ada kata kunci return, dan tidak ada pernyataan.

square = lambda x: x * x
print(square(4))                     # 16

print((lambda a, b=10: a + b)(5))    # 15

Baris kedua mendefinisikan lambda dengan argumen default dan segera memanggilnya. Anda jarang menulis ini dalam kode nyata, tetapi ini menunjukkan bahwa lambda adalah objek fungsi biasa.

lambda vs def

Keduanya menghasilkan fungsi yang berperilaku sama:

square = lambda x: x * x

def square_def(x):
    return x * x

print(square(4), square_def(4))                 # 16 16
print(square.__name__, square_def.__name__)     # <lambda> square_def

Lihatlah nama-namanya. Setiap lambda hanya dipanggil <lambda>, jadi pesan kesalahan dan log tidak dapat memberi tahu Anda mana yang gagal. Ini adalah alasan utama panduan gaya seperti PEP 8 merekomendasikan def kapan pun Anda ingin memberi nama pada suatu fungsi.

Menyortir dengan kunci: penggunaan terbaik

Fungsi seperti sorted, min dan max menerima fungsi key yang memutuskan apa yang akan dibandingkan. Di sinilah lambda bersinar:

products = [("pen", 10), ("bag", 900), ("book", 250)]

sorted(products, key=lambda p: p[1])
# [('pen', 10), ('book', 250), ('bag', 900)]

max(products, key=lambda p: p[1])
# ('bag', 900)

Untuk mengurutkan berdasarkan beberapa hal, kembalikan Tuple. Di sini, orang diurutkan berdasarkan usia, yang tertua terlebih dahulu, lalu berdasarkan nama:

people = [{"name": "Asha", "age": 31}, {"name": "Ben", "age": 25},
          {"name": "Dev", "age": 31}]

[p["name"] for p in sorted(people, key=lambda p: (-p["age"], p["name"]))]
# ['Asha', 'Dev', 'Ben']

Tanda minus membalik urutan angkanya saja. Terkadang Anda tidak memerlukan lambda sama sekali, karena fungsi yang ada sudah melakukan tugasnya. Bandingkan pengurutan default dengan pengurutan yang tidak peka huruf besar/kecil:

names = ["Asha", "ben", "Chitra", "dev"]

sorted(names)                  # ['Asha', 'Chitra', 'ben', 'dev']
sorted(names, key=str.lower)   # ['Asha', 'ben', 'Chitra', 'dev']

Standarnya menempatkan semua kata dengan huruf kapital terlebih dahulu. Meneruskan str.lower akan memperbaikinya tanpa lambda apa pun. Modul operator menawarkan pembantu serupa, seperti itemgetter(1) untuk lambda p: p[1].

peta dan filter

map menerapkan fungsi ke setiap item, dan filter menjaga item yang dikembalikannya tetap benar. Keduanya bekerja dengan lambda, tetapi bandingkan masing-masing dengan pemahaman daftar:

nums = [1, 2, 3, 4, 5, 6]

list(map(lambda n: n * 10, nums))      # [10, 20, 30, 40, 50, 60]
[n * 10 for n in nums]                 # [10, 20, 30, 40, 50, 60]

list(filter(lambda n: n % 2 == 0, nums))   # [2, 4, 6]
[n for n in nums if n % 2 == 0]            # [2, 4, 6]

Hasilnya sama, dan sebagian besar pengembang Python menganggap pemahamannya lebih mudah dibaca. Perhatikan juga bahwa map dan filter mengembalikan iterator yang malas, jadi Anda perlu list() untuk melihat nilainya. Panduan kami untuk Pemahaman daftar Python mencakup gaya tersebut secara mendalam. map masih terbaca dengan baik dengan fungsi bernama yang sudah ada, seperti pada map(str.strip, lines).

mengurangi

functools.reduce menggabungkan item menjadi satu nilai, membawa hasil yang berjalan:

from functools import reduce

reduce(lambda acc, n: acc + n, nums, 0)   # 21
sum(nums)                                 # 21

Untuk pekerjaan umum, misalnya total, gunakan bawaan seperti sum, max atau any. Pertahankan reduce untuk kasus yang lebih jarang, dan pertimbangkan perulangan biasa jika lambda mulai terlihat rumit.

Kondisi di lambda

Anda tidak dapat menggunakan pernyataan if di lambda, tetapi Anda dapat menggunakan ekspresi kondisional:

label = lambda total: "large" if total >= 1000 else "small"

label(1200), label(300)
# ('large', 'small')

Satu syarat baik-baik saja. Begitu Anda mulai menyusunnya, pembaca harus bekerja keras, yang merupakan tanda jelas untuk beralih ke pernyataan def dengan if biasa.

Lambdas yang mengembalikan fungsi

Suatu fungsi dapat membuat dan mengembalikan lambda yang mengingat nilai dari lingkungannya:

def multiplier(n):
    return lambda x: x * n

double = multiplier(2)
double(7)   # 14

Ini berfungsi karena adanya penutupan, yang dijelaskan dalam artikel kami tentang penutupan JavaScript dalam bahasa yang berbeda. functools.partial Python menawarkan cara lain untuk mengisi argumen terlebih dahulu.

Jebakan yang mengikat terlambat

Hal ini pada akhirnya akan menimpa hampir semua orang. Kami membuat tiga lambda dalam satu lingkaran, mengharapkan masing-masing lambda mengembalikan nomornya sendiri:

funcs = [lambda: i for i in range(3)]
[f() for f in funcs]

# [2, 2, 2]

Ketiganya mengembalikan 2. Lambda tidak menangkap nilai dari i saat dibuat. Ia mencari variabel ketika dipanggil, dan pada saat itu loop telah selesai, meninggalkan i di 2. Perbaikan yang biasa dilakukan adalah dengan menangkap nilai sebagai argumen default, karena default dievaluasi pada waktu definisi:

funcs = [lambda i=i: i for i in range(3)]
[f() for f in funcs]

# [0, 1, 2]

Ini tidak unik untuk lambda, karena def di dalam loop berperilaku dengan cara yang sama. Ini hanya muncul lebih sering dengan lambda, karena mereka biasanya dibuat dalam loop, seperti ketika melampirkan callback tombol.

Tabel pencarian fungsi kecil

Lambdas sangat cocok dengan kamus yang memetakan nama ke operasi kecil:

ops = {
    "add": lambda a, b: a + b,
    "sub": lambda a, b: a - b,
}

ops["sub"](10, 3)   # 7

Ini dapat menggantikan rantai panjang if dan elif. Panduan Kamus Python mencakup lebih banyak pola kamus, dan modul operator sudah menyediakan operator.add dan operator.sub.

Batasan lambda

• Hanya satu ekspresi. Tidak ada penugasan dengan =, tanpa loop, dan tanpa blok try.
• Tidak ada pernyataan. Penulisan lambda x: return x gagal dengan SyntaxError, seperti yang dikonfirmasi oleh pengujian kami.
• Tidak ada docstring atau petunjuk mengetik. Alat dan pembaca kurang mendapat bantuan.
• Debug yang lebih sulit. Kesalahan menunjuk pada <lambda> daripada nama yang berguna.

Lambdas tentu saja masih dapat mengajukan pengecualian. Penanganannya berfungsi sama seperti fungsi apa pun, seperti yang dibahas dalam penanganan pengecualian Python.

Kapan tidak menggunakan lambda

Poin terakhir itu penting. Logika yang layak digunakan kembali layak untuk diuji, dan fungsi bernama jauh lebih mudah untuk diuji, seperti yang ditunjukkan oleh tutorial pytest kami.

Penutup

Lambda yang baik cukup pendek untuk dibaca sekilas, dan digunakan sekali, biasanya sebagai argumen. Kunci pengurutan adalah contoh klasik. Untuk memeriksa kode Anda sendiri, cari = lambda, dan ubah menjadi fungsi bernama. Kemudian lihat map atau filter mana pun dengan lambda, dan lihat apakah suatu pemahaman terbaca lebih baik.

Pertanyaan yang sering diajukan

Teruslah belajar