Python Function Annotations: Fitur Keren yang Sering Diremehkan, Padahal Bikin Kamu Terlihat Programmer Cerdas

Python Function Annotations: Fitur Keren yang Sering Diremehkan, Padahal Bikin Kamu Terlihat Programmer Cerdas

Kalau kamu ngoding Python cukup lama, mungkin kamu sudah pernah lihat orang nulis parameter fungsi pakai format aneh begini:

def myfunc(a: int, b: str) -> bool:
    ...

Lalu kamu bertanya:
 “Ini apaan? Beneran Python? Kok mirip-mirip Java tapi versi chill?”

Selamat, kamu baru nyenggol fitur bernama function annotations, salah satu fitur Python yang kayak anak tengah: ada, penting, tapi sering diabaikan karena nggak bikin error sekalipun kamu salah pakai. Namun justru karena fleksibel inilah annotations jadi sangat powerful, terutama di dunia modern yang penuh linter, type checker, dan IDE pintar.

Hari ini kita akan bahas ini dengan gaya santai, tapi tetap memetakan apa yang sebenarnya penting.

Apa Itu Function Annotations?

Function annotations adalah cara untuk menambahkan metadata ke parameter fungsi dan ke nilai return-nya.

Kata kuncinya: metadata, bukan aturan keras.
Python tuh sopan, dia cuma bilang:

“Oke bro, kamu bilang parameternya int. Noted. Tapi kalau nanti kamu masukin string, ya udah… jalan terus.”

Makanya annotations tidak berpengaruh pada eksekusi program. Python tidak marah, tidak ngambek, tidak ceramah.

Annotations lebih diperuntukkan untuk:

• IDE (VSCode, PyCharm)
• dokumentasi otomatis
• static type checker (mypy, pyright)
• programmer lain biar nggak salah paham tentang “fungsi ini maunya apa sih?”

Sebagai catatan sejarah, fitur ini masuk lewat PEP 3107, agar dokumentasi fungsi bisa nempel di definisinya, tidak hanya lewat docstring.

Baca Juga

• Automatisasi Laporan PDF Dengan Python
• Automatisasi Tugas GUI Dengan PyAutoGUI

 

Contoh Dasar Anotasi: Menandai Tipe Parameter

Mari lihat contoh klasik:

def myfunction(a: int, b: int):
   c = a+b
   return c

  
print (myfunction(10,20))
print (myfunction("Hello ", "Python"))

Output:

30
Hello Python

Kamu lihat yang terjadi?
Kamu bilang a:int dan b:int… tapi Python masih dengan santainya menerima string. Tidak ada error. Dua string dijumlahkan? Ya sudah, tinggal digabung.

Inilah bukti Python itu bukan bahasa yang bossy. Dia cuma bilang “baik, saya catat tujuanmu”, tapi eksekusi tetap fleksibel.

 

Annotations Bukan Type Enforcement — Ini Bukan Java

Banyak pemula menganggap:

“Kalau aku kasih a: int, nanti Python bakal maksa input harus integer, kan?”

Enggak bro.

Python masih dynamically typed.
Annotations itu cuma “catatan pinggir”.

Kalau kamu mau Python benar-benar mengecek tipe, kamu butuh:

• mypy
• pydantic
• typeguard
• beartype

—but that’s another story.

 

Menggunakan Anotasi di Return Type

Selain anotasi parameter, kamu juga bisa memberi anotasi pada nilai balik fungsi.

Sintaksnya:

• (parameter) -> return_annotation :

Contoh:

def myfunction(a: int, b: int) -> int:
   c = a+b
   return c
print(myfunction(56,88))
print(myfunction.__annotations__)

Output:

144
{'a': <class 'int'>, 'b': <class 'int'>, 'return': <class 'int'>}

Nah, di sini kita mulai lihat gunanya annotations.
Kamu bisa akses metadata-nya via . __annotations__, sebuah dictionary yang otomatis dibuat Python.

Ini bukan hanya untuk gaya-gayaan.
Static type checker bisa baca metadata ini, IDE bisa kasih color coding, developer lain bisa paham maksud fungsi tanpa baca tulisan panjang.

 

Annotations Tidak Harus Berisi Tipe — Bisa Apa Saja!

Python itu liberal banget: anotasi boleh berupa tipe, string, atau ekspresi Python apa pun.

Contoh:

def total(x : 'marks in Physics', y: 'marks in chemistry'):
   return x+y
print(total(86, 88))
print(total.__annotations__)

Output:

174
{'x': 'marks in Physics', 'y': 'marks in chemistry'}

Dari sini kita belajar:

• anotasi bisa jadi string biasa
• anotasi bisa dipakai untuk dokumentasi
• Python tidak peduli, tetap menjalankan kode

Annotation seperti ini bisa digunakan oleh:

• generator dokumentasi
• framework belajar
• sistem API automatic documentation
• tools internal perusahaan

Kamu bebas pakai anotasi untuk hal kreatif seperti:

• menandai parameter yang “harus berupa id user”
• memberi batasan bisnis
• menulis pesan lucu di metadata (serius, ini valid)

 

Annotation + Default Argument = Tetap Aman

Kamu juga bisa mencampur anotasi dengan default argument:

def myfunction(a: "physics", b:"Maths" = 20) -> int:
   c = a+b
   return c


print (myfunction(10))

Default argument ditulis setelah anotasi.
Aturan Python tetap sama: default harus diletakkan setelah parameter wajib.

Nggak ada drama, semuanya jalan mulus.

 

Function Adalah Objek — dan Anotasinya Bisa Diinspeksi

Python itu bergaya object-oriented tapi tanpa ribet.
Fungsi pun dianggap objek, dan salah satu atributnya adalah __annotations__.

Kamu bisa melihat apa saja atribut objek fungsi dengan:

print(dir(myfunction))

Output-nya panjang, tapi sebagian yang penting:

'__annotations__', '__defaults__', '__doc__', '__name__', '__qualname__', ...

__annotations__ adalah dictionary yang berisi semua anotasi parameter + return value.

 

Kenapa Function Annotations Penting di Dunia Modern?

(Ini bagian pendalaman, gaya agak bad boy—tenang, tetap informatif)

1. Karena coding sekarang bukan kerja sendirian

Di zaman Python 2, banyak orang masih coding ala ninja: cepat, fleksibel, tapi berantakan.
Di Python modern?
Project besar → banyak programmer → anotasi jadi penyelamat.

Annotations membuat kode lebih:

• mudah dipahami
• mudah didokumentasikan
• mudah dicek otomatis

Tanpa harus menulis docstring panjang yang sering kedaluwarsa.

 

2. IDE jadi jauh lebih pintar

VSCode, PyCharm, Sublime LSP—semuanya makin “berotak” kalau kamu pakai anotasi.

Manfaatnya:

• auto-complete lebih akurat
• deteksi bug lebih cepat
• refactor lebih aman
• warning masalah tipe langsung muncul

Dalam project besar, fitur ini menyelamatkan berjam-jam debugging yang nggak perlu.

 

3. Static type checking adalah masa depan

Bahkan Guido van Rossum (bapak Python) bilang di masa depan Python akan makin “type-friendly”.

Annotations adalah pondasi dari:

• mypy
• pyright
• pydantic
• FastAPI
• dataclasses
• attrs

Banyak framework modern memanfaatkan metadata anotasi untuk validasi otomatis, schema generator, dan API documentation.

Contoh paling terkenal: FastAPI.
Kalau kamu kasih anotasi, dia:

• generate dokumentasi otomatis
• validasi input
• menolak tipe tidak valid

Tanpa kamu perlu nulis kode ekstra.

 

4. Bikin kode kamu terlihat profesional

Kalau kamu kirim CV dengan contoh kode tanpa anotasi, tampilannya “Python jadul”.
Kalau kamu beri anotasi rapi, semua parameter jelas, return type jelas…
HR dan reviewer code langsung suka.

Annotations adalah estetika + kualitas engineering.

 

5. Mencegah kesalahan manusia yang klasik

Jenis error paling mainstream:

• kirim integer padahal fungsi butuh string
• return list padahal harusnya dict
• parameter salah urutan
• developer baru nggak ngerti alur datanya

Annotations bukan obat, tapi setidaknya memberi tanda besar:

“HEY BRO, PARAMETER INI HARUSNYA ‘INT’ LHO!”

Walaupun Python tetap akan jalan dengan tipe lain, minimal kamu punya rambu peringatan.

 

Filosofi di Balik Annotations: Python Tanpa Kekangan

Python tidak memilih jalan “ketat”, seperti:

• Java
• C#
• Go

Python tetap pada filosofi:

“We’re all adults here.”

Makanya dia tidak memaksa tipe tertentu.
Annotations adalah fitur informasi, bukan aturan.
Kamu boleh nurut, boleh juga bandel. Python nggak marah.

Tapi dunia modern menghargai developer yang rapi, jadi lebih baik tetap pakai anotasi untuk kejelasan.

 

Apakah Function Annotations Wajib?

Tidak wajib, tapi sangat disarankan untuk:

• backend development
• data processing
• machine learning pipeline
• API
• project kolaboratif
• aplikasi skala besar

Untuk script kecil 10–20 baris?
Ya nggak perlu juga.

 

Ringkasan Bad Boy: Apa yang Harus Kamu Ingat?

• Function annotations = metadata, bukan enforce tipe
• Python tidak akan menghalangi kamu mengirim tipe salah
• Annotations berguna banget dengan tools modern
• Bisa dipakai untuk tipe, string, atau ekspresi bebas
• Default argument tetap bisa dipakai
• Metadata bisa diakses lewat __annotations__
• IDE jadi jauh lebih cerdas
• FastAPI, Pydantic, mypy—semua cinta anotasi

 

Penutup

Function Annotations mungkin terlihat kecil dan simpel, tapi efeknya besar untuk ekosistem Python modern.
Dia tidak memaksa, tidak mendikte, tidak mengekang.
Tapi dia membantu kamu, tim kamu, IDE kamu, dan masa depan kode kamu.

Kalau kamu ingin terlihat programmer berkelas, rapi, tidak barbar, dan siap menghadapi proyek besar—belajarlah memakai function annotations sejak sekarang.

Published on December 06, 2025
Last updated on June 03, 2026