# Nakafa Learning Content

> For AI agents: use [llms.txt](https://nakafa.com/llms.txt) for the site index. Markdown versions are available by appending `.md` to content URLs or sending `Accept: text/markdown`.

URL: https://nakafa.com/id/materi/ai-ds/pemrograman-ai/fungsi
Source: https://raw.githubusercontent.com/nakafaai/nakafa.com/refs/heads/main/packages/contents/material/lesson/ai-ds/ai-programming/function/id.mdx

Pelajari fungsi Python, termasuk parameter, return values, scope variabel, closure, dan error handling dengan contoh kode.

---

## Konsep Dasar Fungsi

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.

## Struktur dan Sintaks Fungsi

Setiap fungsi dalam Python memiliki struktur dasar yang terdiri dari beberapa komponen penting.

File: struktur_fungsi.py
```python
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:

1. Kata kunci `def` untuk memulai definisi fungsi
2. Nama fungsi yang mengikuti aturan penamaan variabel Python
3. Tanda kurung yang berisi daftar parameter (bisa kosong)
4. Titik dua untuk mengakhiri baris definisi
5. Blok kode yang diindentasi
6. Pernyataan `return` opsional untuk mengembalikan nilai

## Cara Kerja Pemanggilan Fungsi

Ketika kamu memanggil fungsi, Python akan menjalankan kode di dalam fungsi tersebut. Mari kita lihat contoh sederhana bagaimana fungsi bekerja.

File: contoh_fungsi.py
```python
# 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:

1. Python mencari definisi fungsi dengan nama yang dipanggil
2. Argumen yang diberikan dikirim ke parameter fungsi
3. Kode di dalam fungsi dieksekusi
4. Jika ada `return`, nilai dikembalikan ke tempat pemanggilan

## Parameter dan Argumen

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.

### Parameter Posisi dan Kata Kunci

File: parameter_fungsi.py
```python
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 Surabaya
```

Aturan penting dalam penggunaan parameter:

1. Parameter posisi harus diberikan sesuai urutan
2. Parameter kata kunci dapat diberikan dalam urutan apa saja
3. Parameter posisi harus ditulis sebelum parameter kata kunci
4. Parameter dengan nilai default bersifat opsional

### Parameter dengan Jumlah Variabel

Python memungkinkan fungsi menerima jumlah argumen yang tidak terbatas menggunakan `*args` dan `**kwargs`.

File: parameter_variabel.py
```python
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.8
```

Parameter `*args` mengumpulkan argumen posisi tambahan ke dalam tuple, sedangkan `**kwargs` mengumpulkan argumen kata kunci tambahan ke dalam dictionary.

## Nilai Kembalian Fungsi

Fungsi dapat mengembalikan nilai menggunakan pernyataan `return`. Jika tidak ada `return` atau `return` tanpa nilai, fungsi akan mengembalikan `None`.

File: return_values.py
```python
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: None
```

## Lingkup Variabel dalam Fungsi

Variabel dalam Python memiliki lingkup (scope) yang menentukan di mana variabel dapat diakses. Pemahaman tentang lingkup variabel penting untuk menghindari kesalahan dalam program.

Component: Mermaid
Props:
- title: Di Mana Variabel Fungsi Bisa Dibaca
- description: Ikuti pencarian nama dari ruang lokal ke luar fungsi agar aturan scope mudah dilacak.
```mermaid

  flowchart TD
      A[Built-in Scope] --> B[Global Scope]
      B --> C[Enclosing Scope]
      C --> D[Local Scope]
      A1[Fungsi bawaan] --> A
      B1[Variabel global] --> B
      C1[Variabel enclosing] --> C
      D1[Variabel lokal] --> D

```

### Variabel Lokal dan Global

File: scope_variables.py
```python
# 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: 1
```

Aturan pencarian variabel mengikuti urutan LEGB:

1. **Local** - di dalam fungsi saat ini
2. **Enclosing** - di fungsi yang membungkus (untuk nested functions)
3. **Global** - di level modul
4. **Built-in** - nama built-in Python

## Fungsi sebagai Objek Kelas Pertama

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.

File: first_class_functions.py
```python
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, 21
```

## Dokumentasi Fungsi dengan Docstring

Docstring adalah string literal yang muncul sebagai pernyataan pertama dalam definisi fungsi. Docstring berfungsi sebagai dokumentasi untuk menjelaskan tujuan dan cara penggunaan fungsi.

File: docstring_example.py
```python
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 docstring
print(hitung_faktorial.__doc__)

# Menggunakan fungsi
print(hitung_faktorial(5))  # Output: 120
print(hitung_faktorial(0))  # Output: 1
```

Konvensi penulisan docstring yang baik:

1. Baris pertama berisi ringkasan singkat fungsi
2. Jika perlu penjelasan tambahan, pisahkan dengan baris kosong
3. Jelaskan parameter, nilai kembalian, dan exception yang mungkin terjadi
4. Berikan contoh penggunaan jika membantu

## Fungsi Bersarang dan Closure

Python memungkinkan definisi fungsi di dalam fungsi lain. Fungsi dalam dapat mengakses variabel dari fungsi luar, menciptakan konsep yang disebut closure.

File: nested_functions.py
```python
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: 42
```

## Penanganan Error dalam Fungsi

Fungsi yang baik harus dapat menangani situasi error dengan graceful. Python menyediakan mekanisme exception handling untuk menangani kesalahan yang mungkin terjadi.

File: error_handling.py
```python
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 penggunaan
hasil, error = bagi_aman(10, 2)
if error:
  print(error)
else:
  print(f"Hasil pembagian: {hasil}")  # Output: Hasil pembagian: 5.0

hasil, error = bagi_aman(10, 0)
if error:
  print(error)  # Output: Error: Tidak dapat membagi dengan nol

# Test konversi
angka1 = konversi_ke_int("123")    # Berhasil, return 123
angka2 = konversi_ke_int("abc")    # Output: Warning: 'abc' tidak dapat dikonversi ke integer
angka3 = konversi_ke_int([1, 2])   # Output: Error: Input tidak valid untuk konversi
```