Program Studi Bisnis Digital • FEB UNDIP

Algoritma dan Pemrograman

Pertemuan 6 — Fungsi dalam Pemrograman: Parameter, Return, dan Scope

Cara membungkus kode yang berulang jadi blok bernama, mengirim data lewat parameter, mengembalikan hasil dengan return, dan memahami batas jangkauan variabel (scope).

RPS MINGGU 6 • 2 × 50 MENIT

Selamat datang kembali, Anda sudah melewati lima pertemuan yang membangun fondasi: variabel, kontrol alur, string, dan penanganan file. Hari ini kita masuk ke salah satu konsep paling penting dalam pemrograman terstruktur, yaitu fungsi. Bayangkan Anda mengelola toko online dan setiap kali ada pesanan baru, Anda harus mengetik ulang rumus hitung diskon dan ongkos kirim satu per satu — melelahkan dan rawan salah ketik. Fungsi memecahkan masalah itu dengan membungkus logika yang berulang menjadi satu blok kode bernama yang bisa dipanggil kapan saja. Sepanjang dua jam ke depan kita akan belajar cara membuat fungsi, mengirim data ke dalamnya lewat parameter, mengambil hasilnya lewat return, dan memahami mengapa variabel di dalam fungsi punya "wilayah" sendiri yang disebut scope.

Tujuan Pembelajaran Hari Ini

Setelah pertemuan ini, Anda diharapkan mampu merancang dan menggunakan fungsi untuk menyusun program yang rapi dan tidak berulang. Secara rinci:

CAPAIAN 1

ANATOMI

Menjelaskan struktur fungsi (def, nama, parameter, return) dan manfaat menghindari kode berulang.

CAPAIAN 2

PARAMETER

Membuat fungsi dengan parameter positional, nilai default, dan keyword argument.

CAPAIAN 3

RETURN

Membedakan return dengan print(), dan mengembalikan lebih dari satu nilai sekaligus.

CAPAIAN 4

SCOPE

Membedakan variabel lokal dan global serta dampaknya pada perilaku program.

Empat capaian ini adalah peta perjalanan kita hari ini. Pertama, Anda perlu paham anatomi sebuah fungsi — bagian mana yang jadi kepala, bagian mana yang jadi badan. Kedua, kita perdalam parameter, karena di sinilah fleksibilitas fungsi muncul; fungsi yang sama bisa dipakai untuk data yang berbeda-beda. Ketiga, kita bahas return, konsep yang paling sering tertukar dengan print() oleh pemrogram pemula. Keempat, kita tutup dengan scope, yaitu wilayah hidup sebuah variabel — apakah ia bisa diakses di luar fungsi atau tidak. Simpan keempat kata kunci ini di kepala Anda: anatomi, parameter, return, dan scope, karena semuanya akan terus dipakai di pertemuan-pertemuan selanjutnya.

Mengapa Kita Butuh Fungsi?

Bayangkan Anda baru membangun sistem kasir sederhana untuk toko online UMKM. Tanpa fungsi, tiga masalah ini muncul berulang setiap hari:

MASALAH 1

DUPLIKASI

Rumus hitung diskon di-copy-paste di 10 tempat berbeda dalam kode. Salah satu typo, semua ikut salah.

MASALAH 2

SULIT UBAH

Tarif ongkir berubah? Anda harus cari dan ubah rumus itu satu-satu di seluruh berkas kode.

MASALAH 3

SULIT DIBACA

Kode 200 baris tanpa pengelompokan jadi seperti benang kusut — sulit dilacak logikanya.

Fungsi membungkus logika yang berulang menjadi satu blok bernama, dipanggil sesuka hati — prinsip ini disebut DRY: Don't Repeat Yourself.

Mari mulai dari masalah nyata. Bayangkan Anda menulis program kasir untuk toko online, dan setiap kali menghitung diskon, Anda mengetik ulang rumus yang sama di banyak tempat berbeda — saat checkout, saat cetak struk, saat laporan penjualan. Masalah pertama, kalau ada satu typo di salah satu tempat, hasilnya jadi tidak konsisten. Masalah kedua, ketika suatu hari tarif ongkos kirim berubah, Anda harus berburu dan mengubah rumus itu satu per satu di seluruh berkas kode, yang sangat berisiko ada yang terlewat. Masalah ketiga, kode yang panjang tanpa pengelompokan menjadi sulit dibaca bahkan oleh Anda sendiri beberapa bulan kemudian. Fungsi menyelesaikan ketiga masalah ini sekaligus dengan prinsip yang dalam dunia pemrograman disebut DRY, singkatan dari "Don't Repeat Yourself" — jangan mengulang diri sendiri. Inilah alasan mengapa fungsi adalah salah satu konsep paling fundamental yang akan terus Anda pakai di setiap program yang Anda tulis.

Bagian 1 dari 4

Anatomi & Cara Kerja Fungsi

Apa itu fungsi, bagian-bagian penyusunnya, dan bagaimana Python mengeksekusinya saat dipanggil.

def call return

Kita mulai bagian pertama dengan pertanyaan paling dasar: apa sebenarnya fungsi itu, dan dari bagian apa saja ia tersusun? Anda mungkin sudah pernah memakai fungsi tanpa sadar, misalnya print() atau len() — keduanya adalah fungsi bawaan Python. Sekarang giliran Anda belajar membuat fungsi sendiri. Kita akan bedah kata kunci def, nama fungsi, parameter, badan fungsi, dan kata kunci return, lalu kita telusuri langkah demi langkah apa yang terjadi di dalam komputer saat sebuah fungsi dipanggil. Perhatikan baik-baik karena pemahaman anatomi ini akan memudahkan Anda membaca kode orang lain sepanjang karier Anda nanti.

Apa Itu Fungsi? Anatomi `def`

Fungsi (function) adalah blok kode bernama yang mengerjakan satu tugas tertentu, dan bisa dipanggil ulang kapan pun dibutuhkan.

ANATOMI FUNGSI PYTHON

Fungsi tidak dijalankan saat didefinisikan — baru berjalan ketika dipanggil: hitung_diskon(250000, 15).

Perhatikan diagram ini, karena setiap fungsi Python selalu punya lima bagian yang sama. Pertama, kata kunci def yang memberi tahu Python "saya akan mendefinisikan sebuah fungsi". Kedua, nama fungsi, sebaiknya deskriptif seperti hitung_diskon, bukan sekadar f1. Ketiga, tanda kurung berisi parameter, yaitu data yang boleh dikirim ke dalam fungsi, lalu ditutup titik dua. Keempat, badan fungsi yang menjorok ke dalam, berisi kode yang benar-benar dijalankan. Kelima, kata kunci return yang mengembalikan hasil ke titik pemanggilan. Satu hal krusial yang sering disalahpahami pemula: fungsi tidak langsung berjalan saat Anda mengetik definisinya, ia hanya "didaftarkan". Fungsi baru benar-benar dieksekusi ketika Anda memanggilnya dengan menuliskan nama fungsi diikuti tanda kurung, misalnya hitung_diskon(250000, 15), mirip seperti resep masakan yang baru menghasilkan makanan ketika benar-benar dimasak, bukan saat ditulis di buku resep.

Langkah Pertama: Fungsi Paling Sederhana

Fungsi paling dasar tidak butuh parameter dan tidak mengembalikan nilai — ia hanya menjalankan tugas tetap setiap dipanggil.

KODE — CETAK KOP STRUK TOKO

def cetak_header(): print("=====================") print(" TOKO SEJAHTERA ONLINE") print("=====================") # memanggil fungsi cetak_header() cetak_header() # dipanggil lagi, tanpa tulis ulang

CIRI-CIRI

TANPA INPUT

Tanda kurung () kosong → tidak ada parameter
Tidak ada return → hanya menampilkan (print)
Bisa dipanggil berkali-kali tanpa menulis ulang isinya

Mari kita mulai dari bentuk fungsi paling sederhana. Fungsi cetak_header ini tidak menerima data apa pun dari luar — tanda kurungnya kosong — dan tugasnya hanya menampilkan tiga baris teks kop struk yang sama setiap kali. Bayangkan tanpa fungsi ini, setiap kali Anda ingin mencetak struk pesanan Tokopedia atau Shopee, Anda harus mengetik ulang tiga baris print() itu. Dengan fungsi, Anda cukup memanggil cetak_header() di mana pun Anda butuhkan, seperti menekan tombol cetak yang sudah diprogram sebelumnya. Perhatikan juga bahwa fungsi ini dipanggil dua kali di baris terakhir kode, dan setiap pemanggilan akan mengulang seluruh badan fungsi dari awal. Ini adalah bentuk paling sederhana sebelum kita menambahkan parameter di slide berikutnya.

Alur Eksekusi: Apa yang Terjadi Saat Fungsi Dipanggil?

Python tidak membaca kode dari atas ke bawah secara lurus ketika ada pemanggilan fungsi — ia "melompat" sejenak, lalu kembali.

RUNUTAN LANGKAH (perhatikan urutan lompatannya)

1Python membaca baris sapa_pelanggan("Budi") — ini titik pemanggilan.
2Eksekusi melompat ke definisi fungsi def sapa_pelanggan(nama):.
3Nilai "Budi" dititipkan ke parameter nama di dalam fungsi.
4Seluruh badan fungsi dijalankan baris demi baris, dari atas ke bawah.
5Begitu ketemu return (atau badan fungsi habis), eksekusi kembali ke titik pemanggilan tadi.
6Program melanjutkan baris setelah pemanggilan, seolah tidak terjadi apa-apa.

Ini sebabnya definisi fungsi (def) boleh diletakkan di atas, tetapi hanya berjalan saat dipanggil, bukan saat dibaca Python pertama kali.

Bagian ini sering jadi titik terang bagi mahasiswa yang tadinya bingung soal fungsi. Bayangkan Anda sedang membaca sebuah buku resep dari halaman satu ke halaman terakhir, lalu tiba-tiba instruksinya bilang "lihat resep kaldu di halaman dua puluh". Anda melompat ke halaman dua puluh, mengikuti instruksinya, lalu begitu selesai, Anda kembali ke halaman semula dan melanjutkan membaca. Persis seperti itulah cara Python mengeksekusi pemanggilan fungsi. Saat Python bertemu sapa_pelanggan("Budi"), ia meloncat ke definisi fungsi, menitipkan nilai "Budi" ke parameter nama, menjalankan seluruh badan fungsi, lalu kembali persis di titik pemanggilan tadi untuk melanjutkan baris berikutnya. Memahami alur lompat-dan-kembali ini adalah kunci untuk membaca program apa pun yang menggunakan banyak fungsi, termasuk program-program besar yang akan Anda temui di dunia kerja nanti.

Fungsi dengan Parameter & Argument

Parameter membuat fungsi fleksibel — satu fungsi bisa dipakai untuk data yang berbeda-beda setiap kali dipanggil.

KODE — SAPAAN PERSONAL PELANGGAN

def sapa_pelanggan(nama): print("Halo, " + nama + "!") print("Terima Kasih sudah belanja.") sapa_pelanggan("Siti") sapa_pelanggan("Budi")

ISTILAH PENTING — JANGAN TERTUKAR

Parameter — nama variabel di dalam tanda kurung saat fungsi didefinisikan. Contoh: nama.

Argument — nilai sesungguhnya yang dikirim saat fungsi dipanggil. Contoh: "Siti", "Budi".

Sekarang kita naik satu tingkat: fungsi dengan parameter. Fungsi sapa_pelanggan punya satu parameter bernama nama, yang berperan seperti kotak kosong yang menunggu diisi. Saat Anda memanggil sapa_pelanggan("Siti"), nilai "Siti" itu dititipkan ke kotak nama, sehingga hasil sapaannya personal untuk Siti. Panggilan berikutnya dengan "Budi" akan menghasilkan sapaan berbeda, padahal kodenya sama persis — inilah kekuatan parameter. Saya ingin Anda hafal dua istilah yang sering tertukar: parameter adalah nama variabel di definisi fungsi, sedangkan argument adalah nilai nyata yang Anda kirim saat memanggil. Analogi sederhananya, parameter itu seperti nama kolom di formulir kosong — "Nama Pelanggan" — sedangkan argument adalah isian sungguhan yang Anda tulis di kolom itu, seperti "Siti" atau "Budi".

Bagian 2 dari 4

Parameter Lanjutan: Default & Keyword

Bagaimana membuat parameter opsional dengan nilai bawaan, dan cara memanggil fungsi tanpa terikat urutan.

default value keyword argument

Parameter dengan Nilai Bawaan (Default)

Beri nilai bawaan pada parameter agar boleh dilewati saat pemanggilan — praktis untuk kasus yang "biasanya begini, tapi kadang beda".

KODE — HITUNG ONGKOS KIRIM

def hitung_ongkir(berat_kg, tarif=5000): # tarif punya nilai bawaan Rp 5.000/kg return berat_kg * tarif # pakai tarif bawaan (tidak diisi) print(hitung_ongkir(3)) # 15000 # timpa tarif bawaan (kota jauh) print(hitung_ongkir(3, 8000)) # 24000

Parameter dengan nilai bawaan harus diletakkan setelah parameter wajib dalam daftar — Python akan error kalau urutannya terbalik.

Perhatikan fungsi hitung_ongkir ini punya dua parameter, tetapi hanya berat_kg yang wajib diisi. Parameter tarif sudah punya nilai bawaan lima ribu rupiah per kilogram, ditulis langsung di definisi fungsi dengan tanda sama dengan. Ketika Anda memanggil hitung_ongkir(3) tanpa mengisi tarif, Python otomatis memakai nilai bawaan lima ribu, sehingga hasilnya lima belas ribu rupiah. Tetapi kalau paket dikirim ke kota yang tarifnya lebih mahal, Anda tinggal menimpa nilai bawaan itu dengan memanggil hitung_ongkir(3, 8000), menghasilkan dua puluh empat ribu rupiah. Fitur ini sangat umum dipakai di dunia nyata, misalnya toko online Tokopedia atau Shopee yang punya tarif standar tetapi bisa berubah untuk pengiriman kilat atau area terpencil. Satu aturan wajib yang harus Anda ingat: parameter berdefault selalu diletakkan setelah parameter wajib, tidak boleh sebaliknya, atau Python akan menolak kode Anda dengan pesan galat.

Keyword Argument: Memanggil Tanpa Terikat Urutan

Sebutkan nama parameternya saat memanggil fungsi — urutan argumen jadi bebas dan kode lebih jelas dibaca.

KODE — POSITIONAL vs KEYWORD

def buat_akun(nama, kota, umur): print(nama, "-", kota, "-", umur) # positional: urutan harus persis buat_akun("Rani", "Semarang", 21) # keyword: urutan bebas, lebih jelas buat_akun(umur=21, nama="Rani", kota="Semarang")

Manfaat keyword argument: mencegah salah pasang nilai saat parameter banyak dan tipenya mirip (mis. dua parameter angka yang mudah tertukar urutannya).

Sampai sekarang kita selalu memanggil fungsi dengan mengandalkan urutan, yang disebut positional argument — nilai pertama otomatis masuk ke parameter pertama, dan seterusnya. Cara ini gampang salah kalau parameternya banyak dan mirip tipe datanya, misalnya tertukar antara umur dan kota. Keyword argument menyelesaikan masalah itu dengan cara Anda menyebutkan nama parameternya secara eksplisit saat memanggil, seperti umur=21. Dengan begitu, urutan penulisannya jadi bebas dan Python tetap tahu persis nilai mana masuk ke parameter mana. Perhatikan pemanggilan kedua di slide ini, urutannya sengaja saya acak — umur duluan, lalu nama, lalu kota — tetapi hasilnya tetap benar karena setiap nilai sudah diberi label namanya. Kebiasaan menulis keyword argument sangat dianjurkan ketika fungsi punya lebih dari dua atau tiga parameter, karena kode jadi jauh lebih mudah dibaca ulang oleh Anda sendiri maupun rekan kerja.

Hitung dari Nol: Fungsi `hitung_diskon()`

Mari telusuri persis apa yang terjadi di dalam komputer saat hitung_diskon(250000, 15) dipanggil.

KODE FUNGSI

def hitung_diskon(harga, persen): diskon = harga * persen / 100 harga_akhir = harga - diskon return harga_akhir hasil = hitung_diskon(250000, 15)

JEJAK EKSEKUSI, LANGKAH DEMI LANGKAH

Langkah	Perhitungan	Nilai
Fungsi dipanggil	harga=250000, persen=15	dititipkan ke parameter
Hitung `diskon`	250.000 × 15 / 100	Rp 37.500
Hitung `harga_akhir`	250.000 − 37.500	Rp 212.500
return harga_akhir	dikembalikan ke pemanggil	Rp 212.500

Setelah return dieksekusi, variabel hasil di luar fungsi berisi Rp 212.500 — siap dipakai di baris kode berikutnya.

Sekarang mari kita hitung persis, bukan cuma membayangkan. Fungsi hitung_diskon dipanggil dengan harga dua ratus lima puluh ribu rupiah dan diskon lima belas persen. Langkah pertama, kedua nilai itu dititipkan ke parameter harga dan persen di dalam fungsi. Langkah kedua, baris pertama badan fungsi menghitung nilai diskon: dua ratus lima puluh ribu dikali lima belas per seratus, hasilnya tiga puluh tujuh ribu lima ratus rupiah. Langkah ketiga, harga akhir dihitung dengan mengurangi harga awal dengan diskon tadi, menghasilkan dua ratus dua belas ribu lima ratus rupiah. Langkah keempat, kata kunci return mengirim nilai itu keluar dari fungsi, dan variabel hasil di luar fungsi kini menyimpan angka dua ratus dua belas ribu lima ratus rupiah, siap dicetak atau dipakai untuk perhitungan selanjutnya seperti total belanja di kasir toko online Anda.

Bagian 3 dari 4

Return Value & Scope Variabel

Perbedaan mendasar antara return dan print, cara mengembalikan banyak nilai, dan wilayah hidup sebuah variabel.

print() ≠ return

Kita masuk bagian ketiga, dan ini bagian yang paling sering menjebak pemrogram pemula. Banyak yang mengira print() dan return adalah hal yang sama karena keduanya sama-sama "menampilkan" sesuatu di layar. Padahal keduanya punya peran yang sangat berbeda, dan kesalahpahaman ini bisa membuat program Anda berjalan tanpa pesan galat tetapi menghasilkan nilai yang salah, yang justru lebih berbahaya karena sulit dilacak. Di bagian ini kita juga akan belajar mengembalikan lebih dari satu nilai sekaligus dari sebuah fungsi, lalu kita tutup dengan konsep scope, yaitu batas wilayah di mana sebuah variabel bisa "dilihat" dan dipakai oleh bagian lain program.

`return` vs `print()`: Beda yang Krusial

Keduanya sama-sama menampilkan angka di layar — tetapi hanya satu yang bisa dipakai lagi oleh bagian lain program.

HANYA print() — SALAH KAPRAH

def hitung_total(a, b): print(a + b) # cuma tampil x = hitung_total(5, 3) # tampil: 8 print(x + 1) # ERROR!

Nilai x berisi None — tidak ada nilai yang dikembalikan untuk dipakai ulang.

DENGAN return — BENAR

def hitung_total(a, b): return a + b # dikembalikan x = hitung_total(5, 3) print(x + 1) # hasil: 9

x benar-benar berisi angka 8, siap dipakai untuk perhitungan lanjutan.

Ini adalah salah satu kesalahpahaman paling umum di kalangan pemrogram pemula, jadi mohon perhatikan baik-baik. print() hanya menampilkan teks di layar untuk dilihat manusia — setelah itu, nilainya hilang, tidak tersimpan di mana pun untuk dipakai program. Sebaliknya, return benar-benar mengirimkan nilai keluar dari fungsi agar bisa ditangkap oleh variabel dan dipakai untuk perhitungan berikutnya. Lihat contoh kiri: fungsi hitung_total hanya mem-print hasilnya, sehingga saat Anda coba menyimpannya ke variabel x dan memakainya lagi, Python akan menganggap x berisi None, yaitu "tidak ada apa-apa", dan program akan error saat mencoba menambah satu ke None. Contoh kanan memperbaikinya dengan return, sehingga x benar-benar berisi angka delapan dan bisa dipakai lagi. Aturan praktisnya: pakai print() kalau Anda hanya ingin menampilkan sesuatu untuk dibaca manusia, dan pakai return kalau hasil fungsi itu akan dipakai lagi oleh bagian lain program Anda.

Mengembalikan Lebih dari Satu Nilai

Python mengizinkan satu return mengirim beberapa nilai sekaligus, dipisahkan koma — dikemas otomatis jadi tuple (dibahas pertemuan 7).

KODE — RINCI PESANAN TOKO ONLINE

def rincian_pesanan(harga_satuan, jumlah): subtotal = harga_satuan * jumlah ongkir = 12000 total = subtotal + ongkir return subtotal, ongkir, total # 3 nilai sekaligus # tangkap ketiganya dengan 3 nama variabel sub, kirim, total_bayar = rincian_pesanan(45000, 2) print(sub, kirim, total_bayar) # 90000 12000 102000

Jumlah variabel penampung di kiri harus sama persis dengan jumlah nilai yang di-return — kalau tidak, Python akan error.

Kadang satu fungsi perlu menghasilkan lebih dari satu informasi. Fungsi rincian_pesanan ini menghitung tiga hal sekaligus: subtotal barang, ongkos kirim, dan total akhir yang harus dibayar. Perhatikan baris return-nya, ketiga nilai itu ditulis dipisah koma, dan Python otomatis mengemasnya menjadi satu paket yang disebut tuple — konsep yang akan kita pelajari lebih dalam di pertemuan ketujuh. Saat memanggil fungsi ini, Anda bisa langsung "membongkar" paket itu ke dalam tiga variabel terpisah, yaitu sub, kirim, dan total_bayar, dalam satu baris kode saja. Ini jauh lebih rapi dibanding membuat tiga fungsi terpisah untuk tiga informasi yang sebenarnya berasal dari perhitungan yang sama. Satu catatan penting: jumlah variabel penampung di sisi kiri harus sama persis dengan jumlah nilai yang dikembalikan fungsi, kalau Anda hanya menulis dua variabel untuk menangkap tiga nilai, Python akan menolaknya dengan pesan galat.

Scope: Wilayah Hidup Sebuah Variabel

Scope menentukan di bagian mana sebuah variabel bisa "dilihat" dan dipakai dalam program.

GLOBAL SCOPE vs LOCAL SCOPE

Variabel yang dibuat di dalam fungsi (local) otomatis hilang begitu fungsi selesai — hanya bisa diakses lewat return.

Sekarang kita bahas konsep terakhir hari ini, dan konsep ini akan sering menjebak kalau tidak dipahami sejak awal. Bayangkan global scope sebagai "ruang utama" toko Anda, tempat variabel seperti stok_toko hidup dan bisa dilihat dari mana saja di program. Sementara itu, setiap kali fungsi dipanggil, Python membuat "ruangan kecil" baru yang disebut local scope, tempat parameter dan variabel yang dibuat di dalam fungsi itu hidup. Ruangan kecil ini boleh mengintip dan membaca nilai dari ruang utama — itulah panah solid di diagram — tetapi ia tidak bisa langsung mengubah nilai di ruang utama begitu saja. Yang lebih penting lagi, begitu fungsi selesai dijalankan, seluruh isi ruangan kecil itu otomatis dibongkar dan hilang dari memori; satu-satunya cara membawa informasi keluar dari ruangan kecil itu adalah lewat return, seperti mengirim surat keluar sebelum ruangannya ditutup. Konsep ini akan kita buktikan dengan angka konkret di slide berikutnya.

Hitung dari Nol: Local Tidak Mengubah Global

Mari buktikan dengan angka bahwa variabel local di dalam fungsi tidak mengubah variabel global di luar fungsi.

KODE

stok_toko = 50 # GLOBAL def cek_stok(jumlah_terjual): sisa = stok_toko - jumlah_terjual # LOCAL return sisa hasil = cek_stok(12) print(hasil) # ? print(stok_toko) # ?

JEJAK EKSEKUSI, LANGKAH DEMI LANGKAH

Langkah	Perhitungan	Nilai
stok_toko dibuat (GLOBAL)	—	stok_toko = 50
Panggil cek_stok(12)	parameter LOCAL	jumlah_terjual = 12
Hitung sisa (LOCAL)	50 − 12	sisa = 38
return sisa	dikembalikan	hasil = 38
Cek stok_toko lagi	tidak tersentuh fungsi	stok_toko = 50 (TETAP!)

Fungsi cek_stok hanya membaca stok_toko, dan variabel sisa hanya hidup di dalam fungsi — begitu fungsi selesai, stok_toko di luar tetap 50.

Mari kita telusuri baris demi baris supaya konsep scope ini benar-benar melekat. Pertama, stok_toko dibuat di level global dengan nilai lima puluh. Kedua, kita memanggil cek_stok(12), dan angka dua belas itu dititipkan ke parameter jumlah_terjual yang sifatnya local, hanya hidup di dalam fungsi. Ketiga, di dalam fungsi dihitung sisa sama dengan lima puluh dikurangi dua belas, hasilnya tiga puluh delapan — perhatikan, fungsi ini boleh membaca stok_toko dari luar, tetapi tidak mengubahnya. Keempat, nilai tiga puluh delapan itu dikembalikan lewat return dan ditangkap oleh variabel hasil di level global. Kelima, dan ini bagian paling penting, ketika kita mengecek ulang stok_toko setelah fungsi selesai, nilainya tetap lima puluh, tidak berubah sedikit pun, karena variabel sisa yang dihitung di dalam fungsi sudah "menguap" begitu fungsi selesai bekerja. Inilah bukti konkret bahwa dunia di dalam fungsi dan dunia di luar fungsi punya batas yang jelas.

Coba Sendiri: Menelusuri Panggilan Fungsi dan Scope

Jalankan pemanggilan fungsi langkah demi langkah dan amati bagaimana parameter local terisi tanpa menyentuh variabel global.

Studi Kasus: Rakit Semua Konsep Jadi Satu Fungsi

Fungsi hitung_total_belanja ini menggabungkan parameter, default, dan return untuk kasir UMKM sungguhan.

KODE LENGKAP

def hitung_total_belanja(harga_satuan, jumlah, diskon_persen=0): subtotal = harga_satuan * jumlah potongan = subtotal * diskon_persen / 100 total = subtotal - potongan return total # pelanggan biasa, tanpa diskon (pakai default) print(hitung_total_belanja(45000, 3)) # 135000 # pelanggan member, diskon 10% (keyword argument) print(hitung_total_belanja(45000, 3, diskon_persen=10)) # 121500

Verifikasi cepat: 45.000 × 3 = 135.000 → potongan 10% = 13.500 → total = 135.000 − 13.500 = 121.500.

Sekarang kita gabungkan semua yang sudah dipelajari hari ini ke dalam satu fungsi yang realistis. Fungsi hitung_total_belanja punya tiga parameter: harga satuan dan jumlah yang wajib diisi, serta diskon persen yang punya nilai bawaan nol persen kalau tidak disebutkan. Untuk pelanggan biasa yang membeli tiga barang seharga empat puluh lima ribu rupiah tanpa diskon, kita cukup memanggil fungsi dengan dua argumen saja, dan hasilnya seratus tiga puluh lima ribu rupiah. Untuk pelanggan member yang dapat diskon sepuluh persen, kita tambahkan diskon_persen=10 sebagai keyword argument, dan hasilnya turun menjadi seratus dua puluh satu ribu lima ratus rupiah — silakan verifikasi sendiri perhitungannya di catatan Anda. Perhatikan bagaimana satu fungsi ini menggantikan puluhan baris kode yang seharusnya ditulis berulang untuk setiap transaksi, persis seperti yang kita janjikan di awal pertemuan tentang prinsip DRY.

Latihan Mandiri: Giliran Anda Merancang Fungsi

Kerjakan di IDE Anda (Thonny/VS Code) selama 15 menit. Kumpulkan berkas .py lewat portal e-learning sebelum kelas berakhir.

SOAL 1 — WAJIB

Buat fungsi hitung_ppn(harga_barang) yang mengembalikan nilai PPN.
Gunakan tarif PPN efektif 11% (PMK 131/2024) sebagai konstanta di dalam fungsi.
Uji dengan harga barang Rp 500.000 — tampilkan hasilnya dengan print().

SOAL 2 — TANTANGAN

Buat fungsi info_pesanan(nama, total, metode="COD") dengan metode berdefault "COD".
Fungsi harus return sebuah tuple berisi nama, total, dan metode.
Panggil sekali dengan default, sekali lagi dengan metode="Transfer" via keyword argument.

Sekarang giliran Anda mempraktikkan sendiri semua yang sudah kita bahas. Soal pertama wajib dikerjakan semua orang: buat fungsi sederhana untuk menghitung PPN dengan tarif efektif sebelas persen sesuai PMK 131/2024, lalu uji dengan harga barang lima ratus ribu rupiah. Soal kedua adalah tantangan tambahan bagi yang ingin memperdalam pemahaman tentang parameter default dan return banyak nilai sekaligus, dengan skenario metode pembayaran COD atau transfer seperti yang biasa Anda temui di aplikasi Shopee atau Tokopedia. Saya akan berkeliling kelas selama lima belas menit ke depan untuk membantu jika Anda mengalami kebuntuan, jadi jangan ragu mengangkat tangan. Kumpulkan berkas Python Anda lewat portal e-learning sebelum waktu kelas berakhir, dan pastikan nama berkasnya jelas menyertakan nama serta NIM Anda.

Ringkasan & Jembatan ke Pertemuan 7

EMPAT HAL YANG WAJIB ANDA KUASAI

Anatomi: def nama(parameter): lalu badan fungsi menjorok.
Parameter: positional, default, dan keyword argument.
Return: mengembalikan nilai untuk dipakai lagi — beda dari print().
Scope: variabel local hidup & mati di dalam fungsi; global tetap di luar.

MINGGU DEPAN — PERTEMUAN 7

LIST & TUPLE

Fungsi kita hari ini kadang perlu memproses banyak data pelanggan sekaligus — di situlah list dan tuple masuk sebagai wadah data terurut yang akan kita pelajari minggu depan.

Sebelum pertemuan berikutnya, pastikan Anda bisa membuat fungsi tanpa membuka catatan — ini fondasi untuk hampir seluruh sisa semester.

Mari kita rangkum perjalanan hari ini. Kita mulai dari mengapa fungsi dibutuhkan untuk menghindari kode berulang, lalu membedah anatominya lewat kata kunci def, parameter, dan badan fungsi. Kita lanjutkan ke parameter lanjutan berupa nilai default dan keyword argument yang membuat pemanggilan fungsi lebih fleksibel dan mudah dibaca. Kita juga menegaskan perbedaan krusial antara return dan print(), serta membuktikan dengan angka konkret bagaimana variabel local dan global punya wilayah hidupnya masing-masing. Minggu depan, di pertemuan ketujuh, kita akan belajar list dan tuple, dua struktur data yang memungkinkan fungsi kita memproses banyak data pelanggan sekaligus, bukan hanya satu per satu seperti hari ini — bayangkan fungsi yang bisa menghitung total belanja seratus pelanggan dalam satu kali panggilan. Sebelum pertemuan berikutnya, saya minta Anda berlatih membuat fungsi sederhana tanpa membuka catatan, karena kemampuan ini akan terus dipakai di hampir seluruh sisa semester, termasuk saat kita masuk ke object-oriented programming di pertemuan dua belas dan tiga belas.

Algoritma dan Pemrograman

Pertemuan 6 — Fungsi dalam Pemrograman: Parameter, Return, dan Scope

Tujuan Pembelajaran Hari Ini

Mengapa Kita Butuh Fungsi?

Apa Itu Fungsi? Anatomi def

Langkah Pertama: Fungsi Paling Sederhana

Alur Eksekusi: Apa yang Terjadi Saat Fungsi Dipanggil?

Fungsi dengan Parameter & Argument

Parameter dengan Nilai Bawaan (Default)

Keyword Argument: Memanggil Tanpa Terikat Urutan

Hitung dari Nol: Fungsi hitung_diskon()

return vs print(): Beda yang Krusial

Mengembalikan Lebih dari Satu Nilai

Scope: Wilayah Hidup Sebuah Variabel

Hitung dari Nol: Local Tidak Mengubah Global

Coba Sendiri: Menelusuri Panggilan Fungsi dan Scope

Studi Kasus: Rakit Semua Konsep Jadi Satu Fungsi

Latihan Mandiri: Giliran Anda Merancang Fungsi

Ringkasan & Jembatan ke Pertemuan 7

Apa Itu Fungsi? Anatomi `def`

Hitung dari Nol: Fungsi `hitung_diskon()`

`return` vs `print()`: Beda yang Krusial