Konsep Dasar Fungsi
Fungsi memberi nama pada operasi yang dapat digunakan ulang. Parameter menjelaskan input yang diterima, body menjalankan pekerjaan, dan statement dapat memberikan hasil kepada pemanggil.
For AI agents: use /llms.txt for the Nakafa content index.
Fungsi memberi nama pada operasi yang dapat digunakan ulang. Parameter menjelaskan input yang diterima, body menjalankan pekerjaan, dan statement dapat memberikan hasil kepada pemanggil.
returnDalam 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.
def nama_fungsi(parameter_list):
"""Docstring opsional untuk menjelaskan fungsi"""
# Blok kode yang akan dijalankan
statement_1
statement_2
return nilai_kembalian # OpsionalKomponen fungsi terdiri dari:
def untuk memulai definisi fungsireturn opsional untuk mengembalikan nilaiPemanggilan fungsi mengevaluasi ekspresi callable, mengikat argumen yang diberikan ke parameter, lalu mengeksekusi body fungsi di frame lokal baru.
# Definisi fungsi
def sapa(nama):
pesan = f"Halo, {nama}!"
return pesan
# Pemanggilan fungsi
hasil = sapa("Alice")
print(hasil) # Output: Halo, Alice!
# Pemanggilan langsung dalam print
print(sapa("Bob")) # Output: Halo, Bob!Proses yang terjadi saat pemanggilan fungsi:
return mengakhiri pemanggilan dengan nilai; mencapai akhir fungsi mengembalikan NoneParameter 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 posisi
print(perkenalan("Sari", 25))
# Output: Nama saya Sari, umur 25 tahun, tinggal di Jakarta
# Menggunakan parameter kata kunci
print(perkenalan(umur=30, nama="Budi", kota="Bandung"))
# Output: Nama saya Budi, umur 30 tahun, tinggal di Bandung
# Campuran parameter posisi dan kata kunci
print(perkenalan("Andi", umur=28, kota="Surabaya"))
# Output: Nama saya Andi, umur 28 tahun, tinggal di SurabayaAturan penting dalam penggunaan parameter:
Python memungkinkan signature mengumpulkan jumlah argumen yang bervariasi melalui *args dan **kwargs. Batas praktis tetap ditentukan oleh resource dan pekerjaan yang dilakukan fungsi.
def hitung_total(*angka):
"""Menghitung total dari sejumlah angka"""
total = 0
for num in angka:
total += num
return total
# Memanggil dengan berbagai jumlah argumen
print(hitung_total(1, 2, 3)) # Output: 6
print(hitung_total(5, 10, 15, 20)) # Output: 50
def 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 arguments
info_siswa("Maya", umur=20, jurusan="Informatika", ipk=3.8)
# Output:
# Nama: Maya
# Umur: 20
# Jurusan: Informatika
# Ipk: 3.8Parameter *args mengumpulkan argumen posisi tambahan ke dalam tuple, sedangkan **kwargs mengumpulkan argumen kata kunci tambahan ke dalam dictionary.
Fungsi dapat mengembalikan nilai menggunakan pernyataan return. Jika tidak ada return atau return tanpa nilai, fungsi akan mengembalikan None.
def luas_lingkaran(radius):
"""Menghitung luas lingkaran"""
import math
return math.pi * radius ** 2
def cari_min_max(daftar_angka):
"""Mengembalikan nilai minimum dan maksimum"""
if not daftar_angka:
return None, None
return min(daftar_angka), max(daftar_angka)
def cetak_pesan(pesan):
"""Fungsi tanpa return eksplisit"""
print(f"Pesan: {pesan}")
# Tidak ada return, otomatis return None
# Contoh penggunaan
luas = luas_lingkaran(5)
print(f"Luas lingkaran: {luas:.2f}") # Output: Luas lingkaran: 78.54
nilai_min, nilai_max = cari_min_max([3, 1, 4, 1, 5, 9])
print(f"Min: {nilai_min}, Max: {nilai_max}") # Output: Min: 1, Max: 9
hasil = cetak_pesan("Hello World") # Output: Pesan: Hello World
print(f"Hasil fungsi cetak_pesan: {hasil}") # Output: Hasil fungsi cetak_pesan: NoneVariabel dalam Python memiliki lingkup (scope) yang menentukan di mana variabel dapat diakses. Pemahaman tentang lingkup variabel penting untuk menghindari kesalahan dalam program.
# Variabel global
counter = 0
def tambah_counter():
# Variabel lokal dengan nama sama
counter = 10
print(f"Counter lokal: {counter}")
def tambah_global_counter():
global counter
counter += 1
print(f"Counter global: {counter}")
# Demonstrasi penggunaan
print(f"Counter awal: {counter}") # Output: Counter awal: 0
tambah_counter() # Output: Counter lokal: 10
print(f"Counter setelah fungsi: {counter}") # Output: Counter setelah fungsi: 0
tambah_global_counter() # Output: Counter global: 1
print(f"Counter akhir: {counter}") # Output: Counter akhir: 1Aturan pencarian variabel mengikuti urutan LEGB:
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.
def kali_dua(x):
return x * 2
def kali_tiga(x):
return x * 3
def terapkan_operasi(fungsi, nilai):
"""Menerapkan fungsi pada nilai"""
return fungsi(nilai)
# Menyimpan fungsi dalam variabel
operasi = kali_dua
print(operasi(5)) # Output: 10
# Menyimpan fungsi dalam list
daftar_operasi = [kali_dua, kali_tiga]
for op in daftar_operasi:
print(op(4)) # Output: 8 kemudian 12
# Mengirim fungsi sebagai argumen
hasil1 = terapkan_operasi(kali_dua, 7)
hasil2 = terapkan_operasi(kali_tiga, 7)
print(f"Hasil: {hasil1}, {hasil2}") # Output: Hasil: 14, 21Docstring adalah string literal yang muncul sebagai pernyataan pertama dalam definisi fungsi. Docstring berfungsi sebagai dokumentasi untuk menjelaskan tujuan dan cara penggunaan fungsi.
def hitung_faktorial(n):
"""
Menghitung faktorial dari bilangan bulat positif.
Parameter:
n (int): Bilangan bulat nonnegatif
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 docstring
print(hitung_faktorial.__doc__)
# Menggunakan fungsi
print(hitung_faktorial(5)) # Output: 120
print(hitung_faktorial(0)) # Output: 1Konvensi penulisan docstring yang baik:
Python mengizinkan definisi fungsi di dalam fungsi lain. Ketika inner function yang dikembalikan mempertahankan free variable dari enclosing scope, fungsi dan environment yang dipertahankan itu membentuk closure.
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 khusus
pengali_dua = buat_pengali(2)
pengali_lima = buat_pengali(5)
print(pengali_dua(10)) # Output: 20
print(pengali_lima(4)) # Output: 20
def 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 kalkulator
calc = kalkulator_sederhana()
print(calc['tambah'](5, 3)) # Output: 8
print(calc['kurang'](10, 4)) # Output: 6
print(calc['kali'](6, 7)) # Output: 42Fungsi perlu menyatakan input yang diterima dan gagal secara eksplisit ketika kontrak itu dilanggar. Tangkap exception hanya ketika kode dapat memulihkan keadaan, menambah konteks yang berguna, atau menyajikan kegagalan kepada pengguna.
def bagi(pembilang, penyebut):
"""Membagi dua bilangan riil dengan kontrak input eksplisit."""
if not isinstance(pembilang, (int, float)):
raise TypeError("Pembilang harus berupa bilangan riil")
if not isinstance(penyebut, (int, float)):
raise TypeError("Penyebut harus berupa bilangan riil")
if penyebut == 0:
raise ValueError("Penyebut tidak boleh nol")
return pembilang / penyebut
def konversi_ke_int(nilai):
"""Konversi nilai yang didukung dan pertahankan error dari Python."""
return int(nilai)
# Pemanggilan yang berhasil tetap langsung
print(f"Hasil pembagian: {bagi(10, 2)}")
# Output: Hasil pembagian: 5.0
print(konversi_ke_int("123"))
# Output: 123
# Tangkap di boundary presentasi tempat pemulihan memungkinkan
for nilai in ("abc", [1, 2]):
try:
print(konversi_ke_int(nilai))
except (TypeError, ValueError) as error:
print(f"Tidak dapat mengonversi {nilai!r}: {error}")