Lambda di Python: fungsi anonim, key untuk sort, dan map/filter

Fungsi yang tidak perlu repot diberi nama

Kebanyakan fungsi di Python didefinisikan dengan def, punya nama, dan tinggal di file tempat ia bisa dipakai ulang. lambda adalah alternatif yang lebih kecil dan tanpa nama, berguna di beberapa kasus ketika mendefinisikan fungsi lengkap terasa terlalu repot.

Ini bentuknya berdampingan:

def double(x):
    return x * 2

double_lambda = lambda x: x * 2

print(double(5))
print(double_lambda(5))

Dua fungsi, keduanya melakukan hal yang persis sama. Versi lambda muat dalam satu baris karena memang itulah tugasnya: fungsi sekali pakai untuk momen sekali pakai.

Sintaks

lambda <params>: <expression>

• <params> adalah daftar parameter yang sama seperti yang dipakai def, mendukung nilai default, *args, dan **kwargs.
• <expression> adalah satu ekspresi yang nilainya menjadi nilai kembalian.

Contoh:

add = lambda a, b: a + b
print(add(3, 4))

square = lambda n: n * n
print(square(8))

greet = lambda name="world": f"Hello, {name}"
print(greet())
print(greet("Rosa"))

Tidak ada kata kunci return. Nilai ekspresinya dikembalikan secara implisit.

Satu-satunya batasan

Lambda hanya bisa berisi satu ekspresi. Kamu tidak bisa menaruh pernyataan di dalamnya:

# These don't work:
# bad = lambda x: x = x + 1         # can't assign
# worse = lambda x:                 # can't have if/elif/else as statements
#     if x > 0:
#         return x
#     else:
#         return -x

Tapi kamu bisa memakai ekspresi ternary:

signed = lambda x: x if x > 0 else -x
print(signed(-5))
print(signed(5))

Kalau kamu butuh lebih dari satu ekspresi, itu tanda untuk beralih ke def.

Tempat lambda benar-benar berguna

Lambda yang di-assign ke sebuah variabel hampir selalu lebih buruk daripada def bernama:

# Don't do this.
double = lambda x: x * 2

Itu jelas lebih buruk daripada def double(x): return x * 2: sama mudahnya dibaca, ditambah versi lambda memberi debugger nama yang tidak membantu, <lambda>, di stack trace.

Lambda bersinar di tepat satu tempat: sebagai argumen langsung untuk higher-order function.

Key khusus untuk pengurutan

Kasus klasiknya:

users = [
    {"name": "Ada", "age": 36},
    {"name": "Boris", "age": 28},
    {"name": "Ciara", "age": 44},
]

by_age = sorted(users, key=lambda u: u["age"])
print(by_age)

Argumen key milik sorted menginginkan fungsi yang menerima satu item lalu mengembalikan nilai yang dipakai untuk mengurutkan. Lambda satu baris pas sekali di sini, dan memakai def lengkap akan terasa berat untuk sesuatu sekecil ini.

Kamu bisa mengurutkan berdasarkan beberapa field dengan memakai tuple:

records = [("Ada", 2), ("Boris", 1), ("Ada", 1), ("Boris", 3)]

by_name_then_version = sorted(records, key=lambda r: (r[0], r[1]))
print(by_name_then_version)

min, max, filter, map

Ceritanya mirip: semuanya menerima argumen fungsi yang opsional:

prices = [{"item": "apple", "cost": 0.50}, {"item": "bread", "cost": 2.00}]

cheapest = min(prices, key=lambda p: p["cost"])
print(cheapest)

# map: apply a function to each item
numbers = [1, 2, 3, 4]
doubled = list(map(lambda n: n * 2, numbers))
print(doubled)

# filter: keep items where the function returns true
evens = list(filter(lambda n: n % 2 == 0, numbers))
print(evens)

Untuk map dan filter, list comprehension biasanya malah lebih jelas:

numbers = [1, 2, 3, 4]

doubled = [n * 2 for n in numbers]
evens = [n for n in numbers if n % 2 == 0]
print(doubled, evens)

Karena alasan ini, kebanyakan programmer Python lebih memilih comprehension daripada map/filter. lambda tetap cocok secara alami untuk sorted, min, dan max, karena di sana tidak ada jalan pintas berupa comprehension.

Lambda dan operator

Kalau lambda-mu hanya "ambil sebuah key" atau "ambil sebuah atribut", modul operator di Python punya alternatif yang lebih cepat dan lebih jelas:

from operator import itemgetter, attrgetter

users = [{"name": "Ada", "age": 36}, {"name": "Boris", "age": 28}]

# These two are equivalent:
a = sorted(users, key=lambda u: u["name"])
b = sorted(users, key=itemgetter("name"))

print(a)
print(b)

Keuntungannya tidak besar, tapi di kode yang memang sudah meng-import operator, cara ini terbaca sedikit lebih deklaratif.

Kapan kembali memakai def

Kalau salah satu dari ini benar, tulis def:

1. Logikanya tidak muat dengan rapi dalam satu ekspresi.
2. Kamu ingin memberi nama pada fungsinya karena nama itu akan membantu keterbacaan.
3. Kamu akan memakai logika yang sama di lebih dari satu tempat.
4. Fungsinya butuh docstring (lambda tidak bisa membawa docstring).

Ingat: Python tidak dinilai dari jumlah baris. Fungsi bernama tiga baris hampir selalu lebih enak dibaca daripada lambda satu baris begitu logikanya tidak sepele.

Berikutnya: decorator

Lambda memperlakukan fungsi sebagai nilai yang bisa dioper ke mana-mana. Decorator membawa ide yang sama selangkah lebih jauh: dengan decorator kamu bisa membungkus fungsi apa pun dengan perilaku yang bisa dipakai ulang, seperti logging, mengukur waktu, caching, dan autentikasi, cukup dengan satu @ di baris di atasnya. Itulah halaman berikutnya.