Argumen Variabel *args / **kwargs dan Beberapa Nilai Kembalian

Pada artikel sebelumnya tentang def, kamu mendefinisikan fungsi dengan jumlah argumen yang tetap. Namun di kode nyata, jumlah argumen tidak selalu diketahui di awal, dan terkadang kamu ingin mengembalikan lebih dari satu hasil dari sekali pemanggilan.

Python menangani hal ini dengan argumen variabel dan beberapa nilai kembalian. Keduanya dibangun langsung di atas pengetahuanmu tentang tuple dan dict.

Argumen posisional variabel *args — kumpulkan ke dalam tuple

Letakkan satu tanda asterisk di depan nama argumen (*args) dan fungsi bisa menerima berapa pun jumlah argumen posisional. Di dalam fungsi, argumen-argumen tersebut tersedia sebagai tuple.

Nama args adalah konvensi, tetapi secara teknis nama deskriptif apa pun bisa dipakai — *prices, *messages, apa saja yang mudah dibaca untuk konteksnya.

# Menerima berapa pun jumlah argumen posisional
def sum_all(*prices):
    print(prices)        # (100, 200, 300)
    print(type(prices))  # <class 'tuple'>
    return sum(prices)

print(sum_all(100, 200, 300))   # 600
print(sum_all(500))             # 500 (satu juga boleh)
print(sum_all())                # 0   (nol menghasilkan tuple kosong)

Menggabungkan argumen biasa dengan *args

Letakkan argumen biasa sebelum *args dan kamu bisa mencampur argumen tetap di depan dengan bagian variabel di belakang. Menulis log(level, *messages) berarti nilai pertama diikat ke level dan sisanya dikumpulkan ke dalam tuple bernama messages. Urutannya adalah argumen biasa → *args.

def log(level, *messages):
    for m in messages:
        print(f"[{level}] {m}")

log("INFO", "Sudah dijalankan", "Terhubung")
# [INFO] Sudah dijalankan
# [INFO] Terhubung

Buat fungsi yang menerima sejumlah harga produk berapa pun dan mengembalikan totalnya.

① Definisikan def calc_total(*prices): dan return sum(prices).

② Cetak hasil calc_total(300, 500) dan calc_total(120, 280, 550, 400). Pastikan fungsi yang sama berfungsi tanpa peduli berapa banyak argumen yang kamu kirim.

(Setelah berjalan dengan benar, penjelasan akan muncul.)

Keyword argument variabel **kwargs — kumpulkan ke dalam dict

Dua tanda asterisk (`kwargs) memungkinkan fungsi menerima keyword argument apa pun dalam bentuk name=value. Di dalam fungsi, argumen-argumen tersebut tiba sebagai dict, yang membuatnya sempurna ketika key tidak diketahui di awal**.

Nama konvensionalnya adalah kwargs (singkatan dari keyword arguments).

Memanggil show(name="Budi", age=30) memberikan penerima dict {"name": "Budi", "age": 30}. Tidak perlu mendeklarasikan key di awal adalah inti dari semuanya.

def describe_user(**info):
    print(info)            # {'name': 'Budi', 'age': 30, 'city': 'Jakarta'}
    print(type(info))      # <class 'dict'>
    for key, value in info.items():
        print(f"{key}: {value}")

describe_user(name="Budi", age=30, city="Jakarta")

Menggabungkan argumen biasa dengan **kwargs

Letakkan argumen biasa sebelum **kwargs dan kamu mendapatkan **nilai wajib yang tetap** plus **field opsional yang fleksibel**. Mendefinisikan def save_user(name, **info): berarti name selalu wajib, sementara field tambahan seperti age=30 atau city="Jakarta" dikumpulkan ke dalam dict info.

def save_user(name, **info):
    print(f"name: {name}")
    for key, value in info.items():
        print(f"{key}: {value}")

save_user("Budi", age=30, city="Jakarta")
# name: Budi
# age: 30
# city: Jakarta

Tulis fungsi yang menerima informasi user sebagai keyword argument dan mencetak setiap entri di barisnya sendiri.

① Definisikan def show_profile(**info): dan loop dengan for key, value in info.items(): mencetak f"{key}: {value}".

② Panggil dengan show_profile(name="Budi", age=20, city="Bandung").

Memakai argumen biasa, *args, dan **kwargs bersama-sama

Ketiga jenis argumen bisa hidup berdampingan dalam satu fungsi. Urutannya tetap: argumen biasa → *args → **kwargs. Menulis def register(user_id, *tags, **meta): mengikat nilai pertama ke user_id, mengumpulkan argumen posisional selanjutnya ke dalam tuple tags, dan mengumpulkan setiap argumen key=value ke dalam dict meta.

def register(user_id, *tags, **meta):
    print(f"id: {user_id}")
    print(f"tags: {tags}")
    print(f"meta: {meta}")

register(1001, "admin", "beta", email="budi@example.com", active=True)
# id: 1001
# tags: ('admin', 'beta')
# meta: {'email': 'budi@example.com', 'active': True}

Tulis fungsi yang menggunakan argumen biasa, *args, dan **kwargs sekaligus.

① Definisikan def register(user_id, *tags, **meta): dan cetak tiga baris: f"id: {user_id}", f"tags: {tags}", dan f"meta: {meta}".

② Panggil register(1001, "admin", "beta", email="budi@example.com", active=True) dan amati bagaimana setiap argumen jatuh ke tempatnya.

Unpacking di sisi pemanggil — *list / **dict

Saat kamu mengirim list atau dict yang sudah ada ke fungsi, apakah kamu meletakkan * atau ** di depannya secara dramatis mengubah hasilnya.

Jika kamu mengirimnya apa adanya tanpa * atau **, list atau dict tersebut diperlakukan **sebagai satu nilai yang tidak di-unpack**. Terima dengan *args dan kamu akan berakhir dengan tuple yang berisi satu list (mis. ([1, 2, 3],)`) — itulah jebakan-nya.

Dengan `list / dict di sisi pemanggil, isinya disebar satu per satu, jadi *args / **kwargs melihat tuple (1, 2, 3) atau dict {"name": "Budi"} yang diharapkan.

def sum_all(*prices):
    return sum(prices)

prices = [120, 280, 550]

# X: dikirim sebagai satu list
# print(sum_all(prices))     # error (sum mencoba menjumlahkan list itu sendiri dengan angka)

# O: sebarkan dengan `*`
print(sum_all(*prices))       # 950 — sama dengan sum_all(120, 280, 550)

# Ide yang sama dengan dict
def announce(name, city):
    print(f"{name} dari {city}")

user = {"name": "Siti", "city": "Surabaya"}
announce(**user)              # sama dengan announce(name="Siti", city="Surabaya")

Unpacking bersinar saat mengirim data yang sudah ada

Saat kamu sudah memiliki data berupa list atau dict, unpacking memasukkannya ke dalam fungsi dalam satu baris.

Misalnya, dict user = {"name": "Siti", "city": "Surabaya"} menjadi announce(**user) — itu sama dengan menulis announce(name="Siti", city="Surabaya"). Kamu tidak perlu mengeluarkan setiap key dengan tangan.

Ambil list yang sudah ada cart_prices = [480, 1200, 320, 980] dan sebarkan ke fungsi calc_total dari sebelumnya.

① Definisikan ulang def calc_total(*prices): mengembalikan sum(prices).

② Deklarasikan cart_prices = [480, 1200, 320, 980] dan print() hasil dari calc_total(*cart_prices).

③ Coba print(calc_total(cart_prices)) tanpa asterisk. Kamu akan mendapatkan error — baca dan konfirmasikan bahwa list itu sendiri menjadi argumen pertama.

Beberapa nilai kembalian — kembalikan sebagai tuple, unpack saat menerima

return menerima beberapa nilai yang dipisah koma, dan pemanggil mendapatkan tuple dari nilai-nilai tersebut. Terima dengan a, b = function() untuk meng-unpack tuple ke beberapa variabel sekaligus.

Ini berguna kapan pun kamu ingin mengembalikan beberapa nilai dari sebuah fungsi (min dan max, username dan role, success flag dan pesan, dan seterusnya).

# Kembalikan beberapa nilai sekaligus
def get_person():
    return "Budi", 30, "Jakarta"

# Terima sebagai tuple
result = get_person()
print(result)            # ('Budi', 30, 'Jakarta')
print(type(result))      # <class 'tuple'>

# Atau unpack ke variabel terpisah
name, age, city = get_person()
print(name, age, city)   # Budi 30 Jakarta

# Contoh praktis: kembalikan min dan max bersamaan
def get_min_max(values):
    return min(values), max(values)

lowest, highest = get_min_max([120, 500, 300, 180])
print(f"min {lowest} / max {highest}")

Gunakan *rest untuk mengambil sisanya

Diberikan list nilai tes seperti return 90, 85, 78, 92, 88, tulis first, *middle, last = ... dan kamu akan mendapatkan first=90, last=88, middle=[85, 78, 92] — nilai pertama dan terakhir, dengan sisanya dikumpulkan ke list. Itu alat yang tepat ketika kamu ingin menyimpan hanya bagian awal dan akhir lalu menggulung semua di antaranya.

Tulis fungsi yang mengembalikan harga terendah dan tertinggi dari list produk.

① Definisikan def get_price_range(prices): dan return min(prices), max(prices) untuk mengirim balik dua nilai.

② Siapkan product_prices = [480, 1200, 320, 980, 650] dan unpack hasilnya dengan lowest, highest = get_price_range(product_prices).

③ Cetak f"Lowest: {lowest}" dan f"Highest: {highest}".