🔧 Fungsi & Modularisasi Python

Tujuan Pembelajaran

Setelah mengikuti praktek ini, kamu akan mampu:

Memahami konsep fungsi sebagai "blok tugas" yang bisa dipanggil berkali-kali
Membuat fungsi sederhana menggunakan def dan memanggilnya
Menggunakan parameter untuk mengirim data ke dalam fungsi
Menggunakan return untuk mengembalikan hasil dari fungsi
Memahami konsep modularisasi — memecah program besar menjadi fungsi-fungsi kecil yang terstruktur
Menerapkan fungsi dalam program diagnosa lengkap bengkel bodi kendaraan

Konsep Dasar Fungsi

Analogi untuk Siswa TBKR:

Fungsi seperti SOP (Standar Operasional Prosedur) di bengkel. Setiap kali ada mobil masuk dengan masalah penyok, teknisi tidak perlu mengingat ulang semua langkah dari nol — mereka cukup mengikuti SOP "Perbaikan Penyok". Fungsi bekerja persis seperti itu: tulis sekali, pakai berkali-kali!

📋

Tanpa Fungsi

Tulis ulang kode yang sama setiap kali dibutuhkan → boros & rawan salah

⚙️

Dengan Fungsi

Tulis sekali, panggil berkali-kali dengan nama fungsi → efisien & rapi

🏗️

Modularisasi

Program besar dipecah jadi fungsi-fungsi kecil → mudah diperbaiki

Anatomi Sebuah Fungsi

# Ini adalah DEFINISI fungsi (buat sekali)
def nama_fungsi(parameter1, parameter2):
    # isi kode di sini (wajib diindentasi)
    hasil = parameter1 + parameter2
    return hasil # kembalikan nilai (opsional)

# Ini adalah PEMANGGILAN fungsi (bisa berkali-kali)
jawaban = nama_fungsi(10, 20)

🔑

def

Kata kunci untuk mendefinisikan (membuat) fungsi. Selalu diikuti nama fungsi dan tanda kurung.

📥

Parameter

Nilai yang dikirim ke fungsi saat dipanggil. Ibaratnya: "bahan baku" yang diterima fungsi untuk diolah.

📤

return

Mengembalikan hasil kerja fungsi ke tempat pemanggilnya. Seperti teknisi menyerahkan laporan hasil diagnosa.

📞

Pemanggilan Fungsi

Gunakan nama fungsi diikuti tanda kurung berisi nilai. Fungsi langsung bekerja saat dipanggil.

Urutan Penting! Fungsi harus didefinisikan dulu sebelum dipanggil. Seperti SOP harus ditulis dulu sebelum teknisi bisa mengikutinya.

Level 1 — Fungsi Tanpa Parameter

🟢 MUDAH Membuat dan memanggil fungsi sederhana

Fungsi paling dasar — tidak menerima input, langsung menjalankan tugasnya. Seperti SOP menyambut pelanggan yang selalu sama setiap kali ada tamu masuk bengkel.

Program mulai → panggil sapa_bengkel() → def sapa_bengkel() → cetak sambutan → lanjut ke kode berikut

# DEFINISI fungsi — tulis sekali di atas
def sapa_bengkel():
    print("==================================")
    print(" Selamat datang di Bengkel TBKR ")
    print(" Siap Melayani Dengan Terbaik ")
    print("==================================")

def tampilkan_menu():
    print("\nLayanan yang tersedia:")
    print("1. Perbaikan Penyok")
    print("2. Pengecatan")
    print("3. Pengelasan")

# PEMANGGILAN fungsi — panggil di mana saja, berapa kali pun
sapa_bengkel() # panggil pertama kali
tampilkan_menu() # panggil menu
print("\n--- Pelanggan berikutnya ---")
sapa_bengkel() # panggil lagi, tanpa tulis ulang!

Contoh Output:

==================================
Selamat datang di Bengkel TBKR
Siap Melayani Dengan Terbaik
==================================

Layanan yang tersedia:
1. Perbaikan Penyok
2. Pengecatan
3. Pengelasan

--- Pelanggan berikutnya ---
==================================
Selamat datang di Bengkel TBKR
Siap Melayani Dengan Terbaik
==================================

Cara Kerja Kode Ini:

1

def sapa_bengkel(): → kata def artinya "saya sedang mendefinisikan fungsi bernama sapa_bengkel"

2

Kurung kosong () berarti fungsi ini tidak butuh input apapun dari luar

3

Untuk memanggil fungsi: tulis nama fungsi + kurung buka-tutup, misal sapa_bengkel()

4

Keuntungan utama: panggil sapa_bengkel() kapan saja tanpa menulis ulang 4 baris print

Level 2 — Parameter & Return

🟡 SEDANG Fungsi yang menerima data dan mengembalikan hasil

Fungsi yang lebih powerful: bisa menerima data (parameter) dan mengembalikan hasil (return). Seperti teknisi yang menerima info kerusakan → menganalisis → menyerahkan laporan hasil diagnosa.

panggil dengan data → fungsi(parameter) → return hasil → simpan / tampilkan

# FUNGSI dengan PARAMETER dan RETURN

# Fungsi 1: menghitung estimasi biaya
def hitung_biaya(luas_cm2, harga_per_cm2):
    total = luas_cm2 * harga_per_cm2
    return total

# Fungsi 2: menentukan status kerusakan berdasarkan kedalaman
def cek_status(kedalaman):
    if kedalaman > 5:
        return "PARAH — ganti panel"
    elif kedalaman > 2:
        return "SEDANG — tarik dengan PDR"
    else:
        return "RINGAN — perbaiki sendiri"

# ===== PROGRAM UTAMA =====
kedalaman = float(input("Kedalaman penyok (cm): "))
luas = float(input("Luas area rusak (cm²): "))

# Panggil fungsi, simpan hasilnya ke variabel
status = cek_status(kedalaman)
biaya = hitung_biaya(luas, 2000) # Rp 2000/cm²

print(f"Status : {status}")
print(f"Est. Biaya: Rp{biaya:,.0f}")

Contoh Output:

# Input: kedalaman=3.5, luas=80
Status : SEDANG — tarik dengan PDR
Est. Biaya: Rp160,000

# Input: kedalaman=6, luas=200
Status : PARAH — ganti panel
Est. Biaya: Rp400,000

Cara baca return: "Setelah selesai bekerja, fungsi menyerahkan nilai ini ke siapapun yang memanggilnya." Nilai return bisa disimpan ke variabel: status = cek_status(3.5)

Cara Kerja Kode Ini:

1

Parameter seperti "slot input" di fungsi. hitung_biaya(luas_cm2, harga_per_cm2) punya 2 slot — keduanya wajib diisi saat memanggil

2

return total mengirim nilai total keluar dari fungsi. Tanpa return, fungsi tidak bisa "memberi tahu" hasil kerjanya

3

Fungsi bisa berisi logika if/elif/else dan tiap cabang bisa punya return berbeda — fungsi langsung berhenti saat bertemu return

4

Hasil return disimpan ke variabel: status = cek_status(kedalaman) — sekarang status berisi teks hasil diagnosa

Level 3 — Modularisasi Program

🔴 SULIT Program besar dipecah menjadi banyak fungsi terstruktur

Ini adalah cara profesional menulis program: setiap "tugas" dipecah menjadi fungsi terpisah, lalu disatukan oleh sebuah fungsi utama. Hasilnya: kode rapi, mudah dicari kalau ada error, dan mudah dikembangkan.

Struktur Program Modular

main() — fungsi utama

input_data() diagnosa() hitung_biaya() tampilkan_laporan()

# ====================================
# SISTEM DIAGNOSA BENGKEL BODI — TBKR
# Program Termodular (setiap tugas = 1 fungsi)
# ====================================

def input_data():
    """Fungsi untuk mengumpulkan data dari pengguna"""
    print("\n--- Input Data Kerusakan ---")
    jenis = input("Jenis (penyok/gores/karat): ").lower()
    luas = float(input("Luas area (cm²): "))
    usia = int(input("Usia kendaraan (tahun): "))
    return jenis, luas, usia # return 3 nilai sekaligus!

def diagnosa(jenis, luas):
    """Fungsi untuk menentukan status dan rekomendasi alat"""
    if jenis == "karat" and luas > 200:
        status = "KRITIS"
        alat = "Gerinda, las MIG, panel baru"
        waktu = "2–3 hari"
    elif jenis == "penyok":
        status = "SEDANG" if luas > 50 else "RINGAN"
        alat = "Dent puller, palu bodi"
        waktu = "3–5 jam" if luas > 50 else "1–2 jam"
    else: # gores atau lainnya
        status = "RINGAN"
        alat = "Amplas, dempul, spray gun"
        waktu = "2–4 jam"
    return status, alat, waktu

def hitung_biaya(luas, jenis):
    """Hitung estimasi biaya berdasarkan jenis dan luas"""
    tarif = {"penyok": 2500, "gores": 3000, "karat": 5000}
    harga = tarif.get(jenis, 3000) # default 3000 jika tidak ada
    return luas * harga

def tampilkan_laporan(jenis, luas, usia, status, alat, waktu, biaya):
    """Fungsi khusus untuk mencetak laporan akhir"""
    print("\n===============================")
    print(" LAPORAN DIAGNOSA BENGKEL ")
    print("===============================")
    print(f"Jenis Kerusakan : {jenis}")
    print(f"Luas Area : {luas} cm²")
    print(f"Usia Kendaraan : {usia} tahun")
    print("-------------------------------")
    print(f"Status : {status}")
    print(f"Alat Dibutuhkan : {alat}")
    print(f"Estimasi Waktu : {waktu}")
    print(f"Estimasi Biaya : Rp{biaya:,.0f}")
    if usia > 10:
        print("⚠ Periksa juga kondisi rangka!")
    print("===============================")

# ===== FUNGSI UTAMA =====
def main():
    """Fungsi utama — mengatur alur program"""
    jenis, luas, usia = input_data()
    status, alat, waktu = diagnosa(jenis, luas)
    biaya = hitung_biaya(luas, jenis)
    tampilkan_laporan(jenis, luas, usia, status, alat, waktu, biaya)

# Jalankan program
main()

Contoh Output:

# Input: jenis=penyok, luas=80, usia=12
===============================
LAPORAN DIAGNOSA BENGKEL
===============================
Jenis Kerusakan : penyok
Luas Area : 80.0 cm²
Usia Kendaraan : 12 tahun
-------------------------------
Status : SEDANG
Alat Dibutuhkan : Dent puller, palu bodi
Estimasi Waktu : 3–5 jam
Estimasi Biaya : Rp200,000
⚠ Periksa juga kondisi rangka!
===============================

Cara Kerja Kode Ini:

1

Return banyak nilai: return jenis, luas, usia → Python otomatis mengirim 3 nilai sekaligus. Di pemanggil: jenis, luas, usia = input_data()

2

Docstring (teks dalam """...""" di dalam fungsi): penjelasan singkat tujuan fungsi. Ini kebiasaan programmer profesional!

3

Dictionary sebagai tabel tarif: tarif = {"penyok": 2500, ...} lalu ambil nilai dengan tarif.get(jenis, 3000)

4

Fungsi main(): tugasnya hanya "mengatur lalu lintas" — memanggil fungsi lain secara berurutan. Program utama jadi sangat mudah dibaca!

Kamus Fungsi Python

Konsep / Kata Kunci	Artinya	Contoh	Keterangan
`def`	Mendefinisikan / membuat fungsi	`def sapa():`	Tulis sekali di atas program
Parameter	Input yang diterima fungsi	`def hitung(luas, harga):`	Nilai dikirim saat memanggil
`return`	Mengembalikan hasil fungsi	`return total`	Opsional — fungsi bisa tanpa return
Pemanggilan	Menjalankan fungsi	`sapa()` atau `hitung(80, 2000)`	Bisa dipanggil berkali-kali
Docstring	Komentar penjelasan fungsi	`"""Fungsi ini untuk..."""`	Di baris pertama dalam fungsi
Return banyak nilai	Mengembalikan beberapa nilai sekaligus	`return a, b, c`	Terima dengan: `x, y, z = fungsi()`
Modularisasi	Memecah program jadi banyak fungsi	`main()` memanggil fungsi lain	Kode lebih rapi, mudah dikelola

Latihan Mandiri

Kerjakan semua latihan di Pydroid 3 atau Pythonista 3 pada smartphone/tablet Anda!

🎯 Latihan 1 (Mudah): Fungsi Sambutan & Penutup

Buat dua fungsi: sambutan() untuk menyambut pelanggan dan penutup() untuk menutup laporan. Panggil kedua fungsi tersebut di program utama.

# Latihan 1 — lengkapi bagian ______
def sambutan():
    print(______) # isi dengan teks sambutan
    print(______) # bisa lebih dari satu baris

def penutup():
    print(______) # isi dengan teks penutup

# Panggil kedua fungsi di sini:
______
______

Petunjuk: Isi ______ pada bagian print() dengan string. Isi ______ di bawah dengan nama pemanggilan fungsi yang benar.

🎯 Latihan 2 (Sedang): Fungsi Cek Standar Cat

Buat fungsi cek_cat(ketebalan) yang menerima ketebalan cat (mm) dan mengembalikan teks status apakah memenuhi standar atau tidak (standar: 0.2 – 0.5 mm).

def cek_cat(ketebalan):
    if ______ and ______:
        return ______ # teks jika memenuhi standar
    else:
        return ______ # teks jika tidak memenuhi

# Gunakan fungsi di program utama:
tebal = float(input("Ketebalan cat (mm): "))
hasil = cek_cat(______) # panggil fungsi
print(f"Hasil QC: {hasil}")

🎯 Latihan 3 (Sulit): Mini Sistem Modular

Buat program modular dengan minimal 3 fungsi terpisah:

📥

ambil_input()

Tanya nama pelanggan dan jenis layanan, return kedua data

🧮

hitung_antrian(n)

Terima nomor n, kembalikan pesan "Anda antrian ke-N"

📋

cetak_tiket()

Cetak tiket antrean lengkap dengan semua informasi

# Buat ketiga fungsi di atas, lalu satukan di main()
def main():
    nama, layanan = ambil_input()
    antrian = hitung_antrian(5) # contoh: antrian ke-5
    cetak_tiket(nama, layanan, antrian)

main()

Tantangan Ekstra: Tambahkan fungsi validasi_nama(nama) yang mengecek apakah nama tidak kosong — jika kosong, tampilkan peringatan.

Tantangan Kreatif (Bonus)

🏆

Proyek Mini: Bengkel Bodi Digital Termodular

Gabungkan materi Logika IF (pertemuan sebelumnya) dengan Fungsi untuk membuat sistem bengkel digital yang lengkap — semua fitur dibuat menjadi fungsi terpisah.

=========================================
BENGKEL BODI DIGITAL — TBKR SMK
=========================================
[1] Diagnosa Kerusakan
[2] Estimasi Biaya
[3] Cek Standar Pengecatan
[4] Keluar
-----------------------------------------
Pilih menu: 1
→ Menjalankan fungsi diagnosa_kerusakan()
=========================================

Setiap menu memanggil fungsi yang berbeda. Gunakan while True agar program berjalan terus sampai pengguna pilih "Keluar".

Dokumentasi & Pengumpulan

WAJIB DIDOKUMENTASIKAN!

Perhatikan Instruksi Berikut:

Setiap latihan yang telah kamu kerjakan WAJIB didokumentasikan dalam satu postingan di Blogger sebagai bukti pembelajaran.

1

Buat Postingan di Blogger

Dokumentasikan semua hasil latihan (kode program, screenshot output, dan penjelasan) dalam satu postingan Blogger yang rapi dan menarik.

2

Gunakan Judul yang Ditentukan

Pastikan postingan menggunakan judul persis seperti berikut:

Memahami Fungsi dan Modularisasi dalam Python

Judul harus persis sama termasuk huruf kapital dan spasi untuk memudahkan penilaian.

3

Isi Minimal Postinganmu:

Screenshot kode + output Latihan 1, 2, dan 3
Penjelasan singkat perbedaan fungsi tanpa return vs dengan return dengan bahasamu sendiri
Satu contoh fungsi yang kamu buat sendiri (bebas, tapi konteks bengkel TBKR)
Jelaskan: mengapa program modular lebih baik daripada kode panjang tanpa fungsi?

4

Kirim Link ke Google Form

Setelah postingan dipublikasikan, kirim link lengkap postinganmu melalui Google Form berikut:

KIRIM KE GOOGLE FORM BLOGGING SEKARANG!

Link form hanya bisa diakses oleh siswa terdaftar

Batas Waktu Pengumpulan: 3 hari setelah praktek ini selesai

Tips Dokumentasi yang Baik:

Sertakan screenshot kode program dan hasil output di HP
Tambahkan penjelasan singkat untuk setiap latihan
Buat diagram sederhana yang menjelaskan alur fungsi yang kamu buat
Pastikan postingan sudah dipublikasikan (bukan draft)

NILAI PRAKTEK AKAN DINILAI BERDASARKAN KELENGKAPAN DOKUMENTASI DI BLOGGER

Tips Belajar

Satu Fungsi, Satu Tugas

Beri nama fungsi yang menjelaskan tugasnya: hitung_biaya() bukan fungsi1(). Kalau fungsi punya dua tugas berbeda, pecah jadi dua fungsi!

Panggil Sebelum Didefinisikan = Error!

Coba sengaja panggil fungsi sebelum menuliskan def-nya. Amati error yang muncul: NameError: name 'xxx' is not defined. Ini cara cepat memahami urutan eksekusi Python.

Uji Setiap Fungsi Sendiri

Setelah membuat fungsi, uji langsung dengan memanggilnya dan print hasilnya. Jangan tunggu sampai seluruh program selesai — lebih mudah menemukan bug jika fungsi diuji satu per satu.

Bagi Tugas dengan Teman

Ini kelebihan modularisasi: satu teman bisa buat fungsi input_data(), teman lain buat hitung_biaya(). Gabungkan di main(). Seperti kerja tim di bengkel sungguhan!

Cheat Sheet — Fungsi Python

Fungsi Dasar

def nama():
print("halo")

nama() # panggil

// Tidak ada input/output

Dengan Parameter

def sapa(nama):
print(f"Halo, {nama}")

sapa("Budi")

// Menerima nilai dari luar

Dengan Return

def kali(a, b):
return a * b

hasil = kali(5, 3)

// Mengembalikan nilai

Return Banyak Nilai

def info():
return "Budi", 17

nama, umur = info()

// Terima banyak nilai sekaligus

Docstring

def diagnosa(j):
"""Cek jenis rusak"""
return f"Jenis: {j}"

// Dokumentasi bawaan fungsi

Fungsi Utama

def main():
    ambil_data()
    proses()
    cetak()

main()

// Pola program modular