Fungsi dalam Python adalah blok kode yang dapat digunakan berulang kali untuk melakukan tugas tertentu. Bayangkan fungsi seperti mesin kopi otomatis yang kamu berikan bahan (input), kemudian mesin tersebut memproses dan menghasilkan kopi (output). Setiap kali kamu ingin kopi, kamu tidak perlu membuat mesin baru, cukup gunakan mesin yang sama.
Dalam pemrograman, fungsi membantu kita menghindari penulisan kode yang sama berulang kali. Fungsi memiliki nama, dapat menerima parameter (data masukan), dan dapat mengembalikan nilai.
Setiap fungsi dalam Python memiliki struktur dasar yang terdiri dari beberapa komponen penting.
struktur_fungsi.py
def nama_fungsi(parameter_list): """Docstring opsional untuk menjelaskan fungsi""" # Blok kode yang akan dijalankan statement_1 statement_2 return nilai_kembalian # Opsional
Komponen fungsi terdiri dari:
Kata kunci def untuk memulai definisi fungsi
Nama fungsi yang mengikuti aturan penamaan variabel Python
Tanda kurung yang berisi daftar parameter (bisa kosong)
Titik dua untuk mengakhiri baris definisi
Blok kode yang diindentasi
Pernyataan return opsional untuk mengembalikan nilai
Parameter adalah variabel yang didefinisikan dalam fungsi, sedangkan argumen adalah nilai aktual yang dikirimkan saat memanggil fungsi. Python menyediakan beberapa jenis parameter untuk fleksibilitas yang lebih besar.
def perkenalan(nama, umur, kota="Jakarta"): return f"Nama saya {nama}, umur {umur} tahun, tinggal di {kota}"# Menggunakan parameter posisiprint(perkenalan("Sari", 25))# Output: Nama saya Sari, umur 25 tahun, tinggal di Jakarta# Menggunakan parameter kata kunciprint(perkenalan(umur=30, nama="Budi", kota="Bandung"))# Output: Nama saya Budi, umur 30 tahun, tinggal di Bandung# Campuran parameter posisi dan kata kunciprint(perkenalan("Andi", umur=28, kota="Surabaya"))# Output: Nama saya Andi, umur 28 tahun, tinggal di Surabaya
Aturan penting dalam penggunaan parameter:
Parameter posisi harus diberikan sesuai urutan
Parameter kata kunci dapat diberikan dalam urutan apa saja
Parameter posisi harus ditulis sebelum parameter kata kunci
Python memungkinkan fungsi menerima jumlah argumen yang tidak terbatas menggunakan *args dan **kwargs.
parameter_variabel.py
def hitung_total(*angka): """Menghitung total dari sejumlah angka""" total = 0 for num in angka: total += num return total# Memanggil dengan berbagai jumlah argumenprint(hitung_total(1, 2, 3)) # Output: 6print(hitung_total(5, 10, 15, 20)) # Output: 50def info_siswa(nama, **detail): """Menampilkan informasi siswa dengan detail tambahan""" print(f"Nama: {nama}") for kunci, nilai in detail.items(): print(f"{kunci.capitalize()}: {nilai}")# Memanggil dengan keyword argumentsinfo_siswa("Maya", umur=20, jurusan="Informatika", ipk=3.8)# Output:# Nama: Maya# Umur: 20# Jurusan: Informatika# Ipk: 3.8
Parameter *args mengumpulkan argumen posisi tambahan ke dalam tuple, sedangkan **kwargs mengumpulkan argumen kata kunci tambahan ke dalam dictionary.
Variabel dalam Python memiliki lingkup (scope) yang menentukan di mana variabel dapat diakses. Pemahaman tentang lingkup variabel penting untuk menghindari kesalahan dalam program.
Dalam Python, fungsi adalah objek kelas pertama, yang berarti fungsi dapat diperlakukan seperti data lainnya. Kamu dapat menyimpan fungsi dalam variabel, mengirimkan fungsi sebagai argumen, atau mengembalikan fungsi dari fungsi lain.
first_class_functions.py
def kali_dua(x): return x * 2def kali_tiga(x): return x * 3def terapkan_operasi(fungsi, nilai): """Menerapkan fungsi pada nilai""" return fungsi(nilai)# Menyimpan fungsi dalam variabeloperasi = kali_duaprint(operasi(5)) # Output: 10# Menyimpan fungsi dalam listdaftar_operasi = [kali_dua, kali_tiga]for op in daftar_operasi: print(op(4)) # Output: 8 kemudian 12# Mengirim fungsi sebagai argumenhasil1 = terapkan_operasi(kali_dua, 7)hasil2 = terapkan_operasi(kali_tiga, 7)print(f"Hasil: {hasil1}, {hasil2}") # Output: Hasil: 14, 21
Docstring adalah string literal yang muncul sebagai pernyataan pertama dalam definisi fungsi. Docstring berfungsi sebagai dokumentasi untuk menjelaskan tujuan dan cara penggunaan fungsi.
docstring_example.py
def hitung_faktorial(n): """ Menghitung faktorial dari bilangan bulat positif. Parameter: n (int): Bilangan bulat positif Returns: int: Nilai faktorial dari n Raises: ValueError: Jika n negatif TypeError: Jika n bukan bilangan bulat Contoh: >>> hitung_faktorial(5) 120 >>> hitung_faktorial(0) 1 """ if not isinstance(n, int): raise TypeError("Input harus berupa bilangan bulat") if n < 0: raise ValueError("Input harus bilangan positif atau nol") if n <= 1: return 1 return n * hitung_faktorial(n - 1)# Mengakses docstringprint(hitung_faktorial.__doc__)# Menggunakan fungsiprint(hitung_faktorial(5)) # Output: 120print(hitung_faktorial(0)) # Output: 1
Konvensi penulisan docstring yang baik:
Baris pertama berisi ringkasan singkat fungsi
Jika perlu penjelasan tambahan, pisahkan dengan baris kosong
Jelaskan parameter, nilai kembalian, dan exception yang mungkin terjadi
Python memungkinkan definisi fungsi di dalam fungsi lain. Fungsi dalam dapat mengakses variabel dari fungsi luar, menciptakan konsep yang disebut closure.
nested_functions.py
def buat_pengali(faktor): """Membuat fungsi pengali dengan faktor tertentu""" def pengali(nilai): """Fungsi dalam yang mengali nilai dengan faktor""" return nilai * faktor return pengali# Membuat fungsi pengali khususpengali_dua = buat_pengali(2)pengali_lima = buat_pengali(5)print(pengali_dua(10)) # Output: 20print(pengali_lima(4)) # Output: 20def kalkulator_sederhana(): """Kalkulator dengan fungsi bersarang""" def tambah(a, b): return a + b def kurang(a, b): return a - b def kali(a, b): return a * b # Mengembalikan dictionary berisi fungsi-fungsi return { 'tambah': tambah, 'kurang': kurang, 'kali': kali }# Menggunakan kalkulatorcalc = kalkulator_sederhana()print(calc['tambah'](5, 3)) # Output: 8print(calc['kurang'](10, 4)) # Output: 6print(calc['kali'](6, 7)) # Output: 42
Fungsi yang baik harus dapat menangani situasi error dengan graceful. Python menyediakan mekanisme exception handling untuk menangani kesalahan yang mungkin terjadi.
error_handling.py
def bagi_aman(pembilang, penyebut): """ Melakukan pembagian dengan penanganan error. Returns: tuple: (hasil, pesan_error) """ try: hasil = pembilang / penyebut return hasil, None except ZeroDivisionError: return None, "Error: Tidak dapat membagi dengan nol" except TypeError: return None, "Error: Input harus berupa angka"def konversi_ke_int(nilai): """Konversi nilai ke integer dengan validasi""" try: return int(nilai) except ValueError: print(f"Warning: '{nilai}' tidak dapat dikonversi ke integer") return None except TypeError: print("Error: Input tidak valid untuk konversi") return None# Contoh penggunaanhasil, error = bagi_aman(10, 2)if error: print(error)else: print(f"Hasil pembagian: {hasil}") # Output: Hasil pembagian: 5.0hasil, error = bagi_aman(10, 0)if error: print(error) # Output: Error: Tidak dapat membagi dengan nol# Test konversiangka1 = konversi_ke_int("123") # Berhasil, return 123angka2 = konversi_ke_int("abc") # Output: Warning: 'abc' tidak dapat dikonversi ke integerangka3 = konversi_ke_int([1, 2]) # Output: Error: Input tidak valid untuk konversi
