Cara Menggunakan Dekorator Python untuk Meningkatkan Fungsi

Dekorator Python merupakan cara yang ampuh dan fleksibel untuk mengubah atau menyempurnakan fungsi dan metode. Dekorator menyediakan cara untuk membungkus suatu fungsi dengan fungsionalitas tambahan, yang memungkinkan Anda untuk memperluas perilakunya tanpa mengubah kode sebenarnya. Artikel ini akan memperkenalkan Anda pada konsep dekorator, cara membuat dan menggunakannya, serta mengeksplorasi beberapa contoh praktis.

Apa itu Dekorator?

Dekorator adalah fungsi yang mengambil fungsi lain dan memperluas perilakunya tanpa mengubahnya secara eksplisit. Dalam Python, dekorator sering digunakan untuk menambahkan fungsionalitas seperti pencatatan, kontrol akses, atau pengukuran kinerja ke fungsi atau metode yang ada. Dekorator diterapkan ke fungsi menggunakan sintaksis @decorator_name.

# Basic example of a decorator
def my_decorator(func):
    def wrapper():
        print("Something is happening before the function is called.")
        func()
        print("Something is happening after the function is called.")
    return wrapper

@my_decorator
def say_hello():
    print("Hello!")

say_hello()

Cara Kerja Dekorator

Saat Anda menerapkan dekorator ke suatu fungsi, Python pada dasarnya melakukan langkah-langkah berikut:

1. Fungsi dekorator dipanggil dengan fungsi asli sebagai argumennya.
2. Fungsi dekorator mendefinisikan fungsi baru (sering disebut wrapper) yang meningkatkan atau memodifikasi perilaku fungsi asli.
3. Fungsi dekorator mengembalikan fungsi baru.
4. Ketika fungsi yang didekorasi dipanggil, fungsi tersebut sebenarnya memanggil fungsi baru yang dikembalikan oleh dekorator.

Membuat Dekorator Sederhana

Mari kita buat dekorator sederhana yang mengukur waktu eksekusi suatu fungsi. Ini berguna untuk pengujian dan pengoptimalan kinerja.

import time

def timing_decorator(func):
    def wrapper(*args, **kwargs):
        start_time = time.time()
        result = func(*args, **kwargs)
        end_time = time.time()
        print(f"Execution time: {end_time - start_time} seconds")
        return result
    return wrapper

@timing_decorator
def slow_function():
    time.sleep(2)
    print("Function finished!")

slow_function()

Menggunakan Dekorator dengan Argumen

Terkadang, Anda mungkin ingin meneruskan argumen ke dekorator Anda. Untuk mencapainya, Anda perlu membuat pabrik dekorator—fungsi yang mengembalikan dekorator. Berikut ini contoh dekorator yang mengambil argumen untuk menentukan pesan khusus.

def custom_message_decorator(message):
    def decorator(func):
        def wrapper(*args, **kwargs):
            print(message)
            return func(*args, **kwargs)
        return wrapper
    return decorator

@custom_message_decorator("Starting the function...")
def greet(name):
    print(f"Hello, {name}!")

greet("Alice")

Dekorator untuk Metode di Kelas

Dekorator juga dapat digunakan dengan metode di dalam kelas. Penggunaan umum meliputi pencatatan panggilan metode, kontrol akses, dan hasil penyimpanan sementara. Berikut ini contoh penggunaan dekorator untuk mencatat panggilan metode di kelas.

def log_method_call(method):
    def wrapper(self, *args, **kwargs):
        print(f"Calling {method.__name__} with arguments {args} and keyword arguments {kwargs}")
        return method(self, *args, **kwargs)
    return wrapper

class MyClass:
    @log_method_call
    def my_method(self, x, y):
        print(f"Result: {x + y}")

obj = MyClass()
obj.my_method(5, 7)

Dekorator Berantai

Anda dapat menerapkan beberapa dekorator ke satu fungsi. Dekorator diterapkan dari dekorator paling dalam ke paling luar. Ini memungkinkan Anda untuk menggabungkan berbagai fungsi secara bersamaan. Berikut ini contoh penggabungan dua dekorator:

def uppercase_decorator(func):
    def wrapper(*args, **kwargs):
        result = func(*args, **kwargs)
        return result.upper()
    return wrapper

def exclamation_decorator(func):
    def wrapper(*args, **kwargs):
        result = func(*args, **kwargs)
        return result + "!"
    return wrapper

@exclamation_decorator
@uppercase_decorator
def greet(name):
    return f"Hello, {name}"

print(greet("Alice"))

Kesimpulan

Dekorator adalah alat serbaguna dalam Python yang memungkinkan Anda untuk meningkatkan atau mengubah perilaku fungsi dan metode. Dengan menggunakan dekorator, Anda dapat menambahkan fungsionalitas yang dapat digunakan kembali di seluruh basis kode Anda tanpa mengubah logika inti fungsi Anda. Baik untuk pencatatan, pengaturan waktu, atau mengubah keluaran, dekorator membantu menjaga kode Anda tetap bersih dan mudah dirawat. Berlatihlah menggunakan dekorator untuk menjadi lebih mahir dan memanfaatkan kekuatannya dalam proyek Python Anda.