Fungsi dan Modul

Seorang analis menjalankan perhitungan yang sama berulang kali: total tagihan dengan pajak, rata-rata penjualan, diskon pelanggan member. Kalau rumusnya disalin-tempel ke mana-mana, satu perbaikan kecil harus diulang di banyak tempat — sumber kesalahan yang mahal. Fungsi menyelesaikan masalah itu: logika ditulis sekali, diberi nama yang jelas, lalu dipanggil berkali-kali. Modul melangkah lebih jauh dengan memindahkan fungsi-fungsi ke berkas terpisah agar bisa dipakai lintas proyek. Pada chapter ini kita membungkus logika Toko Kopi Kita menjadi fungsi, memakai modul standar statistics, membuat modul sendiri, dan mengenal lambda yang akan sering muncul ketika kita bekerja dengan pandas.

Mendefinisikan Fungsi dengan def #

Kata kunci def memulai definisi fungsi: nama fungsi, parameter masukan, badan kode, dan nilai keluaran lewat return. Parameter boleh punya nilai bawaan sehingga pemanggil cukup mengisi yang penting, dan satu return bisa mengirim beberapa nilai sekaligus.

def total_bayar(nilai, pajak=0.1):
    """Hitung total tagihan dari nilai transaksi dan tarif pajak."""
    return nilai + nilai * pajak


def rincian_bayar(nilai):
    """Kembalikan tiga nilai sekaligus: dasar, pajak, dan total bayar."""
    pajak = nilai * 0.1
    return nilai, pajak, nilai + pajak


print("Total bayar biasa      :", total_bayar(42))
print("Total bayar bebas pajak:", total_bayar(42, pajak=0))

dasar, pajak, total = rincian_bayar(42)
print("Rincian: dasar", dasar, "+ pajak", pajak, "=", total)

Output yang Dihasilkan:

Total bayar biasa      : 46.2
Total bayar bebas pajak: 42
Rincian: dasar 42 + pajak 4.2 = 46.2

Mari kita bedah bagian-bagian pentingnya:

1. Baris 1 (def total_bayar(...)): fungsi menerima dua parameter; pajak=0.1 adalah nilai bawaan sehingga pemanggilan total_bayar(42) cukup membawa satu argumen.
2. Baris 2 (docstring): string pertama pada badan fungsi menjadi dokumentasi ringkas. Tulis selalu — ia menjelaskan maksud fungsi tanpa memaksa pembaca membedah isinya.
3. Baris 9 (return nilai, pajak, ...): return dengan beberapa nilai sebenarnya mengirim satu tuple — persis record yang kita kenal pada chapter Struktur Data Python .
4. Baris 13 (pajak=0): pemanggil boleh menimpa nilai bawaan dengan menyebut nama parameternya — berguna untuk transaksi bebas pajak tanpa menduplikasi fungsi.
5. Baris 15 (unpacking hasil): tiga nilai kembalian diuraikan sekaligus ke dasar, pajak, total, sehingga pemanggil bebas memakai masing-masing.

Ruang Lingkup Variabel dalam Fungsi #

Variabel yang dibuat di dalam fungsi bersifat lokal: ia hidup hanya selama pemanggilan berlangsung dan tidak terlihat dari luar. Sebaliknya, fungsi tetap bisa membaca variabel level modul (global) selama tidak menugaskan nilai baru ke nama tersebut.

tarif_diskon = 0.1  # variabel global di level modul

def harga_setelah_diskon(harga):
    """Hitung harga akhir setelah diskon memakai variabel global."""
    potongan = harga * tarif_diskon  # variabel lokal milik fungsi ini
    return harga - potongan

print("Kopi susu jadi:", harga_setelah_diskon(24))

try:
    print(potongan)
except NameError as err:
    print("Di luar fungsi tidak dikenal:", err)

Output yang Dihasilkan:

Kopi susu jadi: 21.6
Di luar fungsi tidak dikenal: name 'potongan' is not defined

Dua hal terjadi di sini. Pertama, harga_setelah_diskon() membaca tarif_diskon dari luar fungsi tanpa masalah — cukup satu tempat untuk mengubah tarif diskon seisi program. Kedua, potongan hanya hidup di dalam fungsi; ketika diakses dari luar, Python membalas NameError, yang kita tangkap agar pesannya tercetak rapi. Praktik yang sehat: fungsi menerima apa yang dibutuhkan lewat parameter dan mengembalikan hasil lewat return, sehingga ketergantungan pada variabel global tetap minim.

Memakai Modul Standar statistics #

Python hadir dengan pustaka standar — kumpulan modul siap pakai yang ikut terpasang bersama Python. Untuk analisis data, modul statistics termasuk yang paling sering dipakai: ia menyediakan mean() dan median() tanpa perlu memasang library apa pun.

import statistics

penjualan_harian = [120, 135, 98, 150, 122, 168, 175]

print("Rata-rata penjualan:", round(statistics.mean(penjualan_harian), 2))
print("Median penjualan   :", statistics.median(penjualan_harian))
print("Rentang penjualan  :", min(penjualan_harian), "-", max(penjualan_harian))

Output yang Dihasilkan:

Rata-rata penjualan: 138.29
Median penjualan   : 135
Rentang penjualan  : 98 - 175

Baris import statistics membawa modul tersebut ke dalam program; setelah itu fungsinya dipanggil dengan awalan statistics.. Perhatikan juga kenapa analis peduli pada mean dan median sekaligus: rata-rata tergeser oleh satu hari yang luar biasa ramai, sedangkan median tetap tenang di nilai tengah — pada data penjualan yang kadang punya lonjakan, median sering menggambarkan hari “biasa” dengan lebih jujur. Kita sudah bertemu perhitungan rata-rata manual dengan sum() dan len(); modul ini menghemat penulisan tersebut dan memperkecil peluang salah tulis rumus.

Membuat Modul Sendiri #

Ketika fungsi-fungsi buatan kita mulai stabil dan dipakai di banyak notebook, saatnya memindahkannya ke berkas .py — itulah modul buatan sendiri. Pola kerjanya: simpan fungsi di berkas, lalu impor seperti modul standar. Contoh berikut menyimulasikan berkas analitik_toko.py di dalam direktori sementara supaya latihan tidak meninggalkan berkas percobaan di folder proyek:

import sys
import tempfile
from pathlib import Path

with tempfile.TemporaryDirectory() as tmp:
    berkas_modul = Path(tmp) / "analitik_toko.py"
    berkas_modul.write_text(
        "def rerata_penjualan(data):\n"
        '    """Hitung rata-rata penjualan harian (cangkir)."""\n'
        "    return sum(data) / len(data)\n"
    )
    sys.path.insert(0, tmp)

    from analitik_toko import rerata_penjualan

    print("Rata-rata pekan ini:", rerata_penjualan([120, 135, 98, 150]))

Output yang Dihasilkan:

Rata-rata pekan ini: 125.75

Urutan langkahnya sederhana namun penting:

1. Baris 6-11 (menulis berkas modul): berkas analitik_toko.py dibuat lalu diisi satu fungsi lengkap dengan docstring — modul hanyalah berkas Python biasa.
2. Baris 12 (sys.path.insert): Python mencari modul pada daftar lokasi bernama sys.path; kita menyisipkan direktori sementara ke posisi terdepan agar modul kita ditemukan.
3. Baris 14 (from ... import ...): fungsi diimpor dengan namanya, lalu dipanggil seperti fungsi lokal.

Pada proyek sesungguhnya kita tidak perlu langkah sementara ini — cukup letakkan berkas modul di folder src/ sebagaimana dirancang pada chapter Struktur Proyek Data Science , dan notebook mana pun dapat mengimpornya. Manfaatnya nyata: logika ditulis sekali, diperbaiki sekali, dan semua analisis otomatis memakai versi terbaru.

Lambda untuk Fungsi Sekali Pakai #

Kadang kita butuh fungsi sangat pendek — satu ekspresi saja — yang tidak sepadan kalau diberi nama. Untuk itu ada lambda: fungsi tanpa nama yang didefinisikan di tempat ia dipakai. Pola paling umum adalah sebagai argumen key pada pengurutan:

harga = {"kopi susu": 24, "americano": 22, "matcha": 28, "teh tawar": 20}

urut_murah = sorted(harga.items(), key=lambda item: item[1])
for produk, nilai in urut_murah:
    print(f"{produk:12} Rp{nilai}.000")

Output yang Dihasilkan:

teh tawar    Rp20.000
americano    Rp22.000
kopi susu    Rp24.000
matcha       Rp28.000

Bagian lambda item: item[1] berarti: terima satu pasangan item, kembalikan elemen keduanya (harganya). Fungsi sorted() lalu mengurutkan daftar pasangan berdasarkan nilai kembalian tersebut — hasilnya daftar menu dari yang termurah. Lambda bukan pengganti def: gunakan hanya untuk ekspresi pendek di tempat fungsi itu sendiri dipakai. Kita mencatatnya sejak sekarang karena pola ini muncul terus-menerus di pandas, misalnya saat mentransformasi satu kolom pada chapter Dasar Pandas .

Referensi Resmi #

• Modul statistics — rujukan resmi fungsi statistik pustaka standar seperti mean dan median.
• Python Packaging User Guide — panduan menata kode dan modul dalam proyek Python yang lebih besar.

Rangkuman #

• def mendefinisikan fungsi; parameter boleh bernilai bawaan, return mengirim hasil — termasuk beberapa nilai sekaligus dalam bentuk tuple.
• Docstring mendokumentasikan maksud fungsi; variabel lokal hidup hanya di dalam pemanggilan, sementara variabel global bisa dibaca dari dalam fungsi.
• Pustaka standar menyediakan modul siap pakai seperti statistics dengan mean() dan median() tanpa pemasangan tambahan.
• Modul buatan sendiri adalah berkas .py yang diimpor lewat sys.path; pada proyek nyata ia hidup di folder src/.
• lambda membuat fungsi satu ekspresi tanpa nama, paling sering dipakai sebagai argumen key dan nanti pada transformasi kolom pandas.

Logika kita kini tertata dalam fungsi dan modul. Berikutnya ada kebiasaan penulisan khas Python yang membuat pembuatan list baru dari data lama menjadi ringkas: List Comprehension — idiom yang akan muncul di mana-mana dalam kode analisis data.