Fungsi di Python: def, return, argumen default dan keyword

Fungsi adalah blok langkah yang diberi nama

Setiap kali kamu menulis beberapa baris yang sama lebih dari sekali, atau ingin memberi nama pada sepotong kecil logika, kamu sudah siap menulis fungsi. Fungsi adalah alat sungguhan pertama untuk mengelola kerumitan di program Python.

Bentuk dasarnya:

def greet(name):
    print(f"Hello, {name}")

greet("Ada")
greet("Boris")

Penjelasannya:

• def adalah kata kunci yang memulai definisi fungsi.
• greet adalah nama fungsinya.
• (name) adalah daftar parameter, yaitu input yang diterima fungsi.
• Titik dua mengakhiri bagian kepala; blok yang diindentasi di bawahnya adalah badan fungsi.
• greet("Ada") adalah sebuah pemanggilan. Python menjalankan badan fungsi dengan name diikat ke "Ada".

Fungsi diam saja sampai dipanggil. Mendefinisikannya tidak menjalankannya. Memanggilnya dengan greet("Ada") yang menjalankannya.

Parameter dan argumen

Kata parameter adalah nama di dalam definisi fungsi. Kata argumen adalah nilai yang dikirimkan saat kamu memanggilnya. Dalam obrolan santai ini tidak terlalu penting, tapi perbedaannya membantu saat membaca pesan error.

def power(base, exponent):
    return base ** exponent

print(power(2, 10))
print(power(5, 3))

Di sini base dan exponent adalah parameter. 2 dan 10 adalah argumen. Python mengikatnya sesuai urutan: argumen pertama ke parameter pertama, dan seterusnya.

return: mengirim nilai kembali

print menulis ke layar. return menyerahkan sebuah nilai kembali ke pemanggil agar bisa dipakai:

def power(base, exponent):
    return base ** exponent

result = power(2, 10)
print(result + 1)

Tanpa return, fungsi mengembalikan None secara default:

def greet(name):
    print(f"Hello, {name}")

value = greet("Ada")
print("got back:", value)   # got back: None

return juga langsung mengakhiri fungsi. Kamu akan sering melihat return lebih awal dipakai untuk keluar dari kasus khusus sebelum logika utama:

def discount(price, percent):
    if percent < 0 or percent > 100:
        return None
    return price * (1 - percent / 100)

print(discount(50, 20))
print(discount(50, 150))

Return lebih awal menjaga badan utama agar tidak bersarang terlalu dalam di if/else.

Argumen default

Sebuah parameter bisa punya nilai default, yang dipakai saat pemanggil tidak memberikannya:

def greet(name, greeting="Hello"):
    print(f"{greeting}, {name}!")

greet("Ada")
greet("Boris", "Good morning")

Semua parameter dengan nilai default harus ditulis setelah parameter tanpa default. def f(a, b=1, c): adalah syntax error.

Jebakan nilai default yang mutable

Ini jebakan Python yang paling terkenal. Perhatikan:

def add_item(item, items=[]):
    items.append(item)
    return items

print(add_item("apple"))
print(add_item("banana"))

Kamu mungkin mengira setiap pemanggilan dimulai dengan list kosong. Ternyata list default itu dipakai bersama di semua pemanggilan, dan item-itemnya menumpuk. Python mengevaluasi nilai default sekali, saat fungsi didefinisikan, lalu memakai list yang sama itu selamanya.

Pola yang aman adalah memakai None sebagai default dan membuat list-nya di dalam fungsi:

def add_item(item, items=None):
    if items is None:
        items = []
    items.append(item)
    return items

print(add_item("apple"))
print(add_item("banana"))

Sekarang setiap pemanggilan yang tidak mengirim items mendapat list baru. Aturan ini berlaku untuk list, dict, set, apa pun yang mutable.

Argumen keyword

Kamu bisa mengirim argumen berdasarkan nama, bukan posisi. Dengan begitu kamu bisa melewatkan parameter di tengah dan membuat pemanggilan yang panjang lebih mudah dibaca:

def post(title, body, draft=False, tags=None):
    status = "draft" if draft else "published"
    print(f"[{status}] {title}")
    print(body)
    print("tags:", tags or [])

post("Python functions", "How to write them", draft=True, tags=["python", "tutorial"])

Argumen posisional dan keyword boleh dicampur, tapi yang posisional harus lebih dulu:

post("Title", body="Body text", draft=True)    # fine
# post(body="Body", "Title")                    # SyntaxError

Begitu sebuah fungsi punya lebih dari tiga atau empat parameter, mengutamakan argumen keyword membuat pemanggilannya jauh lebih mudah dibaca.

Parameter positional-only dan keyword-only

Python memungkinkan kamu menandai beberapa parameter agar hanya bisa diisi berdasarkan posisi (dengan /) atau hanya berdasarkan keyword (dengan *):

def configure(env, /, *, debug=False, log_level="info"):
    print(env, debug, log_level)

configure("prod")                          # fine: env positional
configure("prod", debug=True)              # fine
# configure(env="prod")                    # error: env is positional-only
# configure("prod", True, "info")          # error: debug and log_level are keyword-only

Kamu belum butuh ini di hari pertama. Fitur ini berguna saat merancang API dan ingin mengunci cara pemanggil memakai fungsimu.

Docstring dan penamaan

Baris pertama di dalam fungsi bisa berupa docstring, yaitu string dengan tiga tanda kutip yang diperlakukan Python sebagai dokumentasi:

def discount(price, percent):
    """Return the final price after applying a percentage discount."""
    return price * (1 - percent / 100)

help(discount)

Alat seperti help(), tooltip di IDE, dan generator dokumentasi membaca docstring secara otomatis. Satu baris saja jauh lebih baik daripada tidak ada.

Dan tolong, pikirkan penamaan:

• Nama fungsi sebaiknya berupa kata kerja: fetch_profile, compute_total, is_valid.
• Pakai lower_snake_case.
• Fungsi yang mengembalikan boolean sering diawali is_, has_, atau can_.

Nama yang bagus membuat tempat pemanggilannya jelas dengan sendirinya tanpa perlu komentar.

Pure function lebih mudah dipahami

Fungsi pure mengembalikan output yang sama untuk input yang sama dan tidak punya efek samping: ia tidak mengubah state global, tidak mencetak ke stdout (kecuali untuk debugging), dan tidak menulis ke file.

# Pure - easy to test, easy to reason about.
def total(price, tax_rate):
    return price * (1 + tax_rate)

# Impure - modifies an external variable.
cart = []
def add_to_cart(item):
    cart.append(item)

print(total(100, 0.08))
add_to_cart("apple")
print(cart)

Keduanya punya tempat masing-masing, tapi untuk kode yang ingin kamu pakai ulang dan uji, usahakan sebanyak mungkin memakai pure function.

Contoh kecil yang berjalan

Fungsi singkat yang menggabungkan nilai default, argumen keyword, dan return:

def format_address(street, city, country="US", zip_code=None):
    parts = [street, city]
    if zip_code:
        parts.append(zip_code)
    parts.append(country)
    return ", ".join(parts)

print(format_address("1 Main St", "Boston"))
print(format_address("1 Main St", "Boston", zip_code="02108"))
print(format_address("Place Vendôme 1", "Paris", country="France"))

Berikutnya: daftar argumen yang fleksibel

Kadang kamu tidak tahu berapa banyak argumen yang akan dipakai untuk memanggil sebuah fungsi, atau kamu ingin meneruskan argumen apa pun yang datang ke fungsi lain. *args dan **kwargs menangani hal itu. Itulah halaman berikutnya.