Arbitrary Arguments

Function print() bisa menerima satu nilai, lima nilai, atau lima puluh nilai — dan tetap bekerja. Function max() mencari nilai terbesar dari dua angka maupun dari dua puluh angka. Bagaimana definisi function seperti itu menampung jumlah argument yang tidak pasti? Python menyediakan dua mekanisme: *args untuk kumpulan positional argument dan **kwargs untuk kumpulan keyword argument. Chapter ini membahas keduanya, plus operator unpacking * dan ** di sisi pemanggil.

*args: Kumpulan Positional Argument #

Tanda bintang di depan nama parameter (*nilai) mengubah parameter tersebut menjadi penampung nol atau lebih positional argument. Di dalam badan function, nama tersebut menjadi sebuah tuple yang berisi semua argument yang masuk:

def lihat_args(*nilai):
    print(nilai)

lihat_args(1, 2, 3)
lihat_args("kopi", "teh")
lihat_args()

Output yang Dihasilkan:

(1, 2, 3)
('kopi', 'teh')
()

Pemanggilan tanpa argument menghasilkan tuple kosong (). Dengan jaminan berbentuk tuple, badan function bisa memproses argument menggunakan loop seperti biasa:

def jumlahkan(*angka):
    total = 0
    for nilai in angka:
        total = total + nilai
    return total

print(jumlahkan(1, 2, 3))
print(jumlahkan(5, 10, 15, 20))
print(jumlahkan())

Output yang Dihasilkan:

6
50
0

Pemanggilan jumlahkan(1, 2, 3) mengirim tiga argument; ketiganya terkumpul menjadi tuple (1, 2, 3) di dalam parameter angka, lalu loop menjumlahkannya. Nama args hanyalah kebiasaan komunitas — yang penting adalah tanda *, jadi *nilai maupun *angka sama sahnya. Karena bentuknya tuple, kumpulan argument tersebut tidak bisa diubah isinya setelah diterima; yang bisa kita lakukan adalah membacanya lewat loop, indeks, atau len().

**kwargs: Kumpulan Keyword Argument #

Dua tanda bintang (**data) menampung keyword argument berapa pun. Di dalam badan function, penampung tersebut berbentuk dictionary: key berasal dari nama argument, value berasal dari nilai yang dikirim:

def buat_profil(**data):
    print(data)

buat_profil(nama="Budi", usia=25, kota="Bandung")

Output yang Dihasilkan:

{'nama': 'Budi', 'usia': 25, 'kota': 'Bandung'}

Keyword argument nama="Budi" menjadi pasangan key-value 'nama': 'Budi' di dalam dictionary. Karena dictionary mempertahankan urutan penyisipan — sifat yang kita pelajari pada Chapter Dictionary — isi data tampil sesuai urutan pengiriman. Iterasinya pun standar:

def tampilkan_profil(**data):
    for kunci, nilai in data.items():
        print(f"{kunci}: {nilai}")

tampilkan_profil(nama="Siti", kota="Denpasar")

Output yang Dihasilkan:

nama: Siti
kota: Denpasar

Unpacking di Sisi Pemanggil #

Tanda * dan ** punya makna kedua: pada pemanggilan, keduanya memecah (unpacking) list dan dictionary menjadi argument terpisah. Bandingkan pengiriman list sebagai satu argument versus di-unpack:

def jumlahkan(*angka):
    total = 0
    for nilai in angka:
        total = total + nilai
    return total

def tampilkan_profil(**data):
    for kunci, nilai in data.items():
        print(f"{kunci}: {nilai}")

nilai_ujian = [4, 5, 6]
print(jumlahkan(*nilai_ujian))

identitas = {"nama": "Siti", "kota": "Denpasar"}
tampilkan_profil(**identitas)

Output yang Dihasilkan:

15
nama: Siti
kota: Denpasar

Mari kita telaah baris-baris kuncinya:

1. Baris 12 (print(jumlahkan(*nilai_ujian))): operator * memecah list [4, 5, 6] menjadi tiga argument terpisah — ekuivalen dengan menulis jumlahkan(4, 5, 6) secara manual.
2. Baris 15 (tampilkan_profil(**identitas)): operator ** memecah dictionary menjadi keyword argument — ekuivalen dengan tampilkan_profil(nama="Siti", kota="Denpasar").

Kombinasi keduanya sangat umum: data terkumpul di list atau dictionary dari sumber lain (input pengguna, file konfigurasi), lalu diteruskan ke function yang menerima argument terpisah. Pola ini juga menjadi tulang punggung function pembungkus (wrapper): pembungkus menerima *args dan **kwargs, lalu meneruskkan seluruhnya ke function asli dengan *args dan **kwargs kembali — tanpa perlu tahu isi persisnya.

Urutan Parameter Lengkap #

Saat semuanya digabung, urutan parameter pada definisi mengikuti skema tetap:

def nama_fungsi(wajib, *args, keyword_only, **kwargs):

Empat kelompok tersebut berurutan: parameter biasa, penampung *args, parameter keyword-only, lalu penampung **kwargs di paling belakang. Contoh nyatanya:

def simpan_pesanan(pembeli, *item, biaya_kirim=0, **opsi):
    print("pembeli:", pembeli)
    print("item   :", item)
    print("biaya  :", biaya_kirim)
    print("opsi   :", opsi)

simpan_pesanan("Budi", "kopi", "gula", biaya_kirim=5000, metode="transfer")

Output yang Dihasilkan:

pembeli: Budi
item   : ('kopi', 'gula')
biaya  : 5000
opsi   : {'metode': 'transfer'}

Pemanggilan di atas mengirim: satu argument untuk pembeli, dua argument posisi yang masuk ke item, satu keyword argument untuk biaya_kirim, dan satu keyword argument sisanya yang terkumpul di opsi. Perhatikan bahwa parameter setelah *item (seperti biaya_kirim) hanya bisa diisi lewat keyword — perilaku yang dibahas lebih dalam pada Chapter Positional-Only dan Keyword-Only Parameters.