Decorator #

Pengertian #

Dekorator di Python adalah fungsi yang memungkinkan Anda untuk menambahkan atau memodifikasi fungsionalitas dari fungsi atau metode lain tanpa mengubah kodenya. Dekorator sering digunakan untuk logging, otorisasi, pengaturan waktu eksekusi, dan tujuan lainnya di mana Anda ingin menambah perilaku pada fungsi yang sudah ada.

Cara Kerja #

Dekorator adalah fungsi yang menerima fungsi lain sebagai argumen dan mengembalikan fungsi baru yang memiliki beberapa tambahan atau modifikasi. Dekorator biasanya didefinisikan dengan menggunakan simbol @ diikuti oleh nama dekorator sebelum definisi fungsi yang ingin dihias.

Contoh Sederhana #

Berikut adalah contoh sederhana dari dekorator yang mencetak pesan sebelum dan sesudah menjalankan fungsi yang dihias:

def my_decorator(func):
    def wrapper():
        print("Sebelum menjalankan fungsi")
        func()
        print("Setelah menjalankan fungsi")
    return wrapper

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

say_hello()

Output:

Sebelum menjalankan fungsi
Hello, world!
Setelah menjalankan fungsi

Dalam contoh di atas:

• my_decorator adalah dekorator yang menerima fungsi func sebagai argumen.
• wrapper adalah fungsi dalam yang membungkus fungsi func dengan tambahan fungsionalitas (mencetak pesan sebelum dan sesudah menjalankan func).
• @my_decorator digunakan untuk menghias fungsi say_hello, sehingga ketika say_hello dipanggil, fungsi wrapper yang dipanggil.

Argumen #

Dekorator juga dapat menerima argumen. Untuk melakukan ini, Anda membuat fungsi yang mengembalikan dekorator.

def repeat(num_times):
    def decorator(func):
        def wrapper(*args, **kwargs):
            for _ in range(num_times):
                func(*args, **kwargs)
        return wrapper
    return decorator

@repeat(num_times=3)
def say_hello(name):
    print(f"Hello, {name}!")

say_hello("Alice")

Output:

Hello, Alice!
Hello, Alice!
Hello, Alice!

Dalam contoh di atas:

• repeat adalah fungsi yang menerima argumen num_times dan mengembalikan dekorator.
• decorator adalah dekorator yang menerima fungsi func sebagai argumen.
• wrapper adalah fungsi dalam yang membungkus func dan menjalankannya num_times kali.
• @repeat(num_times=3) digunakan untuk menghias fungsi say_hello.

Metode Kelas #

Dekorator juga dapat digunakan untuk metode kelas. Contoh berikut menunjukkan dekorator yang menghias metode dalam kelas:

def log_method_call(func):
    def wrapper(self, *args, **kwargs):
        print(f"Memanggil metode {func.__name__}")
        return func(self, *args, **kwargs)
    return wrapper

class MyClass:
    @log_method_call
    def say_hello(self):
        print("Hello from MyClass!")

obj = MyClass()
obj.say_hello()

Output:

Memanggil metode say_hello
Hello from MyClass!

Dalam contoh di atas:

• log_method_call adalah dekorator yang mencetak pesan sebelum menjalankan metode yang dihias.
• @log_method_call digunakan untuk menghias metode say_hello dalam kelas MyClass.

Built-in Decorator #

Python memiliki beberapa dekorator built-in seperti @staticmethod, @classmethod, dan @property.

• @staticmethod dan @classmethod digunakan untuk mendefinisikan metode statis dan metode kelas dalam kelas.

  class MyClass:
      @staticmethod
      def static_method():
          print("Ini metode statis.")
  
      @classmethod
      def class_method(cls):
          print(f"Ini metode kelas dari {cls}.")
  
  MyClass.static_method()
  MyClass.class_method()
  

• @property digunakan untuk mendefinisikan properti yang dapat diakses seperti atribut tetapi memiliki metode getter dan setter.

  class Person:
      def __init__(self, name):
          self._name = name
  
      @property
      def name(self):
          return self._name
  
      @name.setter
      def name(self, value):
          if not value:
              raise ValueError("Nama tidak boleh kosong")
          self._name = value
  
  person = Person("Alice")
  print(person.name)  # Output: Alice
  person.name = "Bob"
  print(person.name)  # Output: Bob
  

Kesimpulan #

Dengan dekorator, Anda bisa menambah fungsionalitas tambahan ke fungsi atau metode tanpa mengubah kodenya secara langsung, yang membuat kode Anda lebih modular dan mudah untuk dikelola.