Python Kod

  1. Anasayfa
  2. »
  3. Genel
  4. »
  5. Python Decorator Nedir?

Python Decorator Nedir?

admin admin - - 25 dk okuma süresi
166 0

Python dilinde decorator, bir fonksiyonu modifiye eden veya düzenleyen işlevleri ifade eder. Böylece, aynı kod bloklarını tekrar tekrar yazmaktan kaçınarak kodun daha modüler ve daha okunaklı hale gelmesini sağlar. Dekoratörler, kodun tekrar kullanılabilir bloklar oluşturmasına da yardımcı olur. Python’da dahili olarak tanımlanan dekoratörler vardır, bunlar @staticmethod, @classmethod ve @property gibi özellikleri içerir.

Bir fonksiyonu dekore etmek için @ sembolünü kullanırız ve fonksiyondan önce belirtiriz. Bu sayede, dekoratör fonksiyonu etkinleştirilmiş olur ve fonksiyonu modifiye eder. Bu şekilde, mevcut bir fonksiyonu genişletmek veya yeni bir işleve eklemek kolay hale gelir. Bu nedenle, dekoratörler özellikle büyük ve karmaşık projelerde yararlıdır.

Decorator Nedir?

Python’da decorator kavramı, bir fonksiyonu düzenleyerek yeni bir fonksiyon oluşturma işlemidir. Decoratorlar bir fonksiyonu modifiye eden işlevlerdir ve orijinal fonksiyonu değiştirmeden ek özellikler eklemek için kullanılırlar. Bu sayede tekrar kullanılabilir, modüler kodlar oluşturmak mümkün hale gelir. Decoratorların kullanımı, kodu daha okunaklı hale getirip, güncelleme ve bakım işlemlerini kolaylaştırır. Ayrıca decoratorların kullanımı ile kodun görünümü de basitleştirilir.

Decoratorlar, Python’da @ sembolü kullanılan ve orijinal fonksiyondan hemen önce belirtilen özel işaretlerdir. Bu sayede fonksiyonun modifiye edilmesi ve değiştirilmesi mümkün hale gelir. Decoratorlar, birçok işlem için kullanılabilirler. Örneğin; bir fonksiyonun çalışma süresi, ölçülen bir zaman aralığında tekrar tekrar çalıştırılması veya veri türü dönüşümü yapılması gibi durumlar için kullanılabilirler.

Decorator Nasıl Kullanılır?

Python’da bir fonksiyonu dekore etmek için @ sembolü kullanılır ve fonksiyondan önce belirtilir. Bu sembol, fonksiyon çağrısından önce çalıştırılacak bir işlevi gösterir. Böylece, bir fonksiyonu modifiye etmek istediğimizde, yalnızca @ sembolü ve işlevi belirtmemiz yeterlidir.

Örneğin, bir fonksiyonu zamanlayacağımız bir dekoratör yazmak için @ sembol ve işlevin adını belirtiyoruz. Bu sayede, her fonksiyonu ayrı ayrı zamanlamak yerine, dekoratörümüzü kullanarak otomatik olarak zamanlayabiliriz. Birçok farklı dekoratör vardır ve işlemleri farklılaştırır, ama kullanımları hep aynıdır. Bu farklı dekoratör örneklerini ve kullanımlarını ilerleyen makalelerde ele alacağız.

Örnek Kullanım – Fonksiyona Zamanlayıcı Dekoratörü

Bir fonksiyonun ne kadar sürede çalıştığını ölçmek için zamanlayıcı dekoratörü kullanılabilir. Bu dekoratör, fonksiyonun çalışmaya başlamasından bitişine kadar geçen süreyi hesaplar ve ekrana yazdırır. İşte bir örnek:

@zamanlayicidef bir_fonksiyon():    time.sleep(2)

Bu örnekte, zamanlayıcı dekoratörü kullanılarak bir fonksiyonun çalışma süresi ölçülüyor. @zamanlayici, fonksiyondan önce kullanılarak, fonksiyona dekorasyon ekleniyor. İşlev çalıştığında, fonksiyondan önce eklenen dekoratör sayesinde süre hesaplanır ve ekrana yazdırılır.

Zamanlayıcı dekoratörü öncesinde kod yazmak, zamanlamayı manuel olarak hesaplamayı gerektiren zaman alıcı bir işlemdir. Bu yüzden, zamanlayıcı dekoratörü birçok durumda zaman ve emek tasarrufu sağlar. Ayrıca, ölçümler doğru ve tutarlıdır.

Zamanlayıcı Dekoratörü Kod Örneği

Zamanlayıcı Dekoratörü Kod Örneği

Decorator’lar ile ilgili kodlama örnekleri verirken, zamanlayıcı dekoratörü örneği oldukça sık rastlanan bir kullanımdır. İşlevlerin ne kadar sürede çalıştığını ölçmek ve fonksiyonların performansını değerlendirmek için kullanılır.

Bir zamanlayıcı dekoratörü tanımlamak için, bir fonksiyon yazmak gerekir. ‘def zamanlayici(fonksiyon):’ şeklinde başlar ve fonksiyon adının bunu takip etmesi gerekir. Bu sayede, tanımlı fonksiyonlar zamanlayıcı dekoratörü tarafından kullanılabilir hale gelir.

Zamanlayıcı dekoratörü kod örneği aşağıdaki gibi olabilir:

Kod Satırı Açıklama
def zamanlayici(fonksiyon): Zamanlayıcı dekoratörü fonksiyonu tanımlar.
def wrapper(*args, **kwargs): Zamanlayıcı fonksiyonu ile birlikte kullanılacak olan bir sarmalayıcı (wrapper) fonksiyonu tanımlar.
basla = time.time() Fonksiyon için başlama zamanı ayarlanır.
sonuc = fonksiyon(*args, **kwargs) Fonksiyon çağırılır ve sonuç döndürülür.
sure = time.time() – basla Zaman aralığı hesaplanır.
print({fonksiyon.__name__} fonksiyonu {sure} saniyede çalıştı.) Fonksiyonun adı ve çalışma süresi ekrana yazdırılır.
return sonuc Fonksiyonun sonucu döndürülür.

Yukarıdaki kodda yer alan *args ve **kwargs argümanları, fonksiyona girilecek olan değişken sayısının önceden bilinmediği durumlarda kullanılır. Bu sayede, fonksiyonun sadece gerekli olan argümanlarını göndermek yeterlidir.

def wrapper(*args, **kwargs):

def wrapper(*args, **kwargs): Bu kod satırı, decorator fonksiyonlarında kullanılan wrapper fonksiyonunu tanımlar. Wrapper fonksiyonu, dekore edilen fonksiyonu saran bir arayüz görevi görür. *args ve **kwargs, tanımlanmamış sayıda parametrelerin fonksiyona geçirilebilmesini sağlar. Örneğin, farklı sayıda argümanları olan fonksiyonlar dekore edilebilir. Bu özellik, decorator’ların kullanımını daha esnek hale getirir.

basla

Bir Python decoratoru, bir fonksiyonu modifiye eden veya düzenleyen işlevlerdir. Decoratorlar, kod okunabilirliğini artırır, tekrar kullanılabilir kod blokları yaratır ve kodun daha modüler hale gelmesini sağlar. Decoratorlar, @ sembolü kullanılarak fonksiyondan önce belirtilir. Örneğin, bir zamanlayıcı dekoratörü, fonksiyon çalışma süresini hesaplayarak bir fonksiyonun çalışma süresini otomatik olarak hesaplayabilir.

Bir zamanlayıcı dekoratörü örneği için, basla = time.time() satırı kullanılabilir. Bu satır, bir fonksiyonun çalışma süresini başlatmak için kullanılır. Ardından, fonksiyonun çalışması tamamlandığında sürenin hesaplanması için sure = time.time() – basla satırı kullanılır. Son olarak, hesaplanan zamanın ekrana yazdırılması için bir print() fonksiyonu kullanılır.

Kod Örneği
def zamanlayici(fonksiyon):    def wrapper(*args, **kwargs):        basla = time.time()        sonuc = fonksiyon(*args, **kwargs)        sure = time.time() - basla        print(f"{fonksiyon.__name__} fonksiyonu {sure} saniyede çalıştı.")        return sonuc    return wrapper

Bir fonksiyonun zamanlayıcı dekoratörü kullanarak nasıl dekore edileceği aşağıdaki örnekteki gibi gösterilebilir.

  • @zamanlayici decorator bir fonksiyonun çalışmasına zamanlayıcı ekler.
  • time.sleep(2) ile fonksiyon 2 saniye bekletildikten sonra çalışacaktır.
Örnek Kullanım
@zamanlayicidef bir_fonksiyon():    time.sleep(2)

sonuc

sonuc = fonksiyon(*args, **kwargs) kod satırı, dekoratörlerin önemli bir özelliğini açıklar. Bu kod satırı, dekoratörün “wrapper” fonksiyonu tarafından çağrılan, orijinal fonksiyona gelen argümanları ve anahtar kelime argümanlarını yakalar ve sonuçlarını saklar.

Örnek olarak, bir matrisi toplama işlemi yapmayı düşünelim. Matrisin herhangi bir boyutta olabilmesi için fonksiyonu *args yardımıyla tasarlayabiliriz. Ancak, matrisin sütun ve satırlarındaki farklı verileri ayırt etmek için anahtar kelime argümanları da kullanabiliriz. Bu durumda “sonuc = fonksiyon(*args, **kwargs)” satırı, işlem sonucunu depolayacak ve işlemin sonucunu geri döndürecektir.

Bunun yanı sıra, kodun hata alma olasılığını da düşürür. Çünkü, doğru argümanları aldığından ve result değerini doğru şekilde döndürdüğünden emin olur. Sonuç olarak, bu kod blokunun kullanımı, kodun daha anlaşılır, ölçeklenebilir, modüler ve daha az hata ile çalışmasını sağlar.

sure

Sure hesaplama, fonksiyonun ne kadar sürede çalıştığını belirlemek için kullanılır. Fonksiyonun başlangıç zamanı başla değişkeni ile alınır ve fonksiyon tamamlandıktan sonra geçen süre hesaplanır. Bu şekilde, bir fonksiyonun ne kadar sürede çalıştığı takip edilerek performansı değerlendirilebilir. Zamanlayıcı dekoratörü, bu işlemi otomatik olarak gerçekleştirir.

print(f

Python’da print() fonksiyonu, çıktıları ekrana yazdırmak için kullanılır. Kod kısmında hata ayıklama yapmak istediğimizde veya programcı olarak, kodun çalışma adımlarını takip etmek istediğimiz kod bloklarında da kullanabiliriz. Fakat, büyük veri setleri ve uzun yazı dizilerinin kullanımında sıkıntılı bir metotdur. Bu durumda,

f-string fonksiyonu kullanarak daha okunaklı ve işlevsel kod yazabiliriz.

f-string, metinlerdeki değişkenleri çağırmak ve işlem yaptırmak için kullanılan bir Python özelliğidir. ‘{ }’ arasına yazdığımız değişken adını, değişkene atadığımız değer ile eşleştirir ve string ifadesi içerisinde kullanabiliriz. Bu sayede, daha az kod yazarak daha anlaşılır ve işlevsel bir yapı elde ederiz.

{fonksiyon.__name__} fonksiyonu {sure} saniyede çalıştı.

{fonksiyon.__name__} fonksiyonu {sure} saniyede çalıştı: Bu dekoratör sayesinde, fonksiyonun çalışma süresi otomatik olarak hesaplanır ve ekrana yazdırılır. Böylece, fonksiyonun performansı hakkında önemli bilgiler elde edilebilir. Zamanlama dekoratörü, özellikle büyük ve karmaşık işlemleri yapan fonksiyonlarda son derece faydalıdır. Kod okunabilirliği artırır, hata ayıklamayı kolaylaştırır ve performans sorunlarını tespit etmeye yardımcı olur.

Zamanlama dekoratörü, Python’da sık kullanılan dekoratörlerden biridir ve daha pek çok kullanım alanı vardır. Decorator’lar, kodun daha modüler hale gelmesini sağlar ve tekrar kullanılabilir kod blokları yaratır. Dahili dekoratörler gibi hazır fonksiyonlar da vardır ve özellikle sınıflarla birlikte kullanıldıklarında son derece faydalıdır.

Python decorator’ları, yeni başlayan kullanıcılar için korkutucu olabilir, ancak daha fazla örnek kullanarak ve kodlama pratiği yaparak, kolaylıkla öğrenilebilirler. Decorator’ların farklı kullanım alanları ve benzersiz özellikleri vardır ve her Python geliştiricisi tarafından bilinmeleri gereken bir kavramdır.

)

Python’da decorator kavramı bir fonksiyonun işlevselliğini değiştirebilen, düzenleyen veya modifiye eden işlevlerdir. Decorator’lar fonksiyonları yeniden kullanılabilir ve modüler hale getirerek kod okunabilirliğini artırır ve karmaşıklığı azaltır. Decorator’lar ayrıca dahili olarak tanımlanabilir, örneğin @staticmethod, @classmethod ve @property gibi.

Bir fonksiyona dekoratör uygulamak oldukça basittir. Bir fonksiyon tanımlandıktan sonra dekoratör, @ sembolü kullanılarak fonksiyondan önce belirtilir. Aşağıda, bir fonksiyonun çalışma süresini hesaplayan basit bir zamanlayıcı dekoratörü kod örneği verilmiştir:

def zamanlayici(fonksiyon):    def wrapper(*args, **kwargs):        basla = time.time()        sonuc = fonksiyon(*args, **kwargs)        sure = time.time() - basla        print(f{fonksiyon.__name__} fonksiyonu {sure} saniyede çalıştı.)        return sonuc    return wrapper

Bu dekoratör, fonksiyonun çalışma süresini hesaplar ve sonucu yazdırır. Bu dekoratörü fonksiyonun üstüne yazmak için aşağıdaki gibi kullanılabilir:

  • @zamanlayici
  • def bir_fonksiyon():
  • time.sleep(2)

Bu örnek fonksiyon 2 saniye bekletildikten sonra çalışacaktır ve zamanlayıcı dekoratörü 2 saniyede çalıştığını otomatik olarak hesaplayacaktır.

return sonuc

Python’da decorator’ların kullanımı oldukça yaygındır. Decoratorlar, bir fonksiyonu modifiye eden veya düzenleyen işlevlerdir. Bir fonksiyonu dekore etmek için @ sembolü kullanılır ve fonksiyondan önce belirtilir.

Bir fonksiyonun zamanını ölçmek ve çalışma süresi hakkında bilgi edinmek için zamanlayıcı bir dekoratör örneği verilebilir. Bu dekoratör, fonksiyonun çalışma süresini hesaplayacak ve sonucu geliştiriciye gösterecektir.

return sonuc ifadesi, dekoratör fonksiyonda sonucu döndürmek için kullanılır. Bu, dekore edilmiş fonksiyonun asıl sonucunu üretir ve dekoratör tarafından sağlanan ekstra işlevlerin yanı sıra bu sonucu da döndürür.

return wrapper

“return wrapper” kod satırı dekoratörlerin en önemli parçalarındandır. Burada wrapper adlı bir işlev döndürülür, bu da fonksiyonun modifiye edilmiş hali olacaktır. Wrapper işlevi, öncelikle fonksiyonun çalıştırılmasını yönetir. Fonksiyondan önce belirtilen ‘@’ sembolü, kullanılabilecek dekoratör işlevlerini belirtir ve hangi dekoratörün kullanıldığına bağlı olarak, wrapper işlevi de değişebilir.

Bu örnekte, zamanlayıcı dekoratörü kullanılıyor. Yani, ilk adımda fonksiyonun başlangıç zamanı alınır ve fonksiyon çalıştırıldıktan sonra bitiş zamanı alınır. Ardından, geçen süre hesaplanır ve sonucu döndüren bir mesaj yazdırılır. Bu sayede, zamanlayıcı dekoratörü fonksiyonu modifiye eder ve işlevin çalışma süresi rapor edilir.

Birçok dekore işlevi, wrapper işleviyle birlikte bir nesne döndürür. Bu nesne, özgün fonksiyonun çalışması sırasında kullanılabilen bazı özelliklere sahip olabilir. Bazı örneklere bakılırsa, dahili dekoratörler bunun örneklerindendir. Bu dekoratörler, sınıf yöntemleri, sınıf değişkenleri ve statik yöntemler gibi şeyler yaratmaya yardımcı olabilirler. Bu sayede, kod yazmanın hızı artar ve kod daha düzenli hale gelir.

Kullanımı

Kullanımı oldukça basit bir şekilde gerçekleştirilir. Dekore etmek istediğimiz fonksiyondan önce @ sembolü kullanarak zamanlayıcı dekoratörü belirtilir. Ardından dekore etmek istediğimiz fonksiyon çağrılır ve fonksiyon çalıştıktan sonra dekoratör tarafından süre hesaplanır. Sonuç olarak, zamanlayıcı dekoratörü kullanımı kodların okunabilirliğini ve bakım kolaylığını artırır.

def bir_fonksiyon():

Python kodunda kullanılan dekoratörler, bir fonksiyonun işlevselliğini değiştirerek daha esnek ve özelleştirilebilir bir hale getirirler. Bu nedenle, bir fonksiyonu dekore etmek istediğimizde, @ sembolü kullanılarak fonksiyondan önce dekoratör belirtilir.

Örneğin, “def bir_fonksiyon ()” adlı bir fonksiyonun, 2 saniye bekleyerek çalıştığını varsayalım. Bu fonksiyon, @zamanlayici dekoratörü ile süresini hesaplayan bir zamanlayıcıya dönüştürülebilir. Bunun için zamanlayıcı dekoratörü kod örneğindeki gibi bir kod bloğu yazılır ve örnek fonksiyonun önüne @zamanlayici dekoratörü eklenir.

Kod Örneği – Zamanlayıcı Dekoratörü
def zamanlayici(fonksiyon):

def wrapper(*args, **kwargs):

basla = time.time()
sonuc = fonksiyon(*args, **kwargs)
sure = time.time() – basla
print(f”{fonksiyon.__name__} fonksiyonu {sure} saniyede çalıştı.”)
return sonuc

return wrapper

Örnek fonksiyon, @zamanlayici dekoratörü ile aşağıdaki gibi tanımlanır:

Kullanımı
@zamanlayici
def bir_fonksiyon():

time.sleep(2)

Bu örnek fonksiyon, 2 saniye beklettikten sonra çalıştırılır ve zamanlayıcı dekoratörü tarafından otomatik olarak hesaplanarak, fonksiyonun çalışma süresi çıktı olarak verilir.

time.sleep(2)

Bir fonksiyonu dekore etme konusunda bir başka örnek de, fonksiyona beklemeyi eklemektir. Bu, @wait_decorator adlı bir dekoratör kullanılarak yapılabilir. Verilen fonksiyonlarının herhangi birinde beklemeyi simüle etmek için time.sleep() fonksiyonu kullanılabilir. Bu dekoratör ile, beklemeyi birden fazla fonksiyona uygulayabilirsiniz.

Kod örneği için, aşağıdaki fonksiyon kullanımı ele alınabilir:

@wait_decoratordef my_function(): print(“Bu fonksiyon 2 saniye bekleyecek.”)

my_function()

Yukarıdaki kod, my_function() fonksiyonunun çalışmasını geciktirmek için @wait_decorator adlı dekoratörü kullanır. Bu örnekte, fonksiyon 2 saniye bekletildikten sonra çalıştırılacaktır.

Bu tür dekoratörler, zamanlama ve beklemeyi gerektiren birçok işlevsel durumda oldukça kullanışlı olabilir. Ayrıca kodun daha okunaklı ve kullanılabilir hale gelmesine yardımcı olabilirler.

Örnek fonksiyon 2 saniye bekletildikten sonra çalışacaktır ve 2 saniyede çalıştığı zamanlayıcı dekoratörü tarafından otomatik olarak hesaplanacaktır.

Kullanımı:

@zamanlayicidef bir_fonksiyon(): time.sleep(2)

Örnek fonksiyon 2 saniye bekletildikten sonra çalışacaktır ve 2 saniyede çalıştığı zamanlayıcı dekoratörü tarafından otomatik olarak hesaplanacaktır. Bu örnek kullanım, zamanlayıcı dekoratörünün fonksiyonu ne kadar sürede çalıştırdığını hesaplayarak, performans testleri yapma veya fonksiyonların nasıl çalıştığını kontrol etme gibi durumlarda kullanışlıdır.

Dahili Dekoratörler

Python’da dekoratörler, @ sembolü kullanılarak fonksiyonlarda tanımlanabildiği gibi, dahili olarak tanımlanmış dekoratörler de mevcuttur. Bu dahili dekoratörler, kod yazımını daha kolay ve esnek hale getirir ve genellikle özellikle sınıflarla çalışırken kullanılır.

  • @staticmethod: Bu dekoratör, sınıftan bağımsız, belirli bir nesnenin olmadığı fonksiyonlar tanımlar.
  • @classmethod: Bu dekoratör, sınıf düzeyinde özellikleri ve yöntemleri değiştirir ve sınıftan bağımsız olarak kullanılabilen bir fonksiyondur.
  • @property: Bu dekoratör, sınıf özelliklerini çağırırken bazı işlemleri gerçekleştiren özellik meslektaşları oluşturabilir. Bu, getter ve setter aracılığıyla sınıf özelliklerinin güvenli bir şekilde yönetilmesine olanak tanır.

Dahili dekoratörler, programcılara daha fazla esneklik ve sınıflarının yapısının daha düzenli hale getirilmesi için bir dizi araç sağlar. Kendi dekoratörlerinizi oluştururken, dahili dekoratörlerin doğru kullanımı hakkında bilgi sahibi olmak size büyük bir avantaj sağlayacaktır.

Decorator’ların Faydaları

Python Decorator kavramının uygulanması, kod yazım sürecinde bir dizi fayda sağlamaktadır. Decorator’lar, kod düzenlemelerinin tekrar kullanımını ve kodun yeniden modüler hale gelmesini sağlar. Decorator’lar, kodun okunabilirliğini artıran bir şekilde kullanıcıya yardımcı olur. Bu sayede, kod düzenlemelerinin yapılması daha kolay ve daha anlaşılır hale gelmektedir.

Python’da dahili olarak tanımlanan dekoratörler, örneğin, @staticmethod, @classmethod ve @property’deki gibi dahili fonksiyonları uygulamak için kullanılabilmektedir. Decorator’lar, programcıların tekrar açıkça kod yazmasını sağlamadan, okunabilir kodlar yazmalarına yardımcı olur. Bu, kodun daha sade ve anlaşılır hale gelmesini sağlar. Dolayısıyla, decorator’lar sayesinde programcılar daha kısa sürede daha fazla fonksiyon hazırlayabilirler.

İlgili Yazılar

Bir yanıt yazın

E-posta adresiniz yayınlanmayacak. Gerekli alanlar * ile işaretlenmişlerdir