Fungsi

Apa itu Fungsi?

Fungsi adalah blok kode yang dapat digunakan kembali dan hanya dijalankan ketika dipanggil. Fungsi membantu membuat kode lebih modular, readable, dan maintainable.

Membuat Fungsi Dasar

Definisi Fungsi

# Fungsi tanpa parameter
def sapa():
    print("Halo, selamat datang!")

# Memanggil fungsi
sapa()  # Output: Halo, selamat datang!
sapa()  # Bisa dipanggil berkali-kali

Function Syntax

Format dasar fungsi Python:

def nama_fungsi(parameters):
    """Docstring (opsional)"""
    # Function body
    return value  # opsional

Fungsi dengan Parameter

# Satu parameter
def sapa_nama(nama):
    print(f"Halo, {nama}! Selamat datang!")

sapa_nama("Budi")  # Halo, Budi! Selamat datang!
sapa_nama("Ani")   # Halo, Ani! Selamat datang!

# Multiple parameters
def perkenalan(nama, usia, kota):
    print(f"Nama saya {nama}, usia {usia} tahun, dari {kota}")

perkenalan("Budi", 20, "Jakarta")

Parameter Default

Default Parameter Values

def sapa_lengkap(nama, pesan="Selamat datang!"):
    print(f"Halo, {nama}! {pesan}")

# Pakai default
sapa_lengkap("Budi")
# Output: Halo, Budi! Selamat datang!

# Override default
sapa_lengkap("Ani", "Semoga harimu menyenangkan!")
# Output: Halo, Ani! Semoga harimu menyenangkan!

Default Parameter Order

Parameter dengan default value harus setelah parameter tanpa default:

#  Benar
def fungsi(a, b, c=10, d=20):
    pass

#  Salah - non-default after default
def fungsi(a, b=10, c, d=20):  # SyntaxError!
    pass

Return Statement

Fungsi dengan Return

# Return single value
def jumlah(a, b):
    return a + b

hasil = jumlah(5, 3)
print(f"5 + 3 = {hasil}")

# Return multiple values (tuple)
def operasi_aritmatika(a, b):
    tambah = a + b
    kurang = a - b
    kali = a * b
    bagi = a / b if b != 0 else None
    return tambah, kurang, kali, bagi

# Unpack multiple returns
hasil_tambah, hasil_kurang, hasil_kali, hasil_bagi = operasi_aritmatika(10, 2)
print(f"Tambah: {hasil_tambah}")
print(f"Kurang: {hasil_kurang}")
print(f"Kali: {hasil_kali}")
print(f"Bagi: {hasil_bagi}")

Keyword Arguments

Positional vs Keyword Arguments

def info_mahasiswa(nama, nim, jurusan):
    print(f"Nama: {nama}")
    print(f"NIM: {nim}")
    print(f"Jurusan: {jurusan}")

# Positional arguments (urutan penting)
info_mahasiswa("Budi", "12345", "Informatika")

# Keyword arguments (urutan tidak penting)
info_mahasiswa(nim="12345", jurusan="Informatika", nama="Budi")

# Mixed (positional first, then keyword)
info_mahasiswa("Budi", nim="12345", jurusan="Informatika")

Variable-Length Arguments

# *args untuk variable number of positional arguments
def jumlahkan(*angka):
    total = sum(angka)
    return total

print(jumlahkan(1, 2, 3))           # 6
print(jumlahkan(10, 20, 30, 40))    # 100
print(jumlahkan(5))                 # 5

# Mengakses args
def print_semua(*items):
    for i, item in enumerate(items, 1):
        print(f"{i}. {item}")

print_semua("Apel", "Jeruk", "Mangga")

# **kwargs untuk variable number of keyword arguments
def info_user(**data):
    for key, value in data.items():
        print(f"{key}: {value}")

info_user(nama="Budi", usia=20, kota="Jakarta")
# Output:
# nama: Budi
# usia: 20
# kota: Jakarta

# Kombinasi dengan fixed parameters
def buat_profil(nama, **info):
    print(f"Nama: {nama}")
    for key, value in info.items():
        print(f"{key}: {value}")

buat_profil("Budi", usia=20, kota="Jakarta", hobby="Coding")

# Kombinasi semua jenis parameters
def fungsi_lengkap(a, b, c=10, *args, **kwargs):
    print(f"a={a}, b={b}, c={c}")
    print(f"args: {args}")
    print(f"kwargs: {kwargs}")

fungsi_lengkap(1, 2)
fungsi_lengkap(1, 2, 3, 4, 5, x=10, y=20)

# Urutan parameter harus:
# 1. Positional
# 2. Default
# 3. *args
# 4. **kwargs

Lambda Functions

Lambda adalah anonymous function (fungsi tanpa nama) yang singkat.

Lambda Functions

# Regular function
def kuadrat(x):
    return x ** 2

# Lambda equivalent
kuadrat = lambda x: x ** 2

print(kuadrat(5))  # 25

# Lambda dengan multiple parameters
jumlah = lambda a, b: a + b
print(jumlah(3, 5))  # 8

# Lambda dalam sorted()
mahasiswa = [
    {"nama": "Budi", "nilai": 85},
    {"nama": "Ani", "nilai": 92},
    {"nama": "Citra", "nilai": 78}
]

# Sort by nilai
sorted_mhs = sorted(mahasiswa, key=lambda x: x["nilai"], reverse=True)
for mhs in sorted_mhs:
    print(f"{mhs['nama']}: {mhs['nilai']}")

# Lambda dengan map()
angka = [1, 2, 3, 4, 5]
kuadrat_list = list(map(lambda x: x**2, angka))
print(kuadrat_list)  # [1, 4, 9, 16, 25]

# Lambda dengan filter()
genap = list(filter(lambda x: x % 2 == 0, angka))
print(genap)  # [2, 4]

When to Use Lambda

Lambda best untuk:

Simple operations dalam one-liner
Sebagai argument untuk functions seperti map(), filter(), sorted()

Gunakan regular function untuk:

Logic yang kompleks
Multiple statements
Readability lebih penting

Scope Variabel

Local vs Global Scope

# Global variable
x = 10

def fungsi1():
    # Local variable
    x = 20  # Ini variable lokal, tidak mempengaruhi global x
    print(f"Di dalam fungsi: x = {x}")

fungsi1()  # x = 20
print(f"Di luar fungsi: x = {x}")  # x = 10

# Mengakses global variable
def fungsi2():
    global y
    y = 30  # Modifikasi global variable

fungsi2()
print(f"y = {y}")  # 30

# Nested function dan nonlocal
def outer():
    x = 10

    def inner():
        nonlocal x  # Akses variable dari outer function
        x = 20

    inner()
    print(f"x di outer: {x}")  # 20

outer()

Global Variables

Hindari menggunakan global jika memungkinkan. Lebih baik gunakan parameter dan return value untuk komunikasi antar fungsi.

Docstrings

Function Documentation

def hitung_bmi(berat, tinggi):
    """
    Menghitung Body Mass Index (BMI).

    Parameters:
    berat (float): Berat badan dalam kilogram
    tinggi (float): Tinggi badan dalam meter

    Returns:
    float: Nilai BMI
    str: Kategori BMI

    Example:
    >>> hitung_bmi(70, 1.75)
    (22.86, 'Normal')
    """
    bmi = berat / (tinggi ** 2)

    if bmi < 18.5:
        kategori = "Berat badan kurang"
    elif bmi < 25:
        kategori = "Normal"
    elif bmi < 30:
        kategori = "Berat badan berlebih"
    else:
        kategori = "Obesitas"

    return round(bmi, 2), kategori

# Mengakses docstring
print(hitung_bmi.__doc__)

# Built-in help
help(hitung_bmi)

Higher-Order Functions

Functions sebagai first-class objects - bisa dijadikan parameter atau return value.

Higher-Order Functions

# Function sebagai parameter
def apply_operation(a, b, operation):
    return operation(a, b)

add = lambda x, y: x + y
multiply = lambda x, y: x * y

print(apply_operation(5, 3, add))       # 8
print(apply_operation(5, 3, multiply))  # 15

# Function sebagai return value
def create_multiplier(n):
    def multiplier(x):
        return x * n
    return multiplier

times_two = create_multiplier(2)
times_three = create_multiplier(3)

print(times_two(5))    # 10
print(times_three(5))  # 15

Recursion

Fungsi yang memanggil dirinya sendiri.

Recursive Functions

# Factorial
def factorial(n):
    if n == 0 or n == 1:
        return 1
    return n * factorial(n - 1)

print(factorial(5))  # 120

# Fibonacci
def fibonacci(n):
    if n <= 1:
        return n
    return fibonacci(n-1) + fibonacci(n-2)

print([fibonacci(i) for i in range(10)])
# [0, 1, 1, 2, 3, 5, 8, 13, 21, 34]

Recursion Limit

Python memiliki recursion limit (default 1000). Untuk data besar, gunakan iterative approach atau sys.setrecursionlimit().

Best Practices

#  Good practices
def calculate_total_price(items, tax_rate=0.1):
    """
    Clear name, descriptive parameters, docstring.
    """
    subtotal = sum(item['price'] for item in items)
    tax = subtotal * tax_rate
    return subtotal + tax

#  Single responsibility
def validate_email(email):
    """One function, one job."""
    return '@' in email and '.' in email.split('@')[1]

#  Return early
def process_data(data):
    if not data:
        return None
    if len(data) < 5:
        return "Too short"
    # Process...
    return result

Latihan

Buat fungsi untuk convert suhu (Celsius ↔ Fahrenheit ↔ Kelvin)
Buat fungsi untuk cek bilangan prima
Implementasikan calculator dengan functions untuk setiap operasi
Buat fungsi rekursif untuk menghitung pangkat
Gunakan lambda untuk sort list of dictionaries

Apa Selanjutnya?

Selanjutnya kita akan belajar tentang Struktur Data (List, Dictionary, Tuple, Set)!

On this page