BAB 23: Argumen Fungsi

Di bab sebelumnya, kita membangun sistem kuis dengan beberapa fungsi: tampilkan_skor, hitung_nilai_akhir, dan tambah_peserta. Semua argumen dilempar berdasarkan posisi — hitung_nilai_akhir(87, 90) berarti skor_kuis=87 dan skor_tugas=90, karena urutan deklarasi parameter adalah (skor_kuis, skor_tugas).

Selama jumlah parameternya dua atau tiga, ini mudah diingat. Tapi bayangkan fungsi dengan lima atau enam parameter — kamu harus hafal urutan yang tepat setiap kali memanggilnya. Python punya solusi yang lebih baik: tiga cara berbeda untuk melempar argumen yang masing-masing punya keunggulan tersendiri.

Positional Argument

Cara yang sudah kita gunakan sejak BAB 22 disebut positional argument — argumen yang nilainya ditentukan berdasarkan posisi. Nilai pertama yang kamu berikan akan masuk ke parameter pertama, nilai kedua ke parameter kedua, dan seterusnya.

# kuis.py — positional argument
def tampilkan_hasil(nama: str, nilai: float, keterangan: str):
    print(f"{nama}: {nilai:.1f} ({keterangan})")

tampilkan_hasil("Rina", 88.2, "Lulus")
tampilkan_hasil("Budi", 77.2, "Lulus")
tampilkan_hasil("Dani", 51.0, "Tidak Lulus")

Rina: 88.2 (Lulus)
Budi: 77.2 (Lulus)
Dani: 51.0 (Tidak Lulus)

Ini berfungsi dengan baik selama urutannya benar. Masalahnya, Python tidak bisa mendeteksi jika kamu menukar argumen yang bertipe sama:

# urutan terbalik — Python tidak protes karena tipenya kompatibel
tampilkan_hasil("Lulus", 88.2, "Rina")   # salah secara logika, bukan error

Lulus: 88.2 (Rina)

Output ini salah, tapi Python menerimanya tanpa keluhan karena semua argumen bertipe str dan float sesuai posisi. Tanggung jawab menjaga urutan sepenuhnya ada pada kamu sebagai pemanggil.

Keyword Argument

Keyword argument memungkinkan kamu menyebut nama parameter secara eksplisit saat memanggil fungsi. Hasilnya, urutan argumen tidak lagi penting.

# kuis.py — keyword argument
tampilkan_hasil(nilai=88.2, nama="Rina", keterangan="Lulus")
tampilkan_hasil(keterangan="Lulus", nilai=77.2, nama="Budi")

Rina: 88.2 (Lulus)
Budi: 77.2 (Lulus)

Kedua pemanggilan menghasilkan output yang benar meskipun urutan argumennya berbeda-beda. Python mencocokkan berdasarkan nama, bukan posisi.

Keyword argument sangat berguna untuk fungsi yang parameternya banyak dan bertipe serupa. Dengan menyebut nama parameter, kode pemanggilan menjadi dokumentasi dirinya sendiri:

# tanpa keyword argument — apa arti 0.6 dan 0.4?
hitung_nilai_akhir(87, 90, 0.6, 0.4)

# dengan keyword argument — maksudnya langsung jelas
hitung_nilai_akhir(skor_kuis=87, skor_tugas=90, bobot_kuis=0.6, bobot_tugas=0.4)

Aturan Campuran

Kamu boleh mencampur positional dan keyword argument dalam satu pemanggilan, dengan satu syarat: semua positional argument harus muncul sebelum keyword argument.

# benar — positional dulu, keyword belakangan
tampilkan_hasil("Rina", nilai=88.2, keterangan="Lulus")

# salah — keyword tidak boleh diikuti positional
tampilkan_hasil(nama="Rina", 88.2, keterangan="Lulus")  # SyntaxError

  File "kuis.py", line 7
    tampilkan_hasil(nama="Rina", 88.2, keterangan="Lulus")
                                 ^
SyntaxError: positional argument follows keyword argument

Python mendeteksi pelanggaran ini saat parsing kode — sebelum program dijalankan — sehingga kamu langsung tahu ada yang salah.

tampilkan_hasil("Rina",  nilai=88.2,  keterangan="Lulus")
                |______| |_________________________________|
                positional       keyword (di belakang)        OK

tampilkan_hasil(nama="Rina",  88.2,  keterangan="Lulus")
                |___________| |____|
                   keyword    positional                    SyntaxError!

A clean technical diagram showing the rule for mixing positional and keyword arguments in Python. Two rows, each showing a function call. First row labeled with a green checkmark: "tampilkan_hasil('Rina', nilai=88.2, keterangan='Lulus')". Under the first argument 'Rina', a blue downward bracket labeled "positional". Under the remaining two arguments, an orange downward bracket labeled "keyword". Below the brackets a green label: "Benar — positional sebelum keyword". Second row labeled with a red X: "tampilkan_hasil(nama='Rina', 88.2, keterangan='Lulus')". Under 'nama=Rina' an orange bracket labeled "keyword", under '88.2' a blue bracket labeled "positional". Below, a red label: "SyntaxError — positional setelah keyword". White background, flat design, monospace font for code, blue (#3B82F6) for positional, orange (#F97316) for keyword, green (#22C55E) for valid, red (#EF4444) for invalid. 16:9 aspect ratio. All text labels in Indonesian.

Optional Argument

Optional argument dibuat dengan memberi nilai default pada parameter di definisi fungsi. Parameter dengan default value bisa tidak diisi saat pemanggilan — jika tidak diisi, Python menggunakan nilai defaultnya.

Kembali ke fungsi hitung_nilai_akhir dari BAB 22. Selama ini kita menggunakan bobot tetap 60% untuk kuis dan 40% untuk tugas. Tapi bagaimana jika beberapa kelas punya distribusi bobot berbeda? Kita bisa membuat bobotnya configurable dengan nilai default yang masuk akal:

# kuis.py — optional argument dengan nilai default
def hitung_nilai_akhir(
    skor_kuis: int,
    skor_tugas: int,
    bobot_kuis: float = 0.6,
    bobot_tugas: float = 0.4
) -> float:
    return (skor_kuis * bobot_kuis) + (skor_tugas * bobot_tugas)

# memanggil tanpa menyebut bobot — pakai default
nilai_rina = hitung_nilai_akhir(87, 90)

# memanggil dengan bobot kustom
nilai_kelas_khusus = hitung_nilai_akhir(87, 90, bobot_kuis=0.7, bobot_tugas=0.3)

print(f"Bobot standar: {nilai_rina:.1f}")
print(f"Bobot khusus:  {nilai_kelas_khusus:.1f}")

Bobot standar: 88.2
Bobot khusus:  87.9

Parameter bobot_kuis dan bobot_tugas menjadi opsional. Pemanggilan lama hitung_nilai_akhir(87, 90) tetap berfungsi tanpa perubahan — kompatibel ke belakang sepenuhnya.

Urutan Deklarasi Parameter

Ada aturan yang tidak boleh dilanggar: parameter wajib (tanpa default) harus dideklarasikan sebelum parameter opsional (dengan default). Urutan terbalik menyebabkan SyntaxError:

# salah — parameter opsional sebelum parameter wajib
def hitung_nilai_akhir(bobot_kuis: float = 0.6, skor_kuis: int) -> float:
    pass   # SyntaxError: non-default argument follows default argument

Ini logis: jika parameter opsional boleh muncul di awal, Python tidak bisa tahu apakah argumen pertama yang kamu berikan dimaksudkan untuk parameter opsional atau parameter wajib.

  File "kuis.py", line 2
    def hitung_nilai_akhir(bobot_kuis: float = 0.6, skor_kuis: int) -> float:
                                                    ^^^^^^^^^
SyntaxError: non-default argument follows default argument

Ilustrasi urutan yang benar:

Kombinasi Ketiganya

Ketiga jenis argumen bisa digunakan bersama. Fungsi berikut menerima parameter wajib dan opsional, dan bisa dipanggil dengan berbagai cara:

# kuis.py — kombinasi lengkap
def buat_laporan(
    nama_peserta: str,
    nilai_akhir: float,
    keterangan: str = "Lulus",
    tampilkan_detail: bool = False
) -> str:
    laporan = f"{nama_peserta}: {nilai_akhir:.1f} — {keterangan}"
    if tampilkan_detail:
        laporan += f"\n  [Detail: bobot kuis 60%, bobot tugas 40%]"
    return laporan

peserta = [("Rina", 88.2), ("Budi", 77.2), ("Dani", 51.0)]

for nama, nilai in peserta:
    status = "Lulus" if nilai >= 60 else "Tidak Lulus"
    print(buat_laporan(nama, nilai, keterangan=status))

print()
# cetak satu dengan detail
print(buat_laporan("Rina", 88.2, tampilkan_detail=True))

Rina: 88.2 — Lulus
Budi: 77.2 — Lulus
Dani: 51.0 — Tidak Lulus

Rina: 88.2 — Lulus
  [Detail: bobot kuis 60%, bobot tugas 40%]

Perhatikan pemanggilan buat_laporan(nama, nilai, keterangan=status) — dua argumen pertama dilempar secara positional, sementara keterangan dilempar sebagai keyword. Parameter tampilkan_detail tidak disebut sama sekali, sehingga Python menggunakan nilai defaultnya (False).

Pada pemanggilan terakhir, kita melompati keterangan dan langsung menyebut tampilkan_detail menggunakan keyword argument. Ini hanya mungkin karena kita menggunakan nama parameter secara eksplisit — jika menggunakan positional, kita harus memberikan nilai untuk keterangan terlebih dahulu.

Perbandingan Ketiga Pendekatan

Berikut ringkasan kapan masing-masing digunakan:

Kombinasi yang paling umum dalam kode Python nyata: parameter wajib dilempar secara positional, parameter opsional dilempar secara keyword jika berbeda dari default.

Latihan

Tiga latihan yang membangun di atas sistem kuis yang sudah kita kerjakan:

1. Modifikasi fungsi tampilkan_skor dari BAB 22 sehingga ia menerima parameter opsional lebar: int = 20 yang menentukan lebar kolom nama saat dicetak. Panggil fungsi ini dengan nilai lebar yang berbeda-beda dan amati perbedaan tampilannya. Gunakan f-string dengan alignment formatting: f"{nama:<{lebar}}".

2. Tulis fungsi cetak_tabel_hasil(daftar: list, urut_berdasarkan: str = "nama", tampilkan_nomor: bool = True) yang menerima list berisi tuple (nama, nilai) lalu mencetak tabel terurut. Parameter urut_berdasarkan menentukan apakah pengurutan berdasarkan "nama" atau "nilai". Uji semua kombinasi parameternya.

3. Tulis fungsi filter_dan_format(daftar_nilai: list, batas: float = 60.0, format_output: str = "singkat") -> list yang memfilter nilai berdasarkan batas lalu memformat hasilnya. Jika format_output="singkat", kembalikan list angka. Jika format_output="lengkap", kembalikan list string dalam format "Nilai: XX.X — Lulus".

Argumen adalah jembatan antara fungsi dan data yang hendak diolahnya. Dengan menguasai positional, keyword, dan optional argument, kamu punya kontrol penuh atas bagaimana fungsi-fungsimu dipanggil — apakah ringkas dan cepat, atau eksplisit dan readable. Topik ini juga jadi fondasi untuk memahami dua fitur Python yang lebih advanced: *args dan **kwargs, yang memungkinkan fungsi menerima argumen dengan jumlah tak terbatas.

Referensi

1. 1Python Docs — More on Defining Functions
2. 2PEP 3132 — Extended Iterable Unpacking
3. 3PEP 8 — Function and Variable Names