Coba perhatikan pola ini. Di artikel-artikel sebelumnya, setiap kali kita butuh menghitung nilai akhir, kita menulis rumus yang sama:
nilai_akhir = (nilai_tugas * 0.30) + (nilai_uts * 0.35) + (nilai_uas * 0.35)
Untuk program dengan satu siswa, itu oke. Tapi bagaimana kalau ada 32 siswa? Atau kamu butuh rumus itu di tiga bagian program yang berbeda? Kamu akan menyalin baris yang sama berkali-kali.
Dan bayangkan suatu hari bobot nilainya berubah — misalnya tugas jadi 40%. Kamu harus mencari dan mengedit setiap salinan rumus itu satu per satu. Sangat rawan kesalahan dan melelahkan.
Inilah masalah yang fungsi selesaikan. Fungsi memungkinkan kamu menulis satu blok kode sekali, lalu memanggilnya berulang kali dari mana saja dalam program. Perubahan cukup dilakukan di satu tempat, dan seluruh program ikut berubah otomatis.
Analogi: Mesin Fotokopi di TU Sekolah
Bayangkan mesin fotokopi di ruang Tata Usaha. Mesin itu adalah sebuah “fungsi”:
- Kamu memasukkan dokumen (input / parameter)
- Mesin memproses secara otomatis (body fungsi)
- Kamu mendapatkan fotokopian hasilnya (output / return)
Yang penting: mesin yang sama bisa dipakai oleh siapa saja — Pak Guru, Bu Guru, staf TU — tanpa perlu membangun mesin baru setiap kali ada yang butuh fotokopi.
Fungsi Python bekerja persis seperti itu.
Struktur Dasar Fungsi
def nama_fungsi(parameter1, parameter2):
"""Penjelasan singkat apa yang fungsi ini lakukan."""
# isi/body fungsi
hasil = parameter1 + parameter2
return hasil
Ada empat bagian yang wajib dipahami:
| Bagian | Keterangan |
|---|---|
def | Kata kunci yang menandai definisi fungsi |
nama_fungsi | Nama yang kamu berikan untuk fungsi ini |
parameter | Data yang fungsi butuhkan sebagai input (opsional) |
return | Nilai yang dikembalikan fungsi sebagai output (opsional) |
Fungsi Paling Sederhana
# Mendefinisikan fungsi
def sapa_kelas():
print("Selamat pagi, semuanya!")
print("Semangat belajar hari ini!")
# Memanggil fungsi — cukup tulis namanya
sapa_kelas() # Output: Selamat pagi, semuanya!
# Semangat belajar hari ini!
# Panggil lagi kapanpun dibutuhkan
sapa_kelas() # Output yang sama muncul lagi
Perhatikan perbedaan antara mendefinisikan (def sapa_kelas():) dan memanggil (sapa_kelas()). Mendefinisikan hanya menulis “resepnya” — fungsi belum dijalankan. Memanggil adalah saat fungsi benar-benar dieksekusi.
Parameter — Memberi Input ke Fungsi
Parameter adalah data yang kamu kirimkan ke fungsi saat memanggilnya. Ibarat mesin fotokopi yang butuh dokumen untuk diproses.
def sapa_siswa(nama):
print(f"Halo, {nama}! Selamat datang di kelas.")
# Panggil dengan argumen berbeda
sapa_siswa("Andi") # Output: Halo, Andi! Selamat datang di kelas.
sapa_siswa("Budi") # Output: Halo, Budi! Selamat datang di kelas.
sapa_siswa("Citra") # Output: Halo, Citra! Selamat datang di kelas.
Satu fungsi, tiga output berbeda — tergantung input yang diberikan. Ini yang disebut reusable (bisa dipakai ulang).
Banyak Parameter
Fungsi bisa punya lebih dari satu parameter, dipisah koma:
def cetak_nilai_siswa(nama, mata_pelajaran, nilai):
status = "Tuntas ✅" if nilai >= 75 else "Remedi ⚠️"
print(f" {nama:<20} | {mata_pelajaran:<15} | {nilai:>5.1f} | {status}")
# Header
print(f" {'Nama':<20} | {'Mata Pelajaran':<15} | {'Nilai':>5} | Status")
print(" " + "-" * 55)
# Panggil berkali-kali dengan data berbeda
cetak_nilai_siswa("Andi Saputra", "Matematika", 88.0)
cetak_nilai_siswa("Budi Santoso", "Matematika", 72.5)
cetak_nilai_siswa("Citra Dewi", "Matematika", 91.0)
Output:
Nama | Mata Pelajaran | Nilai | Status
-------------------------------------------------------
Andi Saputra | Matematika | 88.0 | Tuntas ✅
Budi Santoso | Matematika | 72.5 | Remedi ⚠️
Citra Dewi | Matematika | 91.0 | Tuntas ✅
Return — Mengambil Hasil dari Fungsi
return adalah cara fungsi mengirimkan hasilnya kembali ke pemanggil. Fungsi dengan return bisa disimpan ke variabel dan dipakai dalam perhitungan lanjutan.
def hitung_nilai_akhir(tugas, uts, uas):
"""Hitung nilai akhir semester dengan bobot raport."""
nilai_akhir = (tugas * 0.30) + (uts * 0.35) + (uas * 0.35)
return nilai_akhir
# Hasil return bisa disimpan ke variabel
nilai_andi = hitung_nilai_akhir(80, 85, 90)
nilai_budi = hitung_nilai_akhir(70, 68, 72)
print(f"Nilai Andi: {nilai_andi:.2f}") # Output: Nilai Andi: 85.25
print(f"Nilai Budi: {nilai_budi:.2f}") # Output: Nilai Budi: 70.00
# Atau langsung dipakai dalam ekspresi
print(f"Selisih: {nilai_andi - nilai_budi:.2f}") # Output: Selisih: 15.25
⚠️ Setelah
return, fungsi langsung berhenti! Kode apapun yang ditulis setelahreturndi dalam fungsi tidak akan pernah dijalankan.
Tanpa Fungsi vs. Dengan Fungsi
Sebelum kita lanjut ke fitur-fitur fungsi yang lebih canggih, lihat betapa besarnya perbedaan antara kode tanpa fungsi dan dengan fungsi untuk kasus yang sama:
Keuntungan menggunakan fungsi:
- Tidak ada pengulangan kode — tulis sekali, pakai berkali-kali
- Mudah diubah — ganti di satu tempat, semua ikut berubah
- Mudah dibaca — nama fungsi menjelaskan apa yang dilakukan
- Mudah di-debug — kalau ada bug, cari di satu tempat saja
Variasi Fungsi yang Perlu Kamu Tahu
Parameter Default
Kamu bisa memberikan nilai default pada parameter. Kalau parameter itu tidak diisi saat memanggil fungsi, nilai default yang dipakai:
def cek_kelulusan(nilai, kkm=75):
"""Cek lulus/tidak dengan KKM yang fleksibel."""
if nilai >= kkm:
return f"Lulus (nilai {nilai} ≥ KKM {kkm})"
else:
return f"Remedi (nilai {nilai} < KKM {kkm})"
# Pakai KKM default (75)
print(cek_kelulusan(80)) # Output: Lulus (nilai 80 ≥ KKM 75)
# Tentukan KKM sendiri
print(cek_kelulusan(80, kkm=80)) # Output: Remedi (nilai 80 < KKM 80) — nah lho!
print(cek_kelulusan(80, kkm=70)) # Output: Lulus (nilai 80 ≥ KKM 70)
Parameter default sangat berguna untuk fungsi yang sering dipakai dengan pengaturan yang sama, tapi sesekali butuh diubah. Di contoh ini, kebanyakan mapel KKM-nya 75 — tapi beberapa mapel mungkin punya KKM 70 atau 80.
Mengembalikan Banyak Nilai Sekaligus
Python memungkinkan fungsi mengembalikan lebih dari satu nilai sekaligus, dipisah koma:
def analisis_nilai(daftar_nilai):
"""Analisis statistik dasar dari daftar nilai."""
tertinggi = max(daftar_nilai)
terendah = min(daftar_nilai)
rata_rata = sum(daftar_nilai) / len(daftar_nilai)
jumlah_lulus = len([n for n in daftar_nilai if n >= 75])
return tertinggi, terendah, rata_rata, jumlah_lulus
# Terima semua nilai sekaligus
nilai_kelas = [85, 72, 91, 78, 65, 88, 70, 95]
maks, mini, rata, lulus = analisis_nilai(nilai_kelas)
print(f"Nilai tertinggi : {maks}")
print(f"Nilai terendah : {mini}")
print(f"Rata-rata kelas : {rata:.2f}")
print(f"Siswa lulus : {lulus} dari {len(nilai_kelas)}")
Output:
Nilai tertinggi : 95
Nilai terendah : 65
Rata-rata kelas : 80.50
Siswa lulus : 5 dari 8
Docstring — Dokumentasi Fungsi
Docstring adalah string penjelasan yang ditulis tepat setelah baris def, diapit tiga tanda kutip. Ini bukan komentar biasa — Python bisa membacanya secara khusus lewat help():
def hitung_nilai_akhir(tugas, uts, uas, bobot=(0.30, 0.35, 0.35)):
"""
Hitung nilai akhir semester dengan bobot yang bisa dikonfigurasi.
Parameter:
tugas (float): Nilai komponen tugas harian
uts (float): Nilai Ujian Tengah Semester
uas (float): Nilai Ujian Akhir Semester
bobot (tuple): Bobot (tugas, uts, uas), default (0.30, 0.35, 0.35)
Return:
float: Nilai akhir semester
"""
return (tugas * bobot[0]) + (uts * bobot[1]) + (uas * bobot[2])
help(hitung_nilai_akhir) # Cetak docstring di terminal
Membiasakan diri menulis docstring adalah kebiasaan programmer profesional. Kode yang terdokumentasi dengan baik jauh lebih mudah dipahami orang lain — dan dirimu sendiri sebulan kemudian!
Scope — Variabel di Dalam Fungsi Tetap di Dalam
Ada satu hal penting yang harus dipahami: variabel yang dibuat di dalam fungsi tidak bisa diakses dari luar fungsi. Ini disebut scope (ruang lingkup):
def hitung_bonus(nilai):
bonus = 5 # variabel lokal — hanya ada di dalam fungsi ini
return nilai + bonus
hasil = hitung_bonus(85)
print(hasil) # Output: 90 ← ini bisa
# print(bonus) ← NameError: name 'bonus' is not defined!
# variabel 'bonus' tidak ada di luar fungsi
Ini sebenarnya fitur, bukan bug! Dengan scope, kamu tidak perlu khawatir nama variabel di dalam fungsi akan bertabrakan dengan variabel di bagian lain program.
Studi Kasus: Sistem Evaluasi Modular
Pak Fauzi adalah koordinator kurikulum di SMK Nusantara. Setiap akhir semester, beliau harus mengolah data nilai dari enam mata pelajaran untuk setiap siswa, lalu mencetak rekap lengkap. Dengan pendekatan modular — memecah program menjadi fungsi-fungsi kecil — kode menjadi jauh lebih rapi dan mudah dikelola.
# ============================================================
# Sistem Evaluasi Siswa — Modular (Berbasis Fungsi)
# Koordinator Kurikulum SMK Nusantara
# ============================================================
# ── BLOK 1: Fungsi-Fungsi Utama ──────────────────────────────
def hitung_nilai_akhir(tugas, uts, uas):
"""Hitung nilai akhir dengan bobot 30/35/35."""
return round((tugas * 0.30) + (uts * 0.35) + (uas * 0.35), 2)
def tentukan_predikat(nilai):
"""Konversi nilai angka ke predikat huruf dan keterangan."""
if nilai >= 90:
return "A", "Sangat Baik"
elif nilai >= 80:
return "B", "Baik"
elif nilai >= 70:
return "C", "Cukup"
elif nilai >= 60:
return "D", "Kurang"
else:
return "E", "Sangat Kurang"
def analisis_kelas(semua_nilai):
"""
Analisis statistik nilai seluruh kelas.
Return: (rata_rata, tertinggi, terendah, jml_lulus, jml_remedi)
"""
rata = sum(semua_nilai) / len(semua_nilai)
maks = max(semua_nilai)
mini = min(semua_nilai)
lulus = len([n for n in semua_nilai if n >= 75])
remedi = len(semua_nilai) - lulus
return rata, maks, mini, lulus, remedi
def cetak_header_raport(nama_siswa, kelas):
"""Cetak header raport siswa."""
print("\n" + "=" * 54)
print(f"{'LAPORAN HASIL BELAJAR SISWA':^54}")
print(f"{'SMK Nusantara — Semester Ganjil 2024/2025':^54}")
print("=" * 54)
print(f" Nama Siswa : {nama_siswa}")
print(f" Kelas : {kelas}")
print("-" * 54)
def cetak_tabel_nilai(data_nilai):
"""
Cetak tabel nilai per mata pelajaran.
data_nilai: list of dict {"mapel", "tugas", "uts", "uas"}
"""
print(f" {'Mata Pelajaran':<20} {'Nilai':>6} {'Pred':>4} {'Keterangan'}")
print(" " + "-" * 48)
semua_nilai_akhir = []
for item in data_nilai:
na = hitung_nilai_akhir(item["tugas"], item["uts"], item["uas"])
pred, ket = tentukan_predikat(na)
status = "✅" if na >= 75 else "⚠️"
print(f" {item['mapel']:<20} {na:>6.2f} {pred:>4} {ket} {status}")
semua_nilai_akhir.append(na)
return semua_nilai_akhir
def cetak_rekap_akhir(semua_nilai_akhir):
"""Cetak rekap statistik di akhir raport."""
rata, maks, mini, lulus, remedi = analisis_kelas(semua_nilai_akhir)
rata_pred, rata_ket = tentukan_predikat(rata)
print("-" * 54)
print(f" {'Rata-rata Keseluruhan':<20} {rata:>6.2f} {rata_pred:>4} {rata_ket}")
print("=" * 54)
print(f" Nilai tertinggi : {maks:.2f} | Nilai terendah : {mini:.2f}")
print(f" Mapel tuntas : {lulus} | Mapel remedi : {remedi}")
status_naik = "🎓 NAIK KELAS" if rata >= 70 and remedi <= 2 else "⚠️ PERLU EVALUASI"
print(f" Status : {status_naik}")
print("=" * 54)
# ── BLOK 2: Data Siswa ────────────────────────────────────────
siswa = {
"nama" : "Andi Saputra",
"kelas" : "X TKJ 1"
}
mata_pelajaran = [
{"mapel": "Matematika", "tugas": 80, "uts": 82, "uas": 88},
{"mapel": "B. Indonesia", "tugas": 85, "uts": 90, "uas": 88},
{"mapel": "B. Inggris", "tugas": 78, "uts": 72, "uas": 80},
{"mapel": "Fisika", "tugas": 75, "uts": 70, "uas": 78},
{"mapel": "Informatika", "tugas": 92, "uts": 95, "uas": 90},
{"mapel": "PKN", "tugas": 88, "uts": 85, "uas": 87},
]
# ── BLOK 3: Jalankan Sistem ───────────────────────────────────
cetak_header_raport(siswa["nama"], siswa["kelas"])
semua_nilai = cetak_tabel_nilai(mata_pelajaran)
cetak_rekap_akhir(semua_nilai)
Output:
======================================================
LAPORAN HASIL BELAJAR SISWA
SMK Nusantara — Semester Ganjil 2024/2025
======================================================
Nama Siswa : Andi Saputra
Kelas : X TKJ 1
------------------------------------------------------
Mata Pelajaran Nilai Pred Keterangan
------------------------------------------------
Matematika 83.90 B Baik ✅
B. Indonesia 87.75 B Baik ✅
B. Inggris 76.90 C Cukup ✅
Fisika 74.25 C Cukup ⚠️
Informatika 92.25 A Sangat Baik ✅
PKN 86.70 B Baik ✅
------------------------------------------------------
Rata-rata Keseluruhan 83.63 B Baik
======================================================
Nilai tertinggi : 92.25 | Nilai terendah : 74.25
Mapel tuntas : 5 | Mapel remedi : 1
Status : 🎓 NAIK KELAS
======================================================
Perhatikan bagaimana kode terpecah menjadi fungsi-fungsi kecil yang masing-masing punya tanggung jawab tunggal:
hitung_nilai_akhir()— hanya hitung, tidak cetaktentukan_predikat()— hanya konversi angka ke hurufanalisis_kelas()— hanya statistikcetak_header_raport()— hanya tampilan headercetak_tabel_nilai()— hanya tampilan tabelcetak_rekap_akhir()— hanya rekap penutup
Setiap fungsi bisa diuji, diubah, atau diganti secara independen tanpa merusak yang lain. Inilah prinsip modular programming yang jadi fondasi cara kerja programmer profesional.
Latihan: Kalkulator SPP Modular
Buat file kalkulator_spp_modular.py. Program ini memisahkan logika perhitungan, validasi, dan tampilan ke dalam fungsi-fungsi terpisah:
# =======================================
# Kalkulator Tagihan SPP — Modular
# =======================================
def hitung_tagihan(spp_bulanan, bulan_nunggak, persen_denda=5):
"""
Hitung total tagihan SPP dengan denda.
Return:
tuple: (pokok, denda, total)
"""
pokok = spp_bulanan * bulan_nunggak
denda = pokok * (persen_denda / 100)
total = pokok + denda
return pokok, denda, total
def input_angka_valid(prompt, min_val=0, max_val=None):
"""Minta input angka dari pengguna dengan validasi."""
while True:
try:
nilai = float(input(prompt))
if nilai < min_val:
print(f" ❌ Nilai minimal {min_val}. Coba lagi.")
continue
if max_val and nilai > max_val:
print(f" ❌ Nilai maksimal {max_val}. Coba lagi.")
continue
return nilai
except ValueError:
print(" ❌ Masukkan angka yang valid!")
def cetak_struk(nama, kelas, spp, bulan, pokok, denda, total):
"""Cetak struk tagihan SPP."""
print("\n" + "=" * 42)
print(f"{'TAGIHAN SPP SEKOLAH':^42}")
print(f"{'SMK Nusantara':^42}")
print("=" * 42)
print(f" Nama : {nama.title()}")
print(f" Kelas : {kelas.upper()}")
print("-" * 42)
print(f" SPP/bulan : Rp {spp:>10,.0f}")
print(f" Tunggakan : {bulan:.0f} bulan")
print(f" Pokok : Rp {pokok:>10,.0f}")
print(f" Denda (5%) : Rp {denda:>10,.0f}")
print("-" * 42)
print(f" TOTAL BAYAR : Rp {total:>10,.0f}")
print("=" * 42)
if total == 0:
print(" ✅ Tidak ada tunggakan!")
elif total <= 500_000:
print(" ℹ️ Segera lunasi sebelum akhir bulan.")
else:
print(" ⚠️ Harap segera menghubungi bagian TU.")
# ── Program Utama ──
print("=== KALKULATOR TAGIHAN SPP ===\n")
nama_siswa = input("Nama siswa : ")
kelas_siswa = input("Kelas : ")
spp_per_bln = input_angka_valid("SPP per bulan (Rp): ", min_val=0)
bln_nunggak = input_angka_valid("Bulan belum bayar : ", min_val=0, max_val=12)
pokok, denda, total = hitung_tagihan(spp_per_bln, bln_nunggak)
cetak_struk(nama_siswa, kelas_siswa, spp_per_bln, bln_nunggak, pokok, denda, total)
Perhatikan bagaimana input_angka_valid() — fungsi validasi input — bisa dipakai dua kali (untuk SPP dan untuk bulan) dengan parameter yang berbeda. Inilah keindahan fungsi yang reusable!
Rangkuman
| Konsep | Sintaks | Catatan |
|---|---|---|
| Definisi fungsi | def nama(param): | Fungsi belum dijalankan |
| Memanggil fungsi | nama(argumen) | Fungsi baru dijalankan |
| Tanpa parameter | def sapa(): | Tidak butuh input |
| Satu parameter | def sapa(nama): | Satu input |
| Banyak parameter | def hitung(a, b, c): | Dipisah koma |
| Parameter default | def cek(n, kkm=75): | Nilai otomatis jika tak diisi |
| Return satu nilai | return hasil | Kembalikan satu data |
| Return banyak | return a, b, c | Kembalikan beberapa sekaligus |
| Docstring | """Penjelasan fungsi""" | Dokumentasi di baris pertama body |
| Scope | Variabel lokal = hanya di dalam | Tidak bisa diakses dari luar |
Artikel Selanjutnya
Di artikel berikutnya kita masuk ke File I/O — cara Python menyimpan dan membaca data dari file. Ini penting karena selama ini semua data yang kita input langsung hilang begitu program ditutup. Dengan file, data nilai, absensi, dan profil siswa bisa tersimpan permanen dan dibuka lagi kapanpun!
Ada pertanyaan soal fungsi, parameter default, atau scope? Tulis di komentar! 💬
Artikel ini merupakan bagian dari seri “Belajar Python untuk Sekolah” — panduan coding Python bergaya santai untuk pelajar SMA/SMK/MA Indonesia.
Tinggalkan Balasan