Python - Petunjuk Awal untuk Anotasi Fungsi

Halo, para programmer Python yang berbakat! Hari ini, kita akan memasuki dunia yang menarik dari Anotasi Fungsi. Jangan khawatir jika kamu masih baru di bidang pemrograman – saya akan memandu kamu melalui konsep ini langkah demi langkah, sama seperti yang saya lakukan untuk banyak siswa selama tahun-tahun pengajaran saya. Jadi, ambil minuman favorit kamu, rasakan kenyamananmu, dan mari kita melakukan petualangan Python ini bersama-sama!

Apa itu Anotasi Fungsi?

Anotasi fungsi adalah fitur di Python yang memungkinkan kita untuk menambahkan metadata ke parameter fungsi dan nilai kembalian. Pernahkah kamu mendengar tentang catatan kecil yang kita letakkan di atas fungsi kita untuk memberikan informasi ekstra? Mereka tidak mempengaruhi bagaimana fungsi bekerja, tetapi bisa sangat membantu untuk dokumentasi dan pemeriksaan tipe.

Ayo kita mulai dengan contoh sederhana:

def sapa(nama: str) -> str:
return f"Halo, {nama}!"

Dalam contoh ini, : str setelah nama adalah anotasi yang menyiratkan bahwa nama harus berupa string. Sedangkan -> str di akhir menyiratkan bahwa fungsi akan mengembalikan string.

Mengapa Menggunakan Anotasi Fungsi?

1. Membuat kode kamu lebih mudah dibaca.
2. Membantu developer lain (dan kamu di masa depan!) memahami kode kamu lebih baik.
3. Dapat digunakan oleh alat pemeriksaan tipe untuk menangkap kesalahan potensial.

Sekarang, mari kita telusuri lebih jauh tentang jenis-jenis anotasi yang berbeda!

Anotasi Fungsi dengan Parameter

Kita dapat mengannotate parameter fungsi untuk menunjukkan jenis data yang diharapkan. Ini adalah contoh:

def hitung_luas(panjang: float, lebar: float) -> float:
return panjang * lebar

Dalam fungsi ini, kita menyatakan bahwa baik panjang dan lebar harus berupa float (angka desimal), dan fungsi akan mengembalikan float.

Ayo cobalah untuk menggunakannya:

luas = hitung_luas(5.5, 3.2)
print(f"Luasnya adalah: {luas}")

Output:

Luasnya adalah: 17.6

Ingat, anotasi ini tidak mengeksekusi jenis – kamu masih bisa memanggil hitung_luas("halo", "dunia"), tapi itu tidak akan memiliki arti yang baik!

Anotasi Fungsi dengan Tipe Kembalian

Kita sudah melihat anotasi -> float untuk tipe kembalian, tapi mari lihat contoh yang lebih kompleks:

def get_info_pengguna(user_id: int) -> dict:
# Bayangkan bahwa fungsi ini mengambil data pengguna dari database
return {
"id": user_id,
"nama": "Alice",
"umur": 30,
"email": "[email protected]"
}

pengguna = get_info_pengguna(12345)
print(f"Nama pengguna: {pengguna['nama']}")

Output:

Nama pengguna: Alice

Di sini, kita menunjukkan bahwa fungsi mengambil integer user_id dan mengembalikan sebuah dictionary.

Anotasi Fungsi dengan Ekspresi

Anotasi tidak harus hanya tipe sederhana – mereka juga dapat berupa ekspresi yang lebih kompleks. Ini adalah contoh:

from typing import List, Union

def proses_item(items: List[Union[int, str]]) -> List[str]:
return [str(item).upper() for item in items]

hasil = proses_item([1, "halo", 42, "dunia"])
print(hasil)

Output:

['1', 'HALO', '42', 'DUNIA']

Dalam contoh ini, List[Union[int, str]] berarti fungsi mengharapkan sebuah daftar di mana setiap item dapat berupa integer atau string.

Anotasi Fungsi dengan Argumen Default

Kita dapat menggabungkan anotasi dengan argumen default. Ini adalah cara nya:

def sapa_pengguna(nama: str = "Tamu") -> str:
return f"Selamat datang, {nama}!"

print(sapa_pengguna())
print(sapa_pengguna("Alice"))

Output:

Selamat datang, Tamu!
Selamat datang, Alice!

Dalam fungsi ini, kita menyatakan bahwa nama harus berupa string, dan jika tidak ada nama yang diberikan, itu default ke "Tamu".

Menggabungkan Semua itu

Sekarang, mari lihat contoh yang lebih kompleks yang menggabungkan berbagai teknik anotasi:

from typing import List, Dict, Union

def analisis_penjualan(data: List[Dict[str, Union[str, float]]]) -> Dict[str, float]:
total_penjualan = 0.0
item_terjual = 0

for transaksi in data:
total_penjualan += transaksi['jumlah']
item_terjual += 1

return {
"total_penjualan": total_penjualan,
"rata_rata_penjualan": total_penjualan / item_terjual if item_terjual > 0 else 0
}

data_penjualan = [
{"item": "Widget A", "jumlah": 10.99},
{"item": "Widget B", "jumlah": 5.99},
{"item": "Widget C", "jumlah": 15.99}
]

hasil = analisis_penjualan(data_penjualan)
print(f"Total penjualan: ${hasil['total_penjualan']:.2f}")
print(f"Rata-rata penjualan: ${hasil['rata_rata_penjualan']:.2f}")

Output:

Total penjualan: $32.97
Rata-rata penjualan: $10.99

Contoh ini menunjukkan cara kita dapat menggunakan anotasi kompleks untuk menggambarkan struktur data masukan dan nilai kembalian kita.

Ringkasan Metode Anotasi Fungsi

Berikut adalah tabel yang meng ringkaskan cara yang berbeda kita dapat menggunakan anotasi fungsi:

Metode	Contoh	Deskripsi
Anotasi Parameter	def func(x: int):	Menyarankan tipe untuk parameter
Anotasi Tipe Kembalian	def func() -> str:	Menyarankan tipe kembalian fungsi
Nilai Default dengan Anotasi	def func(x: int = 0):	Menggabungkan petunjuk tipe dengan nilai default
Anotasi Tipe Kompleks	def func(x: List[int]):	Menggunakan tipe dari modul typing untuk petunjuk tipe yang lebih spesifik
Beberapa Tipe (Union)	def func(x: Union[int, str]):	Menyarankan bahwa parameter dapat berupa salah satu dari beberapa tipe

Ingat, petunjuk ini adalah petunjuk, bukan aturan yang ketat. Python tidak akan menghentikan kamu dari menggunakan tipe yang berbeda, tetapi alat seperti mypy dapat menggunakan anotasi ini untuk menangkap kesalahan potensial sebelum kamu menjalankan kode kamu.

Dan itu adalah semua, para murid yang tercinta! Kita telah melakukan perjalanan melalui wilayah Anotasi Fungsi Python. Saya harap panduan ini telah menjelaskan konsep ini untuk kamu. Ingat, cara terbaik untuk belajar adalah dengan melakukan, jadi jangan segan untuk menguji anotasi ini di kode kamu sendiri. Selamat coding, dan semoga fungsi kamu selalu diannotate dengan baik!

Credits: Image by storyset