Panduan Penggunaan Anotasi Fungsi Python: Untuk Pemula

Halo, pemrogram Python yang berbakat! Hari ini, kita akan menyelam ke dunia yang menarik tentang Anotasi Fungsi. Jangan khawatir jika kamu baru mengenal pemrograman – saya akan memandu kamu melalui konsep ini langkah demi langkah, seperti yang saya lakukan untuk banyak siswa selama tahun-tahun mengajar saya. Jadi, ambil minuman kesukaan kamu, rasakan kenyamananmu, dan mari kita mulai petualangan Python ini bersama!

Apa itu Anotasi Fungsi?

Anotasi fungsi adalah fitur di Python yang memungkinkan kita untuk menambahkan metadata ke parameter fungsi dan nilai kembalian. Pahami mereka sebagai catatan kecil yang kita lekatkan ke fungsi kita untuk memberikan informasi ekstra. Mereka tidak mempengaruhi bagaimana fungsi bekerja, tetapi bisa sangat membantu untuk dokumentasi dan pemeriksaan jenis.

Ayo kita mulai dengan contoh sederhana:

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

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

Mengapa Menggunakan Anotasi Fungsi?

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

Sekarang, mari kita telusuri lebih jauh jenis anotasi berbeda!

Anotasi Fungsi dengan Parameter

Kita dapat menganotasi 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.

Coba kita gunakan itu:

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

Output:

Luas adalah: 17.6

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

Anotasi Fungsi dengan Tipe Kembalian

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

def dapatkan_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 = dapatkan_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 dictionary.

Anotasi Fungsi dengan Ekspresi

Anotasi tidak harus hanya tipe sederhana – mereka juga dapat berupa ekspresi yang 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 daftar di mana setiap item dapat berupa integer atau string.

Anotasi Fungsi dengan Argumen Default

Kita dapat menggabungkan anotasi dengan argumen default. Ini bagaimana:

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

print(ucapan_pengguna())
print(ucapan_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, defaultnya adalah "Tamu".

Menggabungkan Semua itu

Sekarang, mari lihat contoh yang lebih kompleks yang menggabungkan beberapa 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['amount']
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", "amount": 10.99},
{"item": "Widget B", "amount": 5.99},
{"item": "Widget C", "amount": 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 ringkasan berbagai cara kita dapat menggunakan anotasi fungsi:

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

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

Dan itu semua, para siswa yang tercinta! Kita telah berpetualang melalui wilayah Anotasi Fungsi Python. Saya harap panduan ini telah mengiluminasikan konsep ini untuk kamu. Ingat, cara terbaik untuk belajar adalah dengan melakukan, jadi jangan sungkan untuk eksperimen dengan anotasi ini di kode kamu sendiri. Selamat coding, dan semoga fungsi kamu selalu di-anotasi dengan baik!

Credits: Image by storyset