Agora Metin2 1
Agora Metin2
berzahx 1
berzahx
Aliyldrim 1
Aliyldrim
-ECD- 1
-ECD-
Reklam vermek için turkmmo@gmail.com

Python Dekoratörleri: @fonksiyonlar, Parametreler ve functools.wraps

  • Konuyu başlatan Konuyu başlatan Agora Metin2
  • Başlangıç tarihi Başlangıç tarihi
  • Cevaplar Cevaplar 0
  • Görüntüleme Görüntüleme 13
image3b57beb29d949ebf.jpg


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.wraps

Bir 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.
 

Şu an konuyu görüntüleyenler (Toplam : 0, Üye: 0, Misafir: 0)

Geri
Üst