Fungsi Lambda Python: Panduan untuk Pemula

Fungsi lambda di Python adalah alat yang kuat dan ringkas untuk membuat fungsi kecil tanpa nama secara cepat. Fungsi ini sempurna untuk menyederhanakan tugas jangka pendek, merapikan kode dengan fungsi tingkat tinggi seperti map, filter, atau sorted, serta mengurangi keruwetan saat mendefinisikan logika sementara atau sekali pakai. Fungsi lambda juga menawarkan solusi elegan untuk meningkatkan keterbacaan kode dalam skenario sederhana. Artikel ini akan membahas apa itu fungsi lambda, karakteristiknya, dan cara menggunakannya secara efektif.

Dalam panduan ini, kami akan memberikan panduan lengkap tentang fungsi lambda di Python, mencakup mekanismenya, sintaksnya, dan bagaimana perbandingannya dengan fungsi standar, dengan contoh sederhana untuk mengilustrasikan konsep kunci. Kami membahas kasus penggunaan umum, seperti penggunaan fungsi lambda dalam paradigma pemrograman fungsional dan efisiensinya dibandingkan fungsi standar. Contoh praktis dan praktik terbaik disertakan untuk membantu Anda memasukkan fungsi lambda secara efektif ke dalam pemrograman Python Anda.

Apa itu Fungsi Lambda di Python?

Fungsi lambda berbeda dari fungsi Python standar dalam beberapa hal penting. Fungsi ini merupakan ekspresi anonim, artinya tidak memiliki nama kecuali secara eksplisit ditetapkan ke sebuah variabel. Fungsi lambda juga lebih ringkas dan didefinisikan dalam satu baris tanpa memerlukan pernyataan return. Ini membuatnya ideal untuk operasi sederhana yang sekali pakai dan untuk digunakan sebagai argumen inline pada fungsi tingkat tinggi seperti map, filter, dan sorted.

Berikut contoh fungsi lambda yang menjumlahkan dua angka:

fn = lambda x, y: x + y
print(fn)

# <function <lambda> at 0xe508b8>

Cara kerja fungsi lambda

Bagaimana fungsi lambda ini bekerja? Untuk memahaminya, mari bandingkan dengan fungsi Python standar.

# Example: add two numbers using standard Python function
def add_numbers(x, y):
    return x + y

Fungsi standar ini mudah dipahami. Kata kunci def mendefinisikan fungsi yang menerima dua argumen, x dan y. Fungsi ini menghitung jumlah x dan y dan mengembalikan hasilnya.

Sekarang, mari lihat bagaimana fungsi lambda kita mencapai tugas yang sama.

# Example: add two numbers using a lambda function
fn = lambda x, y: x + y
print(fn)

# <function <lambda> at 0xbfb968>

Kata kunci lambda menandakan bahwa kita sedang mendefinisikan fungsi lambda, sehingga tidak perlu menggunakan kata kunci def. Setelah kata kunci lambda, dicantumkan argumen masukan x dan y. Setelah titik dua, kita menentukan ekspresi yang hasilnya akan dikembalikan, yaitu x + y.

Menulis Fungsi Lambda di Python: Contoh

Agar Anda lebih memahami konsep yang telah kita bahas sejauh ini, mari lihat beberapa contoh cara kerja fungsi Lambda di Python. 

Panduan langkah demi langkah menulis fungsi lambda

Fungsi lambda ideal untuk membuat fungsi pendek dan lugas tanpa kompleksitas tambahan. 

Misalnya, anggap Anda ingin memeriksa apakah suatu bilangan bulat bukan nol adalah genap. Anda bisa menulis fungsi Python standar, tetapi fungsionalitas yang sama dapat dicapai dengan fungsi lambda satu baris yang ringkas dan ditetapkan ke sebuah variabel: is_even = lambda x: x % 2 == 0. 

Di sini, fungsi lambda di sisi kanan penugasan menerima masukan x dan mengembalikan True jika x genap (yaitu jika sisa bagi saat dibagi 2 adalah 0). 

Fungsi lambda ini kemudian ditetapkan ke variabel is_even, sehingga dapat dipanggil seperti fungsi biasa. Misalnya, is_even(5) (mengembalikan False) dan is_even(678432) (mengembalikan True).

Fungsi lambda juga sangat berguna untuk mendefinisikan rumus sederhana. Misalnya, untuk mengonversi Celsius ke Fahrenheit, Anda dapat menggunakan fungsi lambda: c_to_f = lambda c: (c * 9/5) + 32. Anda kemudian memanggil fungsi tersebut seperti fungsi lainnya: c_to_f(0).

Kasus penggunaan umum untuk fungsi lambda

Fungsi lambda sering digunakan dalam pemrograman fungsional, khususnya dengan fungsi seperti map() dan filter() yang menerima fungsi lain sebagai argumen untuk memproses elemen dalam sebuah koleksi. Mari lihat cara menggunakan fungsi lambda dengan filter(). Berikut cuplikan kodenya:

# Use filter with lambda function
numbers = [1, 2, 3, 4, 5, 6, 7, 8]
evens = filter(lambda x: x % 2 == 0, numbers)
print(list(evens))  # print the list of the filter object to see the result

# [2, 4, 6, 8]

Dalam kode ini, kita mulai dengan mendefinisikan himpunan numbers. Selanjutnya, kita membuat fungsi lambda untuk memeriksa apakah suatu angka genap. Fungsi filter menerapkan fungsi lambda ini ke himpunan numbers. Lalu, kita mencetak daftar bilangan genap yang diidentifikasi oleh fungsi filter.

Demikian pula, kita dapat menggunakan fungsi map untuk menerapkan lambda ke suatu koleksi elemen. Pada contoh di bawah, kita menghitung panjang string dalam sebuah daftar dengan memetakan fungsi len() ke setiap elemen.

# Use map with lambda function
fruits = ['apple', 'banana', 'cherry']
lengths = list(map(lambda x: len(x), fruits))
print(lengths)

# [5, 6, 6]

Fungsi lambda juga digunakan dengan fungsi sorted(), yang mengurutkan elemen sebuah koleksi untuk mengembalikan koleksi baru. Pada contoh berikut (tanpa lambda), kita menggunakan fungsi sorted() untuk mengurutkan daftar angka.

numbers = [1, 10, -1, 3, -10, 5]
sorted_stuff = sorted(numbers)
print(sorted_stuff)

# [-10, -1, 1, 3, 5, 10]

Misalkan kita ingin mengurutkan daftar angka berdasarkan nilai absolut. Bagaimana cara mencapainya? Fungsi sorted() memiliki argumen key yang memungkinkan kita menyesuaikan urutan pengurutan dengan memberikan fungsi lambda.

# Sort according to absolute value
sorted_numbers_absolute = sorted(numbers, key=lambda x: abs(x))
print(sorted_numbers_absolute)

# [1, -1, 3, 5, 10, -10]

Kasus penggunaan lain untuk sort() dengan fungsi lambda adalah mengurutkan daftar tuple berdasarkan elemen tertentu, misalnya elemen kedua.

# Sort a list of tuples by the second element
data = [(1, 3), (2, 1), (4, 2)]
sorted_data = sorted(data, key=lambda x: x[1])
print(sorted_data)

# [(2, 1), (4, 2), (1, 3)]

Pada cuplikan kode ini, kita mendefinisikan data sebagai daftar tuple. Lalu kita menggunakan fungsi sorted() dengan parameter key, di mana fungsi lambda mengekstrak elemen kedua dari setiap tuple untuk proses pengurutan.

Apakah Fungsi Lambda Lebih Cepat di Python?

Di Python, fungsi lambda tidak secara bawaan lebih cepat daripada fungsi standar, karena keduanya dikompilasi menjadi bytecode yang serupa. Namun, fungsi lambda dapat sedikit mengurangi overhead dalam kasus ketika mendefinisikan fungsi penuh akan menambah boilerplate yang tidak perlu.

Berikut beberapa kasus uji yang membandingkan fungsi lambda dengan fungsi Python standar. Kode dijalankan di laptop saya, MacBook Pro dengan chip Apple M1 Pro, memori 16 GB, menjalankan macOS Sequoia 15.2.

Fungsi lambda dapat digunakan inline sebagai fungsi anonim saat diteruskan langsung ke fungsi tingkat tinggi seperti map(), filter(), atau sorted(). Ini menghindari kebutuhan untuk mendefinisikan dan mereferensikan fungsi bernama terpisah, mengurangi boilerplate dan overhead pencarian.

import time

numbers = list(range(1, 1000000))

# Standard function
def double_standard(x):
    return x * 2

start = time.time()
map(double_standard, numbers)
print(time.time() - start)

# Lambda function
double_lambda = map(lambda x: x * 2, numbers)

start = time.time()
list(map(lambda x: x * 2, numbers))
print(time.time() - start)

# 3.504753112792969e-05
# 2.384185791015625e-05

Fungsi lambda ideal untuk penggunaan sekali atau sementara, karena menghilangkan kebutuhan akan blok def formal, menghemat waktu dan ruang. Pada blok kode berikut, kami membandingkan kinerja fungsi standar dengan fungsi lambda. Kami mengurutkan kamus dengan satu juta elemen, di mana kuncinya adalah kode dua huruf acak, dan nilainya adalah bilangan bulat acak.

import random
import string

# Generate a dictionary with elements of the form 'XX': number.
NUMBER_ITEMS = 1000000
items = {
    ''.join(random.choices(string.ascii_uppercase, k=2)): random.randint(1, 100)
    for _ in range(NUMBER_ITEMS)
}

# Standard function (extra definition step)
def sort_standard(item):
    return item[1]

print('Standard')
start = time.time()
sorted_items_standard = sorted(items, key=sort_standard)
print(time.time() - start)
print(sorted_items_standard[:5])
print()

# Lambda function
print('Lambda')
start = time.time()
sorted_items_lambda = sorted(items, key=lambda x: x[1])
print(time.time() - start)
print(sorted_items_lambda[:5])
print()

# Standard
# 0.00011610984802246094
# ['OA', 'VA', 'XA', 'IA', 'BA']
# Lambda
# 0.00011014938354492188
# ['OA', 'VA', 'XA', 'IA', 'BA']

Fungsi Lambda Python: Contoh dan Latihan

Mari kita bahas beberapa contoh yang lebih praktis untuk menunjukkan bagaimana fungsi Lambda bekerja di Python. 

Contoh praktis

Fungsi lambda sering digunakan dengan metode bawaan Python. Misalnya, mari lihat penggunaan reduce() untuk menerapkan fungsi biner yang ditentukan pengguna secara kumulatif pada item dalam sebuah urutan.

# Example: Use lambda function with built-in Python method reduce.
from functools import reduce

numbers = [5, -6, 2, 7]
total = reduce(lambda x, y: x + y, numbers)
print(f'The sum of the numbers is {total}.')

# The sum of the numbers is 8.

Mirip dengan filter() atau map() di atas, reduce() menerapkan sebuah fungsi, di sini diberikan oleh lambda, ke sekumpulan elemen.

Sekarang, mari jelajahi fungsi bawaan Python lainnya, zip(). Fungsi zip memasangkan elemen yang bersesuaian dari beberapa daftar ke dalam tuple. Misalnya, hasil dari zip(['a', 'b', 'c'], [1, 2, 3]) adalah [('a', 1), ('b', 2), ('c', 3)].

# Example: Use lambda function with built-in Python method zip.
list1 = [1, 2, 3]
list2 = [4, 5, 6]

# Using zip and a lambda function to multiply corresponding elements
result = list(map(lambda x: x[0] * x[1], zip(list1, list2)))

print(f'The result of multiplying corresponding elements is {result}.')

# The result of multiplying corresponding elements is [4, 10, 18].

Kode ini menghitung hasil kali elemen yang bersesuaian dari dua daftar, list1 dan list2. Kode menggunakan zip() untuk memasangkan elemen dari kedua daftar ke dalam tuple, lalu menerapkan fungsi lambda dengan map() untuk mengalikan elemen yang dipasangkan, dan akhirnya mengonversi hasilnya menjadi daftar.

Contoh dunia nyata: transformasi data

Bayangkan Anda menjalankan kios buah dan ingin menghitung total penjualan untuk setiap jenis buah.

Pertama, kita membuat beberapa catatan penjualan. Lalu, kita menggunakan map() dengan fungsi lambda untuk menghitung total_sales dengan mengalikan harga dan kuantitas untuk setiap item dalam kamus sales_data. Sintaks **record membongkar kamus asli, memastikan semua key dan value-nya tetap dipertahankan dalam kamus baru. Terakhir, kita mencetak setiap catatan dari data yang telah ditransformasikan.

# Sample data: list of dictionaries representing sales records
sales_data = [
	{'fruit': 'peaches', 'price': 1.41, 'quantity': 3},
	{'fruit': 'pears', 'price': 1.21, 'quantity': 2},
	{'fruit': 'mangoes', 'price': 0.56, 'quantity': 3},
]

# Using a lambda function to calculate total sales for each record
transformed_data = list(
	map(
		lambda entry: {**entry, 'total_sales': round(entry['price'] * entry['quantity'], 2)},
		sales_data
	)
)

# Print the transformed data
for record in transformed_data:
	print(record)

# {'fruit': 'peaches', 'price': 1.41, 'quantity': 3, 'total_sales': 4.23}
# {'fruit': 'pears', 'price': 1.21, 'quantity': 2, 'total_sales': 2.42}
# {'fruit': 'mangoes', 'price': 0.56, 'quantity': 3, 'total_sales': 1.68}

Soal sederhana untuk dilatih dengan fungsi lambda

Jika Anda ingin berlatih menggunakan fungsi lambda, berikut beberapa soal yang bisa dicoba.

• Diberi sebuah angka, temukan kuadratnya.
• Diberi dua angka, temukan mana yang lebih besar.
• Diberi sebuah angka, periksa apakah angka tersebut ganjil.
• Diberi daftar bilangan bulat positif, saring semua bilangan ganjil.
• Urutkan daftar tuple 3-elemen berdasarkan elemen ketiganya.
• Ekstrak domain dari alamat email. Misalnya, dari [email protected], ekstrak example.com.

Kesalahan umum terkait lambda

Mari lihat beberapa kesalahan umum yang dilakukan pemrogram dengan lambda dan solusinya.

1. Kesalahan pertama adalah menggunakan fungsi lambda saat tidak tepat. Penting untuk diingat bahwa fungsi lambda dirancang untuk tugas-tugas pendek dan sederhana, bukan untuk menangani logika kompleks. Misalnya, cuplikan kode berikut bukan kasus penggunaan ideal untuk fungsi lambda.

# Complex logic in a lambda
result = lambda x: (x ** 2 + x - 1) / (x + 1 if x != -1 else 1)
print(result(5))  # Hard to understand

# 4.833333333333333

Dalam kasus ini, lebih baik menggunakan fungsi Python standar saja.

def complex_logic(x):
    if x == -1:
        return x ** 2 + x - 1
    return (x ** 2 + x - 1) / (x + 1)
print(complex_logic(5))

# 4.833333333333333

2. Kesalahan sederhana lainnya adalah tertukar sintaksnya. Misalnya, lupa menuliskan kata kunci lambda akan menghasilkan error. Kesalahan sintaks umum lainnya adalah tidak menyertakan argumen masukan:

# Forgetting the required arguments
numbers = [1, 2, 3, 4]
squared = map(lambda: x ** 2, numbers)  # <-- Where is the input argument? Error: lambda missing argument

Solusinya adalah menyertakan argumen masukan:

squared = map(lambda x: x ** 2, numbers)

Cara yang baik untuk menangkap kesalahan seperti ini adalah dengan menyertakan kasus uji informal dan sederhana saat mengembangkan.

print(list(squared))

3. Kesalahan lain yang perlu diwaspadai adalah tidak menyertakan logika untuk kasus tepi. Misalnya, kode ini gagal saat y bernilai 0. Solusinya adalah menyertakan pernyataan if sederhana untuk menangkap kasus bermasalah atau membungkus kode dalam blok pengecualian.

# Dividing without handling zero
divide = lambda x, y: x / y

safe_divide = lambda x, y: x / y if y != 0 else "undefined"
print(safe_divide(5, 0))

# undefined

4. Masalah yang lebih halus adalah lupa mengonversi iterator ke daftar saat menampilkan hasil. Misalnya, fungsi map() mengembalikan objek map, bukan daftar. Untuk mengakses hasilnya, konversikan objek map menjadi list.

# Forgetting to convert to a list
numbers = [1, 2, 3]
squared = map(lambda x: x ** 2, numbers)
print(squared)  # <-- squared is the map, not the result

# <map object at 0x106d2b0>

print(list(squared))  # list(squared) gives the result

# [1, 4, 9]

Strategi Debugging Fungsi Lambda Python

Lalu, bagaimana cara kita melakukan debugging pada lambda? Berikut beberapa kemungkinan.

• Uraikan lambda. Sementara waktu, ubah menjadi fungsi bernama untuk keperluan debugging.
• Gunakan pernyataan print untuk menampilkan nilai antara pada fungsi tingkat tinggi seperti map() atau filter().
• Uji kasus tepi. Uji dengan nilai ekstrem, tidak valid, atau batas untuk menangkap potensi kesalahan.

Trik yang berguna untuk mencetak langkah perantara adalah menyertakan pernyataan print di dalam sebuah tuple bersama hasilnya. Keluaran yang diinginkan kemudian dapat diteruskan ke fungsi tingkat tinggi dengan mengindeks tuple pada posisi 1. 

Berikut contohnya:

numbers = [1, 2, 3, 4, 5]

# Lambda function with print to debug intermediate values
filtered_numbers = filter(lambda x: (print(f'Checking: {x} -> {x >= 3}'), x >= 3)[1], numbers)

# Converting filter object to list to force evaluation
print(list(filtered_numbers))

# Checking: 1 -> False
# Checking: 2 -> False
# Checking: 3 -> True
# Checking: 4 -> True
# Checking: 5 -> True
# [3, 4, 5]

Dalam kode ini, digunakan sebuah trik untuk mencetak langkah perantara saat menyaring daftar angka. Fungsi lambda dalam filter menyertakan sebuah tuple: elemen pertama adalah pernyataan print yang mencatat angka saat ini dan apakah angka tersebut memenuhi kondisi (x >= 3), dan elemen kedua adalah kondisinya sendiri. 

Bagian [1] di akhir lambda memastikan bahwa kondisi (x >= 3) dikembalikan ke fungsi filter sambil memungkinkan pernyataan print dieksekusi untuk debugging. 

Mengonversi objek filter menjadi daftar memaksa evaluasi semua elemen, memicu pernyataan print untuk setiap angka. Pendekatan ini membantu men-debug logika sambil mempertahankan fungsionalitas operasi penyaringan.

Praktik Terbaik Menggunakan Fungsi Lambda

Praktik terbaik dalam menggunakan fungsi lambda melibatkan pemahaman kapan fungsi ini tepat digunakan dan kapan sebaiknya dihindari.

Kapan menggunakan fungsi Lambda

• Logika pendek dan sederhana. Ideal untuk operasi ringkas yang tidak memerlukan definisi fungsi penuh.
• Fungsi tingkat tinggi. Bekerja efektif sebagai argumen untuk fungsi tingkat tinggi seperti map(), filter(), atau sorted().
• Fungsi sementara (sekali pakai). Berguna saat fungsi hanya dibutuhkan sekali, dan mendefinisikannya dengan def hanya akan menambah keruwetan kode secara tidak perlu.
• Keterbacaan yang lebih baik. Cocok untuk tugas sederhana di mana penggunaan fungsi lambda membuat kode tetap ringkas dan mudah diikuti.

Kapan menghindari fungsi Lambda

• Logika kompleks atau multibaris. Lambda terbatas pada satu ekspresi dan dapat dengan cepat menjadi sulit dibaca untuk operasi yang lebih rumit.
• Fungsi yang dapat digunakan ulang atau diberi nama. Jika fungsi perlu digunakan kembali atau diuntungkan dari nama yang deskriptif, fungsi standar def lebih tepat.
• Debugging atau dokumentasi. Fungsi lambda tidak dapat menyertakan docstring dan bisa lebih sulit di-debug dibandingkan fungsi bernama.

Untuk meningkatkan keterbacaan dan kemudahan pemeliharaan saat menggunakan lambda, ikuti praktik terbaik berikut:

• Gunakan nama yang deskriptif untuk kejelasan.
• Tetap sederhana: Lambda idealnya cukup satu baris dan merepresentasikan logika yang lugas.
• Batasi perangkaian (nesting): Hindari menggunakan fungsi lambda di dalam fungsi lambda lain atau struktur data yang kompleks kecuali diperlukan.
• Utamakan keterbacaan daripada keringkasan: Jika penggunaan lambda mengorbankan keterbacaan, lebih baik mendefinisikan fungsi bernama.

Kesimpulan

Fungsi lambda Python adalah alat yang ampuh untuk menulis fungsi anonim yang ringkas. Fungsi ini unggul dalam skenario yang memerlukan operasi singkat, sementara, atau inline, terutama saat digunakan dengan fungsi tingkat tinggi seperti map, filter, atau sorted. 

Namun, penggunaannya harus bijak, karena logika yang lebih kompleks lebih cocok ditangani oleh fungsi standar yang didefinisikan dengan def. Dengan memahami kekuatan, keterbatasan, dan praktik terbaiknya, Anda dapat memanfaatkan fungsi lambda secara efektif untuk menulis kode Python yang bersih, efisien, dan mudah dipelihara.

Untuk mempelajari lebih lanjut tentang fungsi Python, lihat sumber daya DataCamp.

• Fungsi Python: Cara Memanggil & Menulis Fungsi
• Kursus Menulis Fungsi di Python
• Fundamental Data Python
• Fundamental Pemrograman Python
• Kursus Python Menengah untuk Pengembang