*args dan **kwargs di Python: argumen posisional dan keyword yang fleksibel

Saat kamu tidak tahu berapa banyak argumennya

Kebanyakan fungsi menerima jumlah parameter yang tetap. Tapi sesekali kamu butuh sesuatu yang lebih fleksibel: logger yang menerima pesan berapa pun jumlahnya, fungsi pembungkus yang meneruskan apa pun yang diterimanya ke fungsi lain, atau fungsi untuk membuat grafik yang menerima konfigurasi tanpa tahu opsi mana yang akan dipakai pemanggilnya.

Python menangani ini dengan dua penanda khusus di daftar parameter: *args dan **kwargs.

*args mengumpulkan argumen posisional

Satu tanda bintang berarti "kemas semua argumen posisional tambahan ke dalam sebuah tuple":

def log_all(*args):
    for message in args:
        print("LOG:", message)

log_all("starting")
log_all("ready", "set", "go")
log_all()    # zero arguments is fine

Di dalam fungsi, args adalah tuple biasa. Kamu bisa melakukan perulangan di atasnya, mengambil elemennya lewat indeks, mengirimkannya ke len(), atau mengambil potongannya (slicing).

*args biasanya muncul bersama parameter yang diberi nama:

def first_then_rest(first, *rest):
    print("first:", first)
    print("rest:", rest)

first_then_rest("a")
first_then_rest("a", "b", "c", "d")

first mengambil argumen pertama, lalu *rest mengemas semua yang ada setelahnya ke dalam sebuah tuple.

**kwargs mengumpulkan argumen keyword

Dua tanda bintang melakukan hal yang sama untuk argumen keyword, dan mengemasnya ke dalam sebuah dict:

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

describe(name="Rosa", age=30, city="Lisbon")

Di dalam describe, kwargs adalah dict biasa. Key-nya adalah nama keyword dalam bentuk string.

Memakai keduanya sekaligus

Kamu bisa memakai keduanya di fungsi yang sama. Konvensinya, *args ditulis sebelum **kwargs:

def show(**kwargs):
    print(kwargs)

def logger(*args, **kwargs):
    print("positional:", args)
    print("keyword:", kwargs)

logger(1, 2, 3, level="warn", tag="api")

Urutan lengkap parameter, dari kiri ke kanan:

1. Parameter posisional biasa (wajib atau dengan nilai default).
2. *args.
3. Parameter keyword-only (semua yang ada setelah *args harus dikirim dengan keyword).
4. **kwargs.

def post(title, *tags, draft=False, **metadata):
    print(title, tags, draft, metadata)

post("Hello", "python", "docs", draft=True, author="Rosa")

title mengambil argumen posisional pertama. Sisa argumen posisional masuk ke tags. draft harus dikirim dengan keyword (karena posisinya setelah *tags). Argumen keyword lainnya masuk ke metadata.

Membongkar dengan * dan ** saat memanggil fungsi

Tanda bintang juga bekerja ke arah sebaliknya: menyebarkan sebuah sequence atau dict menjadi argumen sebuah pemanggilan:

def area(width, height):
    return width * height

dimensions = (4, 5)
print(area(*dimensions))       # spreads the tuple into two args

options = {"width": 4, "height": 5}
print(area(**options))         # spreads the dict into keyword args

Ini sangat berguna untuk meneruskan argumen:

def log(level, message):
    print(f"[{level}] {message}")

def wrapped(*args, **kwargs):
    print("before")
    result = log(*args, **kwargs)
    print("after")
    return result

wrapped("info", "starting up")
wrapped(level="warn", message="retrying")

wrapped tidak perlu tahu argumen apa yang diharapkan log. Ia cukup mengumpulkan semuanya lalu meneruskannya. Pola ini sering sekali muncul di decorator (topik yang lebih lanjut) dan fungsi pembungkus.

Kapan *args dan **kwargs bukan pilihan yang tepat

Gampang sekali terlalu bersemangat lalu memakainya di mana-mana. Ada dua peringatan:

Keduanya menyembunyikan apa yang diharapkan sebuah fungsi

Kalau setiap fungsi di kodemu berbentuk def f(*args, **kwargs), kode yang memanggilnya tidak tahu argumen apa yang valid. Pakai parameter bernama selama bisa, dan biarkan *args/**kwargs hanya membawa input yang memang jumlahnya tidak tetap atau yang hanya diteruskan.

Pesan error jadi kabur

Nama keyword yang salah ketik berubah menjadi None yang diam-diam atau KeyError jauh di dalam fungsi, bukannya langsung memunculkan "unexpected keyword argument" di tempat pemanggilan. Parameter bernama memberimu umpan balik yang jauh lebih baik.

Aturannya: pakai parameter bernama secara default, dan gunakan *args/**kwargs hanya kalau fungsinya memang fleksibel atau meneruskan argumen ke callable lain.

Contoh praktis kecil

Sebuah fungsi bantu bergaya fungsi grafik yang membungkus fungsi pihak ketiga dengan beberapa nilai default:

def styled_print(*values, sep=" | ", end="\n", **style):
    prefix = style.get("prefix", "")
    suffix = style.get("suffix", "")
    message = sep.join(str(v) for v in values)
    print(prefix + message + suffix, end=end)

styled_print("user", "action", "timestamp")
styled_print("a", "b", "c", sep=" > ", prefix="[info] ")
styled_print(42, True, None, prefix=">>> ", suffix=" <<<")

*values membuat pemanggil bisa mengirim item berapa pun jumlahnya, sedangkan **style menampung konfigurasi tambahan tanpa mengharuskan setiap opsi menjadi parameter bernama. Fungsi ini fleksibel tapi tetap mudah dipahami, karena logika di dalamnya memperlihatkan dengan jelas key apa saja yang dibacanya dari style.

Rangkuman

• *args mengemas argumen posisional tambahan ke dalam sebuah tuple.
• **kwargs mengemas argumen keyword tambahan ke dalam sebuah dict.
• Saat memanggil fungsi, *seq dan **dict membongkar ke arah sebaliknya.
• Parameter harus muncul dengan urutan: biasa → *args → keyword-only → **kwargs.
• Jangan berlebihan: parameter bernama lebih jelas kalau bisa dipakai.

Berikutnya: lambda, cara menulis fungsi kecil sekali pakai langsung di tempat.