Property dan Decorator di Python

Property dan decorator adalah fitur powerful di Python yang membuat kode lebih elegan, aman, dan mudah dirawat, terutama dalam paradigma Object-Oriented Programming (OOP). Namun, banyak pemula yang masih bingung kapan dan bagaimana menggunakan property serta decorator dengan benar. Artikel ini akan membahas secara mendalam konsep, manfaat, contoh, studi kasus, best practice, hingga tips lanjutan agar kamu benar-benar paham dan bisa mengaplikasikannya di proyek Python-mu.

Pengantar: Kenapa Property dan Decorator Penting?

Dalam OOP, kita ingin menjaga data tetap aman dan hanya bisa diakses/diubah dengan cara tertentu. Di sisi lain, kita juga ingin menambah fitur ke fungsi/method tanpa mengubah kode aslinya. Di sinilah property dan decorator berperan besar.

• Property: Membantu mengontrol akses ke atribut (getter, setter, deleter) tanpa mengubah cara aksesnya dari luar class.
• Decorator: Memungkinkan kita menambah/memodifikasi perilaku fungsi atau method secara dinamis, tanpa mengubah kode aslinya.

Apa Itu Property?

Property adalah fitur Python yang memungkinkan method diakses seperti atribut. Dengan property, kamu bisa membuat getter, setter, dan deleter untuk atribut tertentu, sehingga akses data lebih terkontrol dan aman.

Kenapa Perlu Property?

• Melindungi data dari perubahan langsung yang tidak diinginkan.
• Menyisipkan logika validasi saat membaca/menulis atribut.
• Menjaga interface class tetap sederhana (akses seperti atribut biasa).

Contoh Sederhana Property

class Persegi:
    def __init__(self, sisi):
        self._sisi = sisi

    @property
    def sisi(self):
        return self._sisi

    @sisi.setter
    def sisi(self, nilai):
        if nilai > 0:
            self._sisi = nilai
        else:
            print("Sisi harus > 0")

p = Persegi(4)
print(p.sisi)
p.sisi = 10
print(p.sisi)
p.sisi = -5

4
10
Sisi harus > 0

Penjelasan:

• _sisi adalah atribut “private” (konvensi: awali dengan _).
• @property membuat method sisi() bisa diakses seperti atribut.
• @sisi.setter mengatur logika saat atribut diubah.
• Jika nilai sisi negatif, setter menolak perubahan.

Property dengan Getter, Setter, dan Deleter

Property bisa punya tiga bagian: getter, setter, dan deleter.

class Mahasiswa:
    def __init__(self, nama):
        self._nama = nama

    @property
    def nama(self):
        return self._nama

    @nama.setter
    def nama(self, value):
        if value:
            self._nama = value
        else:
            print("Nama tidak boleh kosong.")

    @nama.deleter
    def nama(self):
        print("Nama dihapus!")
        self._nama = None

m = Mahasiswa("Budi")
print(m.nama)
m.nama = ""
del m.nama
print(m.nama)

Budi
Nama tidak boleh kosong.
Nama dihapus!
None

Studi Kasus: Property untuk Validasi dan Perhitungan Otomatis

Misal, kamu ingin membuat class Lingkaran yang otomatis menghitung luas saat jari-jari diubah.

import math

class Lingkaran:
    def __init__(self, jari_jari):
        self._jari_jari = jari_jari

    @property
    def jari_jari(self):
        return self._jari_jari

    @jari_jari.setter
    def jari_jari(self, nilai):
        if nilai > 0:
            self._jari_jari = nilai
        else:
            raise ValueError("Jari-jari harus > 0")

    @property
    def luas(self):
        return math.pi * self._jari_jari ** 2

l = Lingkaran(7)
print(l.luas)
l.jari_jari = 14
print(l.luas)

153.93804002589985
615.7521601035994

Penjelasan:

• Property luas otomatis berubah jika jari_jari diubah.
• Tidak perlu setter untuk luas karena nilainya dihitung otomatis.

Best Practice Property

Apa Itu Decorator?

Decorator adalah fungsi yang digunakan untuk memodifikasi fungsi/method lain tanpa mengubah kode aslinya. Decorator sering digunakan untuk logging, validasi, otorisasi, caching, dan lain-lain.

Kenapa Perlu Decorator?

• Menambah fitur ke fungsi/method tanpa mengubah kode aslinya.
• Memisahkan logika tambahan dari logika utama.
• Membuat kode lebih modular dan reusable.

Contoh Decorator Sederhana

def cetak_nama(func):
    def wrapper(*args, **kwargs):
        print("Memanggil fungsi...")
        return func(*args, **kwargs)
    return wrapper

@cetak_nama
def sapa():
    print("Halo, Pythonista!")

sapa()

Memanggil fungsi...
Halo, Pythonista!

Penjelasan:

• @cetak_nama adalah decorator yang membungkus fungsi sapa.
• Fungsi asli tetap bisa dipanggil, tapi ada tambahan proses sebelum/atau sesudahnya.

Decorator dengan Parameter

Decorator juga bisa menerima parameter, misal untuk logging level.

def log(level):
    def decorator(func):
        def wrapper(*args, **kwargs):
            print(f"[{level}] Memanggil {func.__name__}")
            return func(*args, **kwargs)
        return wrapper
    return decorator

@log("INFO")
def proses():
    print("Proses berjalan...")

proses()

[INFO] Memanggil proses
Proses berjalan...

Decorator pada Method Class

Decorator juga bisa digunakan pada method di dalam class, misal untuk validasi akses.

def admin_only(func):
    def wrapper(self, *args, **kwargs):
        if getattr(self, "is_admin", False):
            return func(self, *args, **kwargs)
        else:
            print("Akses ditolak. Hanya admin!")
    return wrapper

class User:
    def __init__(self, nama, is_admin=False):
        self.nama = nama
        self.is_admin = is_admin

    @admin_only
    def hapus_data(self):
        print(f"{self.nama} menghapus data.")

u1 = User("Budi", is_admin=True)
u2 = User("Ani", is_admin=False)
u1.hapus_data()
u2.hapus_data()

Budi menghapus data.
Akses ditolak. Hanya admin!

Studi Kasus: Decorator untuk Logging dan Timing

Decorator sangat berguna untuk logging dan mengukur waktu eksekusi fungsi.

import time

def timing(func):
    def wrapper(*args, **kwargs):
        start = time.time()
        hasil = func(*args, **kwargs)
        end = time.time()
        print(f"Eksekusi {func.__name__} selesai dalam {end-start:.4f} detik")
        return hasil
    return wrapper

@timing
def hitung():
    total = 0
    for i in range(1000000):
        total += i
    return total

hitung()

Eksekusi hitung selesai dalam ... detik

Decorator Bawaan Python

Python menyediakan beberapa decorator built-in, misal:

• @staticmethod
• @classmethod
• @property

Decorator ini sudah sering kamu jumpai di OOP Python.

Membuat Decorator yang Menjaga Metadata Fungsi

Gunakan functools.wraps agar nama dan docstring fungsi asli tetap terjaga.

from functools import wraps

def log(func):
    @wraps(func)
    def wrapper(*args, **kwargs):
        print(f"Memanggil {func.__name__}")
        return func(*args, **kwargs)
    return wrapper

@log
def halo():
    """Fungsi menyapa user."""
    print("Halo!")

print(halo.__name__)
print(halo.__doc__)

Memanggil halo
Halo!
halo
Fungsi menyapa user.

Perbandingan: Property vs Decorator

Best Practice dan Tips

FAQ Seputar Property dan Decorator

Q: Apakah property bisa digunakan di luar class?
A: Tidak, property hanya untuk class.

Q: Bisakah satu fungsi punya banyak decorator?
A: Bisa, urutan eksekusi dari atas ke bawah.

Q: Apa beda property dan method biasa?
A: Property diakses seperti atribut, method biasa harus pakai tanda kurung.

Q: Apakah decorator bisa dipakai di property?
A: Bisa, misal untuk validasi sebelum setter dijalankan.

Q: Bagaimana cara membuat decorator yang menerima parameter?
A: Gunakan fungsi pembungkus (lihat contoh decorator dengan parameter di atas).

Studi Kasus Lanjutan: Property dan Decorator di Proyek Nyata

Misal, kamu membuat aplikasi keuangan dengan class RekeningBank yang butuh validasi saldo dan logging setiap transaksi.

from functools import wraps

def log_transaksi(func):
    @wraps(func)
    def wrapper(self, *args, **kwargs):
        print(f"Transaksi: {func.__name__} untuk {self.nama}")
        return func(self, *args, **kwargs)
    return wrapper

class RekeningBank:
    def __init__(self, nama, saldo):
        self.nama = nama
        self._saldo = saldo

    @property
    def saldo(self):
        return self._saldo

    @saldo.setter
    def saldo(self, nilai):
        if nilai >= 0:
            self._saldo = nilai
        else:
            print("Saldo tidak boleh negatif!")

    @log_transaksi
    def setor(self, jumlah):
        self.saldo += jumlah

    @log_transaksi
    def tarik(self, jumlah):
        if jumlah <= self.saldo:
            self.saldo -= jumlah
        else:
            print("Saldo tidak cukup!")

r = RekeningBank("Budi", 1000)
r.setor(500)
r.tarik(2000)
print(r.saldo)

Transaksi: setor untuk Budi
Transaksi: tarik untuk Budi
Saldo tidak cukup!
1500

Kesimpulan

Property dan decorator adalah fitur penting di Python yang membuat kode lebih aman, modular, dan mudah dikembangkan. Dengan property, kamu bisa mengontrol akses data di class tanpa mengubah cara akses dari luar. Dengan decorator, kamu bisa menambah fitur ke fungsi/method tanpa mengubah kode aslinya.

Teruslah berlatih membuat property dan decorator di berbagai kasus nyata, agar semakin mahir dan siap membangun aplikasi Python yang profesional!

Happy coding!