Dekoratör Nedir? Bir Fonksiyonu Saran Başka Bir Fonksiyon
Bu kavram başta karmaşık görünebilir ancak işleyişi oldukça nettir. Dekoratörler, temel olarak bir fonksiyonu alıp onu değiştiren veya genişleten yeni bir fonksiyon döndüren yapılardır. Döndürülen bu yeni fonksiyon genellikle orijinal işlevi çağırır ve bu çağrının önüne veya arkasına ek işlemler yerleştirir.
İşte en yalın örnek:
Python:
def shout(func):
def wrapper():
result = func()
return result.upper()
return wrapper
def greet():
return "hello"
greet = shout(greet)
print(greet())
Burada
shout bir dekoratördür. Parametre olarak bir fonksiyon (greet) alır, onun içinde orijinali çağıran ve dönen sonucu büyük harfe çeviren bir wrapper fonksiyonu tanımlar ve bunu geri döndürür. greet = shout(greet) ifadesi, orijinal fonksiyonu artık bu "sarılmış" yeni versiyonla değiştirmiş olur.Bu yeniden atama yöntemi Python'da çok yaygın kullanıldığı için, dilin kendi özel söz dizimi mevcuttur.
@ Söz Dizimi ve Yeniden Atama KolaylığıBir
def satırının hemen üzerine yazılan @name ifadesi, fonksiyon tanımlandıktan sonra gerçekleşen name = name(...) atamasıyla tamamen aynı işi görür:
Python:
def shout(func):
def wrapper():
return func().upper()
return wrapper
@shout
def greet():
return "hello"
print(greet())
@shout ifadesini, "bu fonksiyona shout dekoratörünü uygula" şeklinde okuyabilirsiniz. Kodu çalıştırdığınızda, Python def bloğunun hemen ardından ilgili dekoratör atamasını otomatik olarak gerçekleştirir; bu da daha sade ve okunabilir bir yazım sağlar.Kod içinde
@name gördüğünüz her yerde zihninizde bunun function = name(function) anlamına geldiğini düşünebilirsiniz.Argümanlarla Çalışmak
Fonksiyonlar genellikle parametre alır. Bu yüzden dekoratörlerin de bu parametreleri desteklemesi gerekir. Burada
*args ve **kwargs yapısını kullanırız. Sarmalayıcı fonksiyonun (wrapper), içindeki asıl fonksiyonun hangi argümanları beklediğini bilmesine gerek yoktur; her türlü argümanı kabul edip aktarması yeterlidir:
Python:
def shout(func):
def wrapper(*args, **kwargs):
result = func(*args, **kwargs)
return result.upper()
return wrapper
@shout
def greet(name, punctuation="!"):
return f"hello, {name}{punctuation}"
print(greet("rosa"))
print(greet("boris", punctuation="."))
*args tüm konumsal, **kwargs ise tüm anahtar kelimeli argümanları yakalar. Sarmalayıcı, bu argümanları olduğu gibi orijinal fonksiyona iletir ve ardından dekoratörün asıl amacı olan ek işlemleri (burada büyük harfe çevirme gibi) gerçekleştirir.Gerçek dünyadaki çoğu dekoratör bu yapıyı temel alır.
Pratik Örnek: Çalışma Süresini Ölçme
Bir fonksiyonun ne kadar sürede tamamlandığını görmek için şöyle bir yapı kurabilirsiniz:
Python:
import time
def timed(func):
def wrapper(*args, **kwargs):
start = time.perf_counter()
result = func(*args, **kwargs)
elapsed = time.perf_counter() - start
print(f"{func.__name__} took {elapsed*1000:.2f} ms")
return result
return wrapper
@timed
def slow_sum(n):
total = 0
for i in range(n):
total += i
return total
print(slow_sum(1_000_000))
print(slow_sum(5_000_000))
Buradaki temel mantık; fonksiyon çağrılmadan önce bir işlem yap, çağrıldıktan sonra başka bir işlem yap şeklindedir. Günlük tutma (logging), yetki kontrolleri, hata durumunda tekrar deneme veya girdi doğrulaması gibi işlemler hep bu aynı şablonu takip eder.
Orijinal Metadata'yı Korumak:
functools.wrapsBir fonksiyonu dekore etmek, onun bazı kimlik bilgilerini değiştirebilir. Sarılan fonksiyon orijinal
__name__ ve __doc__ gibi değerlerini kaybedebilir:
Python:
def shout(func):
def wrapper(*args, **kwargs):
return func(*args, **kwargs).upper()
return wrapper
@shout
def greet(name):
"""Kişiselleştirilmiş bir selamlama döndürür."""
return f"hello, {name}"
print(greet.__name__)
print(greet.__doc__)
Bu durumda
greet.__name__ artık "wrapper" olarak görünür ve docstring (belge metni) kaybolur. Bu da help() komutunun veya hata ayıklama araçlarının doğru çalışmasını engeller.Çözümü çok basittir: İçteki fonksiyona
@functools.wraps(func) dekoratörünü ekleyerek orijinal metadata'nın korunmasını sağlayabilirsiniz.
Python:
from functools import wraps
def shout(func):
@wraps(func)
def wrapper(*args, **kwargs):
return func(*args, **kwargs).upper()
return wrapper
@shout
def greet(name):
"""Kişiselleştirilmiş bir selamlama döndürür."""
return f"hello, {name}"
print(greet.__name__)
print(greet.__doc__)
Bu kullanımı standart bir alışkanlık haline getirmelisiniz. Ek bir maliyeti yoktur ve sizi gelecekteki karmaşık hata ayıklama süreçlerinden kurtarır.
Parametre Alan Dekoratörler
Bazen dekoratörün kendisine "bu fonksiyonu 3 kez tekrarla" veya "DEBUG modunda çalıştır" gibi ayarlar vermek istersiniz. Bu durumda bir katman daha iç içe geçmiş bir yapı kurmanız gerekir: dış fonksiyon argümanı alır ve bir dekoratör döndürür.
Python:
from functools import wraps
def repeat(times):
def decorator(func):
@wraps(func)
def wrapper(*args, **kwargs):
for _ in range(times):
result = func(*args, **kwargs)
return result
return wrapper
return decorator
@repeat(times=3)
def say_hi(name):
print(f"Hi, {name}")
say_hi("Rosa")
Üç katmanlı bu yapıyı şu şekilde okuyabilirsiniz:
1.
repeat(times=3) çağrısı decorator kısmını döndürür.2.
decorator, gerçek dekoratör işlevini görerek fonksiyonu alır ve sarmalar.3.
wrapper ise fonksiyon çalıştırıldığında devreye giren asıl kısımdır.Bu yapı,
@retry(times=5) veya @app.route("/users") gibi popüler kütüphanelerin temelini oluşturur.Dekoratörleri Birleştirmek
Bir fonksiyona birden fazla dekoratör ekleyebilirsiniz. Bu işlem alttan üste doğru gerçekleşir;
def satırına en yakın olan dekoratör ilk çalışandır:
Python:
from functools import wraps
def add_exclaim(func):
@wraps(func)
def wrapper(*args, **kwargs):
return func(*args, **kwargs) + "!"
return wrapper
def shout(func):
@wraps(func)
def wrapper(*args, **kwargs):
return func(*args, **kwargs).upper()
return wrapper
@shout
@add_exclaim
def greet(name):
return f"hi, {name}"
print(greet("rosa"))
add_exclaim önce sarıp ünlem ekler, ardından shout dekoratörü bunu büyük harfe çevirir. Sıralama önemlidir; ters çevrildiğinde çıktı farklı olabilir. Özellikle JSON biçimlendirme veya günlük tutma gibi işlemlerde dekoratörlerin hangi sırada çalıştığı, sonucun niteliğini doğrudan değiştirir.Dahili Python Dekoratörleri
Python ile birlikte gelen ve sıklıkla karşılaşacağınız bazı temel dekoratörler şunlardır:
Python:
from functools import lru_cache
class Circle:
def __init__(self, radius):
self.radius = radius
@property
def area(self):
return 3.14159 * self.radius ** 2
@staticmethod
def unit_circle_area():
return 3.14159
@classmethod
def from_diameter(cls, diameter):
return cls(diameter / 2)
@lru_cache(maxsize=128)
def fib(n):
if n < 2:
return n
return fib(n - 1) + fib(n - 2)
c = Circle(5)
print(c.area)
print(Circle.unit_circle_area())
print(Circle.from_diameter(10).radius)
print(fib(50))
•
@property, bir metodu sanki bir değişkenmiş (nitelik) gibi kullanmanızı sağlar.•
@staticmethod, self veya cls gerektirmeyen metotlar için kullanılır.•
@classmethod, metodu örnek yerine sınıf bazlı çalışacak şekilde tanımlar; genellikle alternatif kurucular için kullanılır.•
@functools.lru_cache, fonksiyon sonuçlarını hafızaya alarak aynı argümanlarla yapılan çağrıları hızlandırır.Dekoratör Kullanımı Hakkında Tavsiyeler
Aynı işi yapan birçok fonksiyonunuz varsa (zamanlama, yetkilendirme, hata ayıklama gibi), dekoratörler kodu tekrar etmekten kurtarır. Ancak her durumda kullanılmamalıdır:
• Eğer bir davranış sadece tek bir fonksiyona özelse, dekoratör yazmak yerine doğrudan fonksiyonun içine eklemek daha basittir.
• Sadece test aşamasında ihtiyaç duyduğunuz bir durumsa, daha açık olan fixture veya parametre yöntemlerini tercih edin.
• Üst üste çok fazla dekoratör kullanmaktan kaçının. Bu durum, kodun okunabilirliğini düşürür ve birinin ne işe yaradığını anlamak için tüm katmanları tek tek incelemeniz gerekir.
Dekoratörler, doğru kullanıldığında kodu temiz ve hedefe yönelik tutan çok güçlü bir araçtır. Ancak karmaşıklığı artırmamaya dikkat etmelisiniz.
Sırada: Tip İpuçları
Dekoratörler, Python'daki tip ipuçları (type hints) ile birlikte oldukça sık kullanılır. Bir sonraki adımda,
wrapper fonksiyonlarının imzalarını nasıl belirtebileceğinizi ve tip ipuçlarının projelerinize nasıl hız kazandıracağını inceleyeceğiz.