Belajar Python Function Dan Lambda

function (fungsi) itu blok kode yang bisa dipanggil berulang kali buat ngerjain tugas tertentu. dengan fungsi, kode lebih terorganisir, gampang di-test, dan nggak perlu nulis kode yang sama dua kali. di tulisan yang lama, fungsi def pada python sudah sempat kita bahas dasarnya: cara bikin fungsi, return, sama parameter default. nah, artikel ini versi yang jauh lebih lengkap, dan bedanya ada di dua hal: pertama, pembahasannya ngalir dari nol sampai konsep yang lebih dalam kayak rekursif, lambda, dan decorator; kedua, saya fokus banget ke bagian yang bikin pemula nyangkut, terutama beda print sama return dan beda parameter sama argumen.

materi ini adalah salah satu yang mengubah cara saya nulis kode secara permanen. sebelum paham fungsi, kode saya panjang dan ngulang terus; setelahnya semuanya jadi jauh lebih ringkas. kalau kalian cuma mau ngambil satu hal dari artikel ini, ingat prinsip ini: kalau kode yang sama ditulis dua kali, seharusnya itu jadi sebuah fungsi.

di artikel ini kita bahas tuntas: cara bikin dan manggil fungsi, return value, macam-macam parameter, scope variabel, fungsi rekursif, lambda, sampai decorator. tiap bagian saya kasih contoh yang bisa langsung kalian coba sendiri, plus error-error yang sering muncul biar kalian nggak ngalamin hal yang sama kayak saya dulu.

1. Membuat dan Memanggil Fungsi

fungsi paling sederhana itu yang tinggal dipanggil tanpa butuh data apa pun dari luar:

def sapa():
    print("Halo, selamat datang!")

# Panggil fungsi
sapa()
sapa()  # Bisa dipanggil berkali-kali

perhatikan anatomi fungsi di atas:

• def adalah kata kunci penanda bahwa ini fungsi
• sapa itu nama fungsinya, bebas mau dikasih nama apa, asal mengikuti aturan penamaan python (huruf, underscore, nggak diawali angka, bukan kata kunci)
• kurung () tempat parameter, di contoh ini kosong karena fungsi tidak butuh data dari luar
• titik dua : di akhir baris def, dan baris di bawahnya harus di-indent (biasanya 4 spasi), kalau lupa indent python bakal error IndentationError
• isi fungsi berupa satu atau beberapa baris pernyataan, di sini cuma print()

fungsi yang sudah dibuat bisa dipanggil berkali-kali sesuka kalian. ini yang bikin fungsi itu hemat: bayangkan kalau baris print("Halo, selamat datang!") harus ditulis manual di sepuluh tempat, iya banget bisa, tapi kalau teksnya mau diganti, sepuluh tempat itu harus diubah satu-satu.

fungsi juga bisa dikasih dokumentasi singkat pakai docstring, tiga tanda kutip di baris pertama:

def sapa():
    """Menyapa pengunjung program."""
    print("Halo, selamat datang!")

docstring ini nggak ngefek ke jalannya program, tapi berguna saat kalian (atau orang lain) baca kode beberapa bulan kemudian, tinggal panggil help(sapa) atau sapa.__doc__ buat lihat penjelasannya.

Fungsi dengan Parameter

fungsi baru terasa kuat kalau dia bisa nerima data dari luar lewat parameter:

def sapa_nama(nama):
    print(f"Halo {nama}!")

sapa_nama("Andi")   # Halo Andi!
sapa_nama("Budi")   # Halo Budi!

parameter nama di sini bertugas nampung nilai yang dikasih pas fungsi dipanggil. pas sapa_nama("Andi") dijalankan, nama berisi "Andi"; pas sapa_nama("Budi"), nama berisi "Budi". satu fungsi, bisa melayani input yang bermacam-macam.

error yang paling sering saya lihat dari pemula di bagian ini ada dua. pertama, manggil fungsi tanpa ngasih argumen padahal fungsinya butuh parameter:

sapa_nama()  # ❌ TypeError: sapa_nama() missing 1 required positional argument: 'nama'

kedua, kebalikannya, ngasih argumen lebih banyak dari parameter yang ada:

sapa_nama("Andi", "Budi")  # ❌ TypeError: sapa_nama() takes 1 positional argument but 2 were given

pesan errornya memang panjang, tapi intinya jelas, jumlah argumen yang dikasih harus pas sama jumlah parameter yang didefinisikan.

2. Return Value

fungsi yang tadi cuma nge-print hasilnya ke layar. beda cerita kalau hasilnya mau dipakai lagi buat proses berikutnya, di situ return berperan:

def tambah(a, b):
    return a + b

hasil = tambah(5, 3)
print(hasil)  # 8

nilai yang di-return bisa ditampung ke variabel, kayak hasil di atas, atau langsung dipakai di ekspresi lain:

print(tambah(5, 3) * 2)   # 16 — hasil fungsi langsung dikali dua
print(tambah(1, 2) + tambah(3, 4))  # 10 — fungsi bisa dipanggil di dalam ekspresi

ada dua hal penting soal return yang sering bikin bingung:

pertama, return langsung menghentikan fungsi. kode setelah return di dalam fungsi yang sama nggak akan pernah jalan:

def cek_positif(angka):
    if angka < 0:
        return "negatif"
    return "positif"

print(cek_positif(-5))  # negatif
print(cek_positif(7))   # positif

di contoh ini, kalau angka negatif, fungsi berhenti di return "negatif" dan baris return "positif" nggak dieksekusi. ini pola yang lumrah: beberapa return di beberapa cabang kondisinya.

kedua, fungsi tanpa return bakal ngembaliin None secara otomatis. None itu nilai khusus python buat nyatain “nggak ada apa-apa”:

def cetak_saja(teks):
    print(teks)

hasil = cetak_saja("halo")
print(hasil)  # None — padahal baris print-nya jalan

jadi kalau suatu saat fungsi kalian balikin None padahal nggak diharapkan, cek dulu, jangan-jangan lupa nulis return-nya.

Print vs Return: Ini yang Paling Sering Bikin Pemula Nyangkut

dari pengalaman saya ngejawab pertanyaan pemula, kebingungan terbesar itu bukan di sintaks def, tapi di bedanya print sama return. dua-duanya keliatan “mengeluarkan” sesuatu, padahal kerjanya beda jauh.

print itu cuma nampilin teks ke layar, selesai. hasilnya tidak bisa dipakai untuk perhitungan apa pun:

def tambah_print(a, b):
    print(a + b)   # cuma tampil di layar

hasil = tambah_print(2, 3)  # 5 tampil di layar
print(hasil)                 # None

sedangkan return itu ngasih nilai hasilnya kembali ke pemanggil, jadi bisa ditampung atau diolah:

def tambah_return(a, b):
    return a + b

hasil = tambah_return(2, 3)
print(hasil)          # 5
print(hasil * 10)     # 50 — hasilnya bisa dipakai lagi

cara gampang ngingetnya begini: print itu kayak orang ngomong, hasilnya hilang begitu selesai ngomong. return itu kayak orang ngasih barang, barangnya bisa dibawa ke mana-mana. kalau fungsi kalian cuma buat nampilin laporan, pakai print. kalau hasilnya mau dipakai di kode lain, wajib return.

Multiple Return

banyak bahasa pemrograman cuma bisa ngembaliin satu nilai, python nggak. python bisa ngembaliin beberapa nilai sekaligus:

def hitung(a, b):
    jumlah = a + b
    selisih = a - b
    return jumlah, selisih

x, y = hitung(10, 4)
print(x)  # 14
print(y)  # 6

sebenernya di balik layar, return jumlah, selisih itu ngembaliin sebuah tuple, lalu x, y = ... membongkar (unpacking) tuple itu ke dua variabel. kalau kalian penasaran, coba tangkap tanpa unpacking:

hasil = hitung(10, 4)
print(hasil)  # (14, 6) — tuple
print(hasil[0])  # 14

cara ini juga valid. multiple return sangat praktis buat fungsi yang hasilnya memang sepasang, misalnya bagi hasil dan sisa bagi, atau koordinat x dan y.

3. Jenis Parameter

parameter di python itu nggak cuma satu macam. ada empat pola yang wajib kalian kenal, masing-masing punya kegunaan sendiri. tapi sebelum masuk ke situ, satu hal yang harus lurus dulu karena banyak tutorial yang nggak ngebedain dengan jelas: parameter itu beda sama argumen.

• parameter itu variabel yang ditulis di dalam definisi fungsi, jadi semacam tempat nampung yang disediakan di awal
• argumen itu nilai aslinya yang dikasih pas fungsi dipanggil

contohnya di def sapa(nama), nama itu parameter. pas dipanggil sapa("Andi"), nilai "Andi" itulah argumennya. jadi satu baris definisi itu menyediakan parameter, dan tiap kali dipanggil kita mengisi argumen. kedengerannya sepele, tapi istilah ini bakal kepake terus di dokumentasi dan pesan error python, jadi enaknya lurus dari sekarang.

Default Parameter

parameter bisa dikasih nilai bawaan, jadi kalau dipanggil tanpa argumen di posisi itu, nilai bawaannya yang dipakai:

def sapa(nama, pesan="Halo"):
    print(f"{pesan} {nama}!")

sapa("Andi")          # Halo Andi! — pesan pakai bawaan
sapa("Budi", "Selamat pagi")  # Selamat pagi Budi! — pesan diisi sendiri

aturan pentingnya, parameter yang punya nilai default harus diletakkan di belakang semua parameter tanpa default:

def salah(pesan="Halo", nama):  # ❌ SyntaxError: non-default argument follows default argument
    print(f"{pesan} {nama}!")

python nolak definisi kayak gitu karena bakal ambigu: pas dipanggil salah("Andi"), python bingung "Andi" itu buat pesan atau nama.

Keyword Arguments

normalnya argumen dikasih berdasarkan urutan posisinya. tapi python juga ngizinin argumen dikirim dengan menyebut nama parameternya:

def biodata(nama, umur, kota):
    print(f"{nama}, {umur} tahun, dari {kota}")

biodata(umur=25, nama="Andi", kota="Jakarta")
# Urutan tidak penting saat pakai keyword

lihat, urutan pemanggilannya umur, nama, kota tapi hasilnya tetap benar karena masing-masing disebut namanya. keyword arguments ini sangat membantu di fungsi yang parameternya banyak, bikin kode pemanggilan lebih jelas maksudnya apa.

keduanya juga bisa dicampur, yang posisi dulu baru yang keyword:

biodata("Andi", kota="Jakarta", umur=25)  # ✅ boleh
biodata(kota="Jakarta", "Andi", 25)       # ❌ SyntaxError: positional argument follows keyword argument

aturan campurnya: argumen posisi harus dilempar duluan. mau yang keyword duluan baru posisi, nggak boleh.

*args: Banyak Argumen Posisi

kadang kita nggak tau duluan berapa banyak argumen yang bakal dikasih. di situ *args datang, dia menampung semua argumen posisi ekstra jadi sebuah tuple:

def jumlahkan(*angka):
    total = sum(angka)
    return total

print(jumlahkan(1, 2, 3))       # 6
print(jumlahkan(10, 20, 30, 40)) # 100
print(jumlahkan())               # 0 — boleh nggak ngasih apa-apa

coba-coba juga kalau penasaran bentuk tuple-nya:

def tampilkan(*angka):
    print(angka)

tampilkan(1, 2, 3)  # (1, 2, 3) — tuple

nama args itu cuma konvensi, yang penting bintang *-nya. mau dinamain *nilai juga sah-sah aja.

**kwargs: Banyak Keyword Arguments

kalau *args buat argumen posisi, **kwargs buat argumen keyword yang jumlahnya bebas. dia menampung semuanya jadi sebuah dictionary:

def profil(**data):
    for key, value in data.items():
        print(f"{key}: {value}")

profil(nama="Andi", pekerjaan="Developer", kota="Jakarta")
# nama: Andi
# pekerjaan: Developer
# kota: Jakarta

ini sangat praktis buat fungsi yang harus nerima data yang bentuknya beda-beda tiap dipanggil, kayak form HTML yang kolomnya dinamis.

*args dan **kwargs juga sering dipakai barengan, terutama di decorator yang kita bahas nanti:

def fungsi_fleksibel(a, b, *args, **kwargs):
    print(a, b)          # argumen posisi wajib
    print(args)          # tuple sisa argumen posisi
    print(kwargs)        # dict sisa argumen keyword

fungsi_fleksibel(1, 2, 3, 4, nama="Andi")
# 1 2
# (3, 4)
# {'nama': 'Andi'}

4. Scope Variabel

variabel itu punya jangkauan (scope). variabel yang didefinisikan di luar fungsi itu global, bisa diakses di mana saja. variabel yang didefinisikan di dalam fungsi itu lokal, cuma hidup di dalam fungsi itu:

x = 10  # Global scope

def fungsi():
    x = 5  # Local scope — beda dengan x global
    print(f"Local x: {x}")

fungsi()  # Local x: 5
print(f"Global x: {x}")  # Global x: 10

perhatikan, x = 5 di dalam fungsi itu membuat variabel baru yang kebetulan namanya sama, bukan mengubah x yang global. jadi nilai x di luar fungsi tetap 10. ini sering bikin bingung pemula yang mengira fungsi itu bisa seenaknya ngubah variabel global.

variabel global sendiri bisa dibaca dari dalam fungsi tanpa masalah:

nama_aplikasi = "Sistem Nilai"

def sapa():
    print(f"Selamat datang di {nama_aplikasi}")

sapa()  # Selamat datang di Sistem Nilai

tapi kalau mau benar-benar mengubah variabel global dari dalam fungsi, harus dideklarasikan global dulu:

def ubah_global():
    global x
    x = 20

ubah_global()
print(f"x setelah diubah: {x}")  # x setelah diubah: 20

saya saranin, pakai global itu seminim mungkin. kalau fungsi butuh nilai dari luar dan hasilnya mau dipakai lagi di luar, lebih bersih kalau lewat parameter dan return:

def tambah_nilai(x, y):
    return x + y

x = tambah_nilai(10, 20)  # hasilnya dipegang di luar, bukan diubah dari dalam

kode yang bergantung pada global yang diubah-ubah sembarangan itu susah dilacak, karena fungsi yang sama bisa ngasih hasil beda tergantung kapan dipanggil.

5. Fungsi Rekursif

rekursif itu gaya nulis fungsi yang manggil dirinya sendiri. kedengarannya aneh, tapi ini pola yang pas buat masalah yang bisa dipecah jadi versi lebih kecil dari dirinya sendiri:

def faktorial(n):
    if n <= 1:
        return 1
    return n * faktorial(n - 1)

print(faktorial(5))  # 120

coba telusuri cara kerjanya buat faktorial(5):

• faktorial(5) → 5 * faktorial(4)
• faktorial(4) → 4 * faktorial(3)
• faktorial(3) → 3 * faktorial(2)
• faktorial(2) → 2 * faktorial(1)
• faktorial(1) → 1 (ini base case, berhenti di sini)

jadi hasilnya 5 * 4 * 3 * 2 * 1 = 120. bagian if n <= 1: return 1 itu disebut base case, kondisi berhenti yang wajib ada. tanpa base case, fungsi bakal manggil dirinya sendiri terus sampai python kehabisan memori:

def tanpa_henti(n):
    return tanpa_henti(n + 1)  # ❌ RecursionError: maximum recursion depth exceeded

pesan RecursionError itu tanda kalian lupa base case atau base case-nya nggak pernah kesentuh. contoh lain yang klasik, deret fibonacci:

def fibonacci(n):
    if n <= 1:
        return n
    return fibonacci(n-1) + fibonacci(n-2)

for i in range(10):
    print(fibonacci(i), end=" ")  # 0 1 1 2 3 5 8 13 21 34

catatan jujur dari saya: rekursif itu elegan untuk kasus kayak gini, tapi nggak selalu yang tercepat. fibonacci versi rekursif ini lambat buat input besar karena manggil fungsi yang sama berulang kali. kalau performa penting, versi iteratif pakai loop biasanya lebih efisien:

def fibonacci_iteratif(n):
    a, b = 0, 1
    for _ in range(n):
        a, b = b, a + b
    return a

print(fibonacci_iteratif(9))  # 34

jadi gunakan rekursif kalau kodenya jadi lebih jelas dan inputnya kecil, dan jangan ragu pindah ke loop kalau datanya besar.

6. Lambda Expression

lambda itu fungsi anonim, fungsi tanpa nama, yang cuma satu baris ekspresi:

# Fungsi biasa
def kuadrat(x):
    return x ** 2

# Lambda
kuadrat = lambda x: x ** 2

print(kuadrat(5))  # 25

strukturnya gampang: lambda diikuti parameter (boleh lebih dari satu, dipisah koma), titik dua, lalu ekspresi yang hasilnya otomatis jadi nilai baliknya. tanpa return, tanpa def, tanpa nama.

kalau hanya dilihat dari contoh di atas, lambda keliatan cuma singkatan def. memang itu intinya: lambda buat fungsi yang sangat sederhana, satu ekspresi, yang dipakai sekali atau dilempar ke fungsi lain. bedanya dengan def, lambda nggak bisa berisi lebih dari satu ekspresi dan nggak bisa punya statement kayak if biasa, for, atau return eksplisit:

lambda x: if x > 0: return x  # ❌ SyntaxError — lambda cuma boleh satu ekspresi

tapi kalian tetap bisa bikin lambda yang berisi kondisional satu baris kayak gini:

kategori = lambda u: "dewasa" if u >= 18 else "anak-anak"

print(kategori(20))  # dewasa
print(kategori(15))  # anak-anak

Lambda untuk Sorting

kegunaan paling umum lambda di project saya: jadi key untuk sorting. contohnya ngurutin list of dictionary berdasarkan satu kolom:

mahasiswa = [
    {"nama": "Andi", "ipk": 3.2},
    {"nama": "Budi", "ipk": 3.8},
    {"nama": "Cici", "ipk": 3.5},
]

# Urutkan berdasarkan IPK
mahasiswa.sort(key=lambda m: m["ipk"], reverse=True)
for m in mahasiswa:
    print(f"{m['nama']}: {m['ipk']}")

di sini, key=lambda m: m["ipk"] bilang ke python: “setiap elemen list ini, yang dipakai pembandingnya adalah nilai ipk-nya”. tanpa lambda, kalian harus nulis fungsi def kecil-kecilan cuma buat satu baris ini.

kalian juga bisa ngurutin berdasarkan string, misalnya nama:

data = ["Banana", "apple", "Cherry"]
data.sort(key=lambda s: s.lower())
print(data)  # ['apple', 'Banana', 'Cherry']

dengan key=lambda s: s.lower(), perbandingannya memakai versi lowercase, jadi huruf besar kecil nggak ngaruh ke urutan.

Lambda dengan map(), filter(), sorted()

lambda juga paling sering dipasangin sama fungsi-fungsi manipulasi koleksi: map() buat transformasi, filter() buat seleksi, dan sorted() buat urutan:

angka = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

# map — kuadrat setiap angka
kuadrat = list(map(lambda x: x ** 2, angka))
print(kuadrat)  # [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

# filter — ambil genap
genap = list(filter(lambda x: x % 2 == 0, angka))
print(genap)  # [2, 4, 6, 8, 10]

kenapa dibungkus list()? karena map() dan filter() di python modern ngembaliin objek iterator yang malas (lazy), tidak langsung ngasih list. bungkus list() biar hasilnya jadi list yang bisa langsung dilihat dan dipakai.

lambda paling sering saya pakai buat sorted() dengan key, misalnya ngurutin list of dictionary berdasarkan satu kolom, kayak contoh ranking di studi kasus bawah. kalau logikanya lebih dari satu baris, mending pakai fungsi def biasa biar lebih gampang dibaca.

jadi aturan kasarnya: lambda buat fungsi sekali pakai yang sederhana, def buat fungsi yang lebih panjang atau yang dipakai berulang di banyak tempat.

7. Decorator: Fungsi Pembungkus

decorator itu fungsi yang membungkus fungsi lain, buat nambah perilaku sebelum atau sesudah fungsi aslinya jalan, tanpa mengubah isi fungsi itu sendiri:

def logger(func):
    def wrapper(*args, **kwargs):
        print(f"Memanggil {func.__name__}...")
        hasil = func(*args, **kwargs)
        print(f"Selesai: {hasil}")
        return hasil
    return wrapper

@logger
def tambah(a, b):
    return a + b

tambah(10, 5)
# Memanggil tambah...
# Selesai: 15

cara bacanya, @logger di atas def tambah itu sama persis dengan nulis tambah = logger(tambah) setelah definisi. jadi fungsi tambah yang asli diganti dengan wrapper, dan di dalam wrapper itulah log tambahannya ditulis. fungsi aslinya tetap utuh, return a + b nggak berubah.

kenapa *args, **kwargs di wrapper? karena wrapper harus bisa meneruskan argumen apa pun yang tadinya dikasih ke fungsi asli. dengan *args dan **kwargs, decorator ini jadi generik, bisa dipasang ke fungsi yang parameternya berapa pun.

contoh kedua yang sering saya pakai sendiri, decorator buat ngukur lama eksekusi fungsi:

import time

def timer(func):
    def wrapper(*args, **kwargs):
        mulai = time.time()
        hasil = func(*args, **kwargs)
        selesai = time.time()
        print(f"{func.__name__} jalan selama {selesai - mulai:.4f} detik")
        return hasil
    return wrapper

@timer
def proses_data():
    total = 0
    for i in range(1000000):
        total += i
    return total

proses_data()
# proses_data jalan selama 0.0521 detik (angka bakal beda-beda)

decorator ini berguna banget waktu mau cek fungsi mana yang jadi biang keladi lambatnya program. tinggal tempel @timer, jalanin, lihat hasilnya, cabut kalau sudah tidak perlu. nggak perlu ngotak-atik isi fungsinya.

pola umum decorator lain di project nyata: cek login sebelum masuk ke fungsi (autentikasi), logging request, retry kalau fungsi gagal, atau cache hasil perhitungan.

8. Studi Kasus

nah, sebelum ke studi kasus, kalau kalian masih ngerasa materi function ini numpuk banget, nggak apa-apa. banyak kok yang butuh baca ulang dua tiga kali.

supaya makin kebayang, ini program manajemen nilai mahasiswa yang menggabungkan beberapa konsep di atas: fungsi, parameter, return, dictionary, lambda buat sorting, dan scope global:

# Program manajemen nilai mahasiswa
nilai_mahasiswa = {}

def tambah_nilai(nim, nama, nilai):
    nilai_mahasiswa[nim] = {"nama": nama, "nilai": nilai}
    print(f"Data {nama} ditambahkan")

def cari_nilai(nim):
    return nilai_mahasiswa.get(nim, "Tidak ditemukan")

def hapus_nilai(nim):
    if nim in nilai_mahasiswa:
        del nilai_mahasiswa[nim]
        print(f"Data dengan NIM {nim} dihapus")
    else:
        print(f"Data dengan NIM {nim} tidak ada")

def rata_rata():
    if not nilai_mahasiswa:
        return 0
    total = sum(d["nilai"] for d in nilai_mahasiswa.values())
    return total / len(nilai_mahasiswa)

def ranking():
    sorted_mhs = sorted(
        nilai_mahasiswa.items(),
        key=lambda x: x[1]["nilai"],
        reverse=True
    )
    for i, (nim, data) in enumerate(sorted_mhs, 1):
        print(f"{i}. {data['nama']}: {data['nilai']}")

alurnya gampang diikuti: nilai_mahasiswa itu dictionary global yang nyimpen data, key-nya NIM, value-nya dictionary {"nama": ..., "nilai": ...}. tambah_nilai ngisi dictionary itu, cari_nilai buat ngecek satu data (pakai .get() biar aman kalau NIM-nya nggak ada), hapus_nilai buat ngilangin data, rata_rata ngitung pakai generator sum(...), dan ranking ngurutin pakai lambda.

demo jalannya:

# Demo
tambah_nilai("G001", "Andi", 85)
tambah_nilai("G002", "Budi", 92)
tambah_nilai("G003", "Cici", 78)

print(f"\nRata-rata: {rata_rata():.2f}")
print("\nRanking:")
ranking()

print("\nCari G002:", cari_nilai("G002"))
print("Cari G999:", cari_nilai("G999"))  # nggak ada, balik ke default

hapus_nilai("G003")
print(f"\nRata-rata setelah G003 dihapus: {rata_rata():.2f}")

hasil yang muncul kurang lebih begini:

Data Andi ditambahkan
Data Budi ditambahkan
Data Cici ditambahkan

Rata-rata: 85.00

Ranking:
1. Budi: 92
2. Andi: 85
3. Cici: 78

Cari G002: {'nama': 'Budi', 'nilai': 92}
Cari G999: Tidak ditemukan
Data dengan NIM G003 dihapus

Rata-rata setelah G003 dihapus: 88.50

lihat betapa rapi program ini dibanding kalau semua logika ditulis panjang lebar di satu alur tanpa fungsi. tiap tugas punya fungsi sendiri, bisa dipanggil kapan saja, dan kalau ada bug tinggal periksa fungsi yang bersangkutan.

Kesimpulan

rangkaian konsep function yang tadi dibahas:

• def, bikin fungsi dengan nama
• return, ngembaliin nilai, kalau tanpa return hasilnya None
• parameter, ada positional, keyword, default, *args, sama **kwargs
• scope, variabel lokal di dalam fungsi, global di luar, hati-hati pakai global
• rekursif, fungsi manggil diri sendiri, wajib ada base case
• lambda, fungsi anonim satu baris, cocok buat map/filter/sort
• decorator, bungkus fungsi buat nambah fungsionalitas tanpa ngubah isinya

latihan paling efektif buat ngunci materi ini: ambil program yang pernah kalian tulis dan refactor semua bagian yang ngulang jadi fungsi. terus coba ganti salah satu fungsi sederhananya jadi lambda, dan pasang decorator logger di salah satu fungsi buat lihat perilakunya. dari situ semua konsep ini bakal nyambung sendiri.

artikel terkait:

• Perulangan for dan while di Python
• List, tuple, set, dan dictionary di Python