Pendamping Bab 11: Fungsi: Menyusun Bagian Program yang Dapat Digunakan Ulang. Gunakan nomor contoh dan latihan yang sama dengan buku.

Tujuan Belajar

• Mendefinisikan dan memanggil fungsi.
• Membedakan parameter, argumen, dan nilai balik.
• Mengenali lingkup variabel serta dokumentasi fungsi.

Persiapan

Kamu sudah memahami input, percabangan, dan perulangan. Pembahasan inti memakai fungsi dalam satu file; organisasi banyak file diperdalam pada Bab 17.

Program dengan tombol Coba di IDE dapat dijalankan di browser. Untuk program lokal, unduh sumber, ekstrak ZIP, lalu ikuti README.txt.

Pembahasan

11-01 – Apa Itu Fungsi?

Setiap kali kamu ingin nasi goreng, kamu tinggal ikuti "resep" (panggil fungsi) tersebut.

def sapa():
    print("Halo, selamat datang!")


sapa()  # Memanggil fungsi

Hasil yang diharapkan:

Halo, selamat datang!

Coba ubah: Ubah satu nilai pada contoh, lalu jelaskan pengaruhnya terhadap hasil.

11-02 – Parameter dan Argumen

u berikan saat memanggil fungsi disebut argumen.

def tambah(a, b):
    print("Hasil:", a + b)


tambah(4, 7)

Hasil yang diharapkan:

Hasil: 11

Coba ubah: Ubah satu nilai pada contoh, lalu jelaskan pengaruhnya terhadap hasil.

11-03 – Return Value (Nilai Balik)

Tidak semua fungsi hanya melakukan aksi (seperti mencetak sesuatu). Banyak fungsi yang setelah selesai bekerja, akan mengembalikan sebuah nilai ke bagian program yang memanggilnya. Nilai ini disebut *return value* atau nilai balik, dan kita menggunakan kata kunci return untuk menentukannya.

def kuadrat(x):
    return x * x


hasil = kuadrat(5)
print(hasil)  # 25

Hasil yang diharapkan:

25

Coba ubah: Ubah satu nilai pada contoh, lalu jelaskan pengaruhnya terhadap hasil.

11-04 – Variabel Lokal

Analogi Variabel Lokal: Bayangkan sebuah dapur (fungsi). Peralatan masak dan bahan-bahan yang kamu siapkan khusus di dapur itu (variabel lokal) hanya ada dan digunakan di dapur itu. Orang di ruang tamu (di luar fungsi) tidak tahu dan tidak bisa langsung menggunakan panci spesifik yang ada di dapurmu.

def halo():
    pesan = "Hai, dunia!"  # variabel lokal
    print(pesan)


halo()
# print(pesan)  # Error: 'pesan' tidak dikenali di luar fungsi

Hasil yang diharapkan:

Hai, dunia!

Coba ubah: Ubah satu nilai pada contoh, lalu jelaskan pengaruhnya terhadap hasil.

11-05 – Variabel Global

Analogi Variabel Global: Bayangkan sebuah lemari bumbu umum di sebuah rumah (program). Siapa pun yang ada di rumah itu, baik di dapur A (fungsi A) maupun di dapur B (fungsi B), bisa melihat dan menggunakan bumbu dari lemari umum tersebut (variabel global).

pesan = "Halo!"


def tampilkan():
    print(pesan)


tampilkan()

Hasil yang diharapkan:

Halo!

Coba ubah: Ganti isi pesan dengan teks lain dan bandingkan hasilnya.

11-06 – Mengubah Variabel Global dari Dalam Fungsi

cara default, jika kamu mencoba memberi nilai baru ke variabel dengan nama yang sama seperti variabel global di dalam fungsi, Python akan membuat variabel lokal baru, bukan mengubah variabel globalnya. Jika kamu benar-benar ingin memodifikasi variabel global dari dalam fungsi, kamu harus menggunakan kata kunci global.

angka = 0


def tambah():
    global angka
    angka += 1


for _ in range(3):
    tambah()

print(angka)  # Output: 3

Hasil yang diharapkan:

3

Coba ubah: Ubah angka dari 0 menjadi 1, lalu prediksi hasilnya.

11-07 – Fungsi dengan Logika dan Perulangan

Perhatikan pemakaian cetak_genap, range pada data contoh dan bandingkan hasilnya dengan nilai awal.

def cetak_genap(n):
    for i in range(n + 1):
        if i % 2 == 0:
            print(i)


cetak_genap(10)

Hasil yang diharapkan:

0
2
4
6
8
10

Coba ubah: Ubah satu nilai pada contoh, lalu jelaskan pengaruhnya terhadap hasil.

11-08 – Fungsi Bersarang (Nested Function)

Analogi Fungsi Bersarang: Bayangkan kamu punya resep utama (fungsi luar), misalnya "Membuat Pesta Makan Malam". Di dalam resep itu, ada sub-resep khusus (fungsi dalam), seperti "Membuat Saus Spesial" yang hanya relevan dan digunakan untuk pesta makan malam tersebut, tidak untuk masakan lain secara umum.

def luar():
    def dalam():
        print("Fungsi dalam dipanggil")

    dalam()


luar()

Hasil yang diharapkan:

Fungsi dalam dipanggil

Coba ubah: Ubah satu nilai pada contoh, lalu jelaskan pengaruhnya terhadap hasil.

11-09 – Argumen Default

Analogi Argumen Default: Saat memesan kopi, jika kamu tidak bilang apa-apa soal gula, barista mungkin akan membuatkannya tanpa gula (nilai default gula=0). Tapi kamu tetap bisa minta, "Kopi, gulanya 2 sendok ya!" (memberikan argumen spesifik).

# nama dan ucapan punya nilai default
def salam(nama="Teman", ucapan="Selamat pagi"):
    print(f"{ucapan}, {nama}!")


# Menggunakan argumen yang diberikan
salam("Ayu", "Halo")
# Menggunakan default untuk ucapan: "Selamat pagi, Budi!"
salam("Budi")
# Menggunakan default untuk nama dan ucapan
salam()

Hasil yang diharapkan:

Halo, Ayu!
Selamat pagi, Budi!
Selamat pagi, Teman!

Coba ubah: Ubah satu nilai pada contoh, lalu jelaskan pengaruhnya terhadap hasil.

11-10 – Keyword Arguments

Analogi Keyword Arguments: Saat memesan pizza custom, kamu bisa bilang, "Saya mau pizza, ukuran='besar', topping_utama='jamur', pinggiran='keju'." Kamu tidak harus menyebutkannya dalam urutan tertentu, yang penting jelas parameternya (ukuran, topping, pinggiran) dan nilainya.

def biodata(nama, umur, kota):
    print(f"{nama} berusia {umur} tahun dan tinggal di {kota}.")


biodata(nama="Rina", umur=30, kota="Jakarta")
# Urutan tidak masalah dengan keyword arguments
biodata(kota="Bandung", nama="Andi", umur=25)

Hasil yang diharapkan:

Rina berusia 30 tahun dan tinggal di Jakarta.
Andi berusia 25 tahun dan tinggal di Bandung.

Coba ubah: Ubah satu nilai pada contoh, lalu jelaskan pengaruhnya terhadap hasil.

11-11 – Fungsi Anonim: Lambda

Analogi Lambda: Bayangkan kamu butuh instruksi super singkat dan cepat, seperti catatan tempel kecil untuk tugas sekali jalan. Misalnya, "Gandakan angka ini!" atau "Ambil huruf pertamanya!". Kamu tidak perlu memberinya nama resmi atau prosedur panjang.

# Fungsi biasa
def kuadrat_biasa(x):
    return x * x


# Fungsi lambda yang setara
kuadrat_lambda = lambda x: x * x

print(kuadrat_biasa(6))  # 36
print(kuadrat_lambda(6))  # 36

# Contoh penggunaan umum lambda dengan fungsi lain (misal, sort)
poin = [(1, 2), (3, 1), (5, 4), (2, 0)]
# Sort berdasarkan elemen kedua dari setiap tuple
poin.sort(key=lambda item: item[1])
print(poin)  # Output: [(2, 0), (3, 1), (1, 2), (5, 4)]

Hasil yang diharapkan:

36
36
[(2, 0), (3, 1), (1, 2), (5, 4)]

Coba ubah: Ubah satu nilai pada poin dan periksa bagian hasil yang ikut berubah.

Studi Kasus

11-12 – Konversi mata uang dengan kurs contoh

Fungsi yang sama dipanggil dengan dua argumen rupiah. Nilai balik dipakai dalam f-string. Kurs disimpan sebagai parameter agar dapat diganti.

def konversi_ke_usd(rupiah, kurs=15000):
    """Hitung nilai dolar memakai kurs yang diberikan."""
    return rupiah / kurs


print(f"USD {konversi_ke_usd(150000):.2f}")
print(f"USD {konversi_ke_usd(300000):.2f}")

Hasil yang diharapkan:

USD 10.00
USD 20.00

Coba ubah: Berikan kurs=16000 dan bandingkan hasil konversi.

Rangkuman

Fungsi mengelompokkan pekerjaan dan dapat dipanggil berulang. Parameter menerima argumen; return mengembalikan hasil. Variabel lokal membantu memisahkan data antarbagian program.

Cek Pemahaman

Lima pertanyaan ini sama dengan pertanyaan di buku. Periksa jawaban di kuis untuk melihat skor dan pembahasan.

1. Kata kunci untuk mendefinisikan fungsi adalah …
2. Apa perbedaan parameter dan argumen?
3. Apa fungsi return?
4. Variabel yang dibuat di dalam fungsi biasanya …
5. Jika fungsi selesai tanpa return yang memberikan nilai, hasilnya …

Latihan Mandiri

Latihan 11-L01 – Fungsi sapaan

Dasar. Buat fungsi sapa(nama) yang mengembalikan Halo, Ayu! ketika dipanggil dengan Ayu.

Hasil yang diharapkan:

Halo, Ayu!

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


print(sapa("Ayu"))

Latihan 11-L02 – Luas persegi panjang

Penerapan. Buat luas(panjang, lebar), lalu cetak hasil untuk panjang 8 dan lebar 5.

Hasil yang diharapkan:

40

def luas(panjang, lebar):
    return panjang * lebar


print(luas(8, 5))

Latihan 11-L03 – Parameter default

Pengembangan. Buat harga_total(harga, jumlah=1). Cetak hasil untuk harga 5000 tanpa jumlah, lalu dengan jumlah 3.

Hasil yang diharapkan:

5000
15000

def harga_total(harga, jumlah=1):
    return harga * jumlah


print(harga_total(5000))
print(harga_total(5000, jumlah=3))

Pengembangan

Modul dan Paket

Prasyarat: kerjakan setelah Bab 17.

Ketika programmu semakin besar, menyimpan semua code dalam satu file akan membuatnya sulit dikelola. Modularisasi adalah praktik memecah program menjadi beberapa file (modul) yang lebih kecil dan terorganisir. Setiap modul biasanya berisi fungsi, kelas, dan variabel yang terkait dengan tugas tertentu.

Kamu bisa menyimpan fungsi-fungsimu dalam sebuah file Python (misalnya, kalkulator.py). Lalu, kamu bisa mengimpor fungsi-fungsi tersebut di file Python lainnya (misalnya, main.py) menggunakan pernyataan import.

Analogi Modularisasi: Bayangkan kamu seorang koki handal dengan banyak resep (fungsi). – Menyimpan semua resep dalam satu buku catatan super tebal (satu file besar) akan merepotkan. – Modularisasi itu seperti kamu mengelompokkan resep-resepmu ke dalam beberapa buku masak yang lebih kecil berdasarkan kategori: “Buku Resep Kue”, “Buku Resep Masakan Utama”, “Buku Resep Minuman”. Ini adalah modul-modul: resep_kue.py, masakan_utama.py. – Ketika kamu ingin membuat kue, kamu tinggal ambil “Buku Resep Kue” (import resep_kue) dan menggunakan resep di dalamnya.

Contoh:

File: kalkulator.py

#### Ini adalah modul kalkulator.py

def tambah(a, b):
    """Menjumlahkan dua angka."""
    return a + b

def kurang(a, b):
    """Mengurangkan dua angka."""
    return a - b

PI = 3.14159 # Contoh variabel dalam modul

File: main.py (dalam direktori yang sama dengan kalkulator.py)

#### Mengimpor seluruh modul kalkulator
import kalkulator

hasil_tambah = kalkulator.tambah(10, 5)
print(f"Hasil tambah: {hasil_tambah}")
print(f"Nilai PI dari modul: {kalkulator.PI}")

Diagram Berbagai Cara Import Modul

Diagram ini menunjukkan berbagai strategi import dan cara penggunaannya:

flowchart TD
    A[kalkulator.py<br/>def tambah a, b<br/>def kurang a, b<br/>PI = 3.14159] --> B{Cara Import?}
    
    B -->|1| C[import kalkulator]
    C --> C1[Akses: kalkulator.tambah 10, 5]
    
    B -->|2| D[import kalkulator as kalk]
    D --> D1[Akses: kalk.tambah 10, 5]
    
    B -->|3| E[from kalkulator import tambah]
    E --> E1[Akses langsung: tambah 10, 5]
    
    B -->|4| F[from kalkulator import tambah as penjumlahan]
    F --> F1[Akses: penjumlahan 10, 5]
    
    B -->|5| G[from kalkulator import *<br/>tidak disarankan]
    G --> G1[Akses langsung semua<br/>risiko konflik nama]

#### Cara lain: Mengimpor fungsi spesifik dari modul
from kalkulator import kurang

hasil_kurang = kurang(10, 3)
print(f"Hasil kurang: {hasil_kurang}")

#### Cara lain: Mengimpor semua dari modul
#### (kurang disarankan untuk proyek besar karena konflik nama)
#### from kalkulator import *
#### hasil_tambah_lagi = tambah(20, 7)
#### print(f"Hasil tambah lagi: {hasil_tambah_lagi}")

Ini membuat program jadi lebih terorganisir, rapi, dan mudah dikelola. Setiap modul bisa dikembangkan dan diuji secara independen.

Berbagai Cara Import di Python

Selain cara dasar di atas, Python menyediakan beberapa fleksibilitas dalam mengimpor modul dan isinya:

#### Misalkan kita memiliki modul bernama 'kalkulator.py'
#### seperti contoh sebelumnya.

#### 1. Import seluruh modul (cara standar)
#### Kamu perlu menggunakan nama modul sebagai prefix
#### saat memanggil fungsinya.
import kalkulator
hasil_1 = kalkulator.tambah(10, 5)
print(f"Hasil (import standar): {hasil_1}")

#### 2. Import dengan alias (nama samaran)
#### Berguna jika nama modul panjang atau ingin nama
#### yang lebih singkat.
import kalkulator as kalk
hasil_2 = kalk.kurang(10, 3)
print(f"Hasil (import dengan alias 'kalk'): {hasil_2}")

#### 3. Import item spesifik dari modul
#### Kamu bisa langsung menggunakan nama item
#### tanpa prefix modul.
from kalkulator import tambah, PI
hasil_3 = tambah(20, 7)
print(f"Hasil (from kalkulator import tambah): {hasil_3}")
print(f"Nilai PI (from kalkulator import PI): {PI}")

#### 4. Import item spesifik dengan alias
#### Berguna jika ingin mengganti nama item yang diimpor
#### atau menghindari konflik nama.
from kalkulator import tambah as penjumlahan
from kalkulator import kurang as pengurangan
hasil_4 = penjumlahan(100, 50)
hasil_5 = pengurangan(100, 25)
print(f"Hasil (from ... import tambah as penjumlahan):")
print(f"  {hasil_4}")
print(f"Hasil (from ... import kurang as pengurangan):")
print(f"  {hasil_5}")

#### 5. Import semua item dari modul
#### (gunakan dengan hati-hati!)
#### Mengimpor semua nama dari modul ke dalam
#### namespace saat ini.
#### Ini bisa menyebabkan konflik nama jika modul
#### memiliki nama yang sama dengan yang sudah ada.
#### Umumnya kurang direkomendasikan untuk proyek besar
#### karena mengurangi kejelasan.
#### from kalkulator import *
#### hasil_bintang = tambah(5, 5)
#### print(f"Hasil (from kalkulator import *):")
#### print(f"  {hasil_bintang}")

Contoh Struktur Proyek dengan Package

Ketika proyek semakin besar, kamu mungkin ingin mengorganisir modul-modul ke dalam direktori yang disebut package. Package adalah cara untuk menstrukturkan namespace modul Python menggunakan “nama modul bertitik”.

Misalkan struktur proyekmu seperti ini:

proyek_saya/
|-- main_app.py
`-- utils/
    |-- __init__.py
    |-- matematika.py
    `-- format_teks.py

• utils/ adalah sebuah package karena berisi file __init__.py. File ini bisa kosong, tetapi keberadaannya memberitahu Python bahwa direktori utils harus diperlakukan sebagai package.
• matematika.py dan format_teks.py adalah modul di dalam package utils.

File: utils/matematika.py

#### utils/matematika.py
def kali(a, b):
    return a * b

KONSTANTA_MAT = 1.618

File: utils/format_teks.py

#### utils/format_teks.py
def kapital_awal(teks):
    return teks.capitalize()

File: main_app.py

#### main_app.py

#### Mengimpor dari modul dalam package
from utils.matematika import kali, KONSTANTA_MAT
from utils.format_teks import kapital_awal

#### Mengimpor seluruh modul dari package
import utils.matematika
import utils.format_teks as ft # dengan alias

angka1 = 10
angka2 = 5

hasil_kali = kali(angka1, angka2)
print(f"Hasil kali ({angka1}x{angka2}): {hasil_kali}")
print(f"Konstanta Matematika: {KONSTANTA_MAT}")

nama = "budi"
nama_kapital = kapital_awal(nama)
print(f"Nama '{nama}' menjadi '{nama_kapital}'")

#### Menggunakan modul yang diimpor dengan alias
#### (jika import utils.matematika)
hasil_kali_lagi = utils.matematika.kali(7, 3)
print(f"Hasil kali lagi: {hasil_kali_lagi}")

nama_lain = "SITI nurhaliza"
#### (jika import utils.format_teks as ft)
nama_lain_kapital = ft.kapital_awal(nama_lain)
print(f"Nama '{nama_lain}' menjadi '{nama_lain_kapital}'")

Tips Penting untuk Import

1. Prioritaskan Keterbacaan:

   • import modul dan from paket import modul umumnya lebih mudah dibaca dan dipahami daripada from modul import *.
   • Aliasing (import numpy as np) sangat berguna untuk modul dengan nama panjang atau yang umum digunakan dengan alias tertentu. Namun, jangan membuat alias yang membingungkan.

2. Penanganan ImportError: Kadang, modul yang ingin kamu impor mungkin belum terinstal atau tidak ada. Kamu bisa menangani ini dengan try-except:

   try:
       import modul_yang_mungkin_tidak_ada
   except ImportError:
       print("Modul 'modul_yang_mungkin_tidak_ada'")
       print("tidak ditemukan.")
       print("Pastikan sudah terinstal atau di PYTHONPATH.")
       # Kamu bisa menambahkan logika alternatif
       # atau keluar dari program
       # import sys
       # sys.exit(1)

3. Hindari Circular Imports: Circular import terjadi ketika modul A mengimpor modul B, dan modul B juga mengimpor modul A (secara langsung atau tidak langsung). Ini bisa menyebabkan error atau perilaku tak terduga.

   • Solusi: Salah satu cara mengatasinya adalah dengan memindahkan salah satu import ke dalam fungsi atau metode yang membutuhkannya, bukan di level atas modul. Cara lain adalah dengan merestrukturisasi code untuk menghilangkan ketergantungan timbal balik.

   # Contoh circular import yang dihindari
   # File: modul_a.py
   # from modul_b import fungsi_b
   # <-- Potensi circular jika modul_b import modul_a
   
   # def fungsi_a():
   #     print("Fungsi A dijalankan")
   #     fungsi_b()
   
   # Solusi: import di dalam fungsi
   def fungsi_a_solusi():
       # Import saat dibutuhkan
       from modul_b import fungsi_b
       print("Fungsi A (solusi) dijalankan")
       fungsi_b()

Memahami berbagai cara import dan bagaimana mengelola struktur proyek dengan package akan sangat membantumu saat membangun aplikasi Python yang lebih besar dan kompleks.

Kalkulator dengan Modul

Prasyarat: kerjakan setelah Bab 17.

Buat program yang:

• Menampilkan menu operasi: Tambah, Kurang, Kali, Bagi, Keluar
• Menggunakan fungsi untuk setiap operasi
• Menggunakan while loop agar pengguna bisa mencoba berulang kali
• Menangani kesalahan seperti pembagian dengan nol

Contoh:

def bagi(a, b):
    if b == 0:
        return "Tidak bisa dibagi nol"
    return a / b

Modularisasi

• Simpan semua fungsi ke dalam file fungsi_operasi.py
• Di file utama, gunakan from fungsi_operasi import ...
• Pastikan semua fungsi berjalan dengan baik saat di-import

Referensi dan Materi Pendamping

• Fungsi di Python: def, Parameter, dan Pemanggilan
• return di Python: Mengembalikan Nilai dari Fungsi
• Argumen Default di Python: Parameter Opsional dan Keyword

Langkah Selanjutnya

Bab 12 membahas List dan Tuple: Koleksi Berurutan. Sebelum melanjutkan, pastikan kamu dapat menjelaskan tujuan belajar dan menyelesaikan tiga latihan inti bab ini.

Edisi September 2026. Nomor contoh, pertanyaan, dan latihan digunakan bersama pada buku dan halaman ini.

Bab 10 | Bab 12