Python’da Kapsülleme: Kapsamlı Bir Rehber

Kapsülleme, Python’daki temel nesne yönelimli ilkelerden biridir. Sınıflarınızı kazara yapılan değişiklik veya silinmelere karşı korur ve kodun yeniden kullanılabilirliğini ve sürdürülebilirliğini artırır. Şu basit sınıf tanımını düşünün:

class Smartphone:
   def __init__(self, brand, os):
       self.brand = brand
       self.os = os

iphone = Smartphone("Apple", "iOS 17")

Birçok Python programcısı sınıfları bu şekilde tanımlar. Ancak bu, profesyonel Python geliştiricilerinin takip ettiği en iyi uygulamalardan oldukça uzaktır. Bu sınıftaki sorun, verilerini değiştirmeye çalıştığınızda açıkça ortaya çıkar:

iphone.os = "Android"
print(iphone.os)

Android

Android çalıştıran bir iPhone hayal edin — ne büyük bir aykırılık! Açıkça görülüyor ki, kullanıcıların özniteliklerini istedikleri gibi değiştirmelerini engellemek için sınıfımız içinde bazı sınırlar koymamız gerekiyor.

Eğer değiştirmeye karar verirlerse, bu değişiklikler bizim şartlarımız ve kurallarımız doğrultusunda yapılmalı. Yine de yüzeyde .os veya .brand özniteliklerinin aynı kalmasını istiyoruz.

Tüm bunlar kapsüleme kullanılarak desteklenebilir ve bu derste bununla ilgili her şeyi öğreneceğiz. Hadi başlayalım!

Python’da Kapsülleme Nasıl Sağlanır?

Python, zorunlu erişim belirleyicileri yerine, sözleşmeler ve programlama uygulamaları aracılığıyla kapsülemeyi destekler. Şöyle ki, Python kod tasarımının büyük bölümünün arkasındaki temel ilke “Burada hepimiz yetişkiniz.” anlayışıdır. Kapsülemeyi yalnızca bir sözleşme olarak uygulayabilir ve diğer Python geliştiricilerinin kodumuza güvenip saygı göstereceğini umabiliriz.

Java ve C++ gibi diğer OOP dillerinde kapsülleme, public, private veya protected gibi erişim belirleyicileriyle sıkı şekilde uygulanır, ancak Python’da bunlar yoktur:

Dolayısıyla, size göstermek üzere olduğum kapsülleme tekniklerinin çoğu, hatta tamamı Python sözleşmeleridir. İsterseniz kolayca bozulabilirler. Ancak kendi geliştirme projelerinizde bunlara saygı göstereceğinize ve uyacağınıza güveniyorum.

Python’da erişim belirleyicileri

Diyelim ki şöyle basit bir sınıfımız var:

class Tree:
   def __init__(self, height):
       self.height = height

pine = Tree(20)
print(pine.height)

20

Yazdırabildiğimiz tek bir height özniteliği var. Sorun şu ki, bunu istediğimiz herhangi bir şeye de çevirebiliriz:

pine.height = 50
pine.height

50

pine.height = "Grandma"
pine.height

'Grandma'

Peki kullanıcılara, height’ı değiştirmenin yasak olduğunu nasıl söyleriz? Bir korumalı üyeye çevirerek; bunun için başına tek alt çizgi ekleriz:

class Tree:
   def __init__(self, height):
       self._height = height

pine = Tree(20)
pine._height

20

Artık bu sözleşmeyi bilen kişiler, özniteliğe yalnızca erişebileceklerini ve onu kullanıp değiştirmelerinin şiddetle tavsiye edilmediğini anlayacaktır. Ama isterlerse değiştirebilirler, evet.

Öyleyse bunu da nasıl önleriz? Başka bir sözleşme kullanarak — özniteliği başına çift alt çizgi ekleyerek bir özel üyeye dönüştürerek:

class Tree:
   def __init__(self, height):
       self.__height = height


pine = Tree(20)
pine.__height

AttributeError: 'Tree' object has no attribute '__height'

Artık biri özniteliğe erişmeye çalışırsa, değiştirmeyi bırakın, Python bir hata yükseltecek.

Ama ne yaptığımızın farkında mısınız? Nesnelerimizle ilgili tek bilgiyi kullanıcıdan gizledik. Sınıfımız halka açık öznitelik olmadığından işe yaramaz hale geldi.

Peki ağaç yüksekliğini kullanıcılara nasıl açarız ama yine de nasıl erişilip değiştirileceğini kontrol ederiz? Örneğin, ağaç yüksekliklerinin belirli bir aralıkta ve yalnızca tam sayı olmasını istiyoruz. Bunu nasıl zorunlu kılarız?

Bu noktada, Java kullanan bir arkadaşınız devreye girip getter ve setter yöntemleri kullanmayı önerebilir. O halde önce bunu deneyelim:

class Tree:
   def __init__(self, height):
       self.__height = height

   def get_height(self):
       return self.__height

   def set_height(self, new_height):
       if not isinstance(new_height, int):
           raise TypeError("Tree height must be an integer")
       if 0 < new_height <= 40:
           self.__height = new_height
       else:
           raise ValueError("Invalid height for a pine tree")


pine = Tree(20)
pine.get_height()

20

Bu şekilde, __height adlı bir özel öznitelik oluşturur, ancak kullanıcıların buna get_height ve set_height yöntemlerini kullanarak kontrollü bir şekilde erişip değiştirmesine izin verirsiniz.

pine.set_height(25)

pine.get_height()

25

set_height, yeni bir değer ayarlamadan önce yeni yüksekliğin belirli bir aralıkta ve sayısal olduğundan emin olur.

pine.set_height("Password")

TypeError: Tree height must be an integer

Ancak bu yöntemler basit bir işlem için biraz abartı görünüyor. Ayrıca, şu şekilde kod yazmak da pek hoş değil:

# Increase height by 5
pine.set_height(pine.get_height() + 5)

Şu kodu yazabilsek daha güzel ve okunaklı olmaz mıydı:

pine.height += 5

ve yine de height için doğru veri türünü ve aralığı zorunlu kılsak? Cevap evet ve bir sonraki bölümde tam olarak bunu nasıl yapacağımızı öğreneceğiz.

Python sınıflarında @property dekoratörünü kullanma

Yeni bir teknik tanıtıyoruz — öznitelikler için property oluşturma:

class Tree:
   def __init__(self, height):
       # First, create a private or protected attribute
       self.__height = height

   @property
   def height(self):
       return self.__height

pine = Tree(17)
pine.height

17

Kullanıcıların __height adlı gizli bir özniteliğe, sanki height adlı normal bir öznitelikmiş gibi erişmesini istiyoruz. Bunu başarmak için, self.__height döndüren ve @property ile dekore edilen height adlı bir yöntem tanımlarız.

Artık height çağrılarak özel özniteliğe erişilebilir:

pine.height

17

Ancak en iyi yanı, kullanıcıların bunu değiştiremiyor olmasıdır:

pine.height = 15

AttributeError: can't set attribute 'height'

Bu yüzden, height.setter dekoratörüyle sarmalanan height(self, new_height) adlı başka bir yöntem ekleriz. Bu yöntemin içinde, height için istenen veri türünü ve aralığı zorunlu kılan mantığı uygularız:

class Tree:
   def __init__(self, height):
       self.__height = height

   @property
   def height(self):
       return self.__height

   @height.setter
   def height(self, new_height):
       if not isinstance(new_height, int):
           raise TypeError("Tree height must be an integer")
       if 0 < new_height <= 40:
           self.__height = new_height
       else:
           raise ValueError("Invalid height for a pine tree")

Artık bir kullanıcı height özniteliğini değiştirmeye çalıştığında, @height.setter çağrılır ve böylece doğru değerin geçirildiğinden emin olunur:

pine = Tree(10)

pine.height = 33  # Calling @height.setter
pine.height = 45  # An error is raised

ValueError: Invalid height for a pine tree

@height.getter ile, height özniteliğine nokta gösterimiyle erişimin şeklini de özelleştirebiliriz:

class Tree:
   def __init__(self, height):
       self.__height = height

   @property
   def height(self):
       return self.__height

   @height.getter
   def height(self):
       # You can return a custom version of height
       return f"This tree is {self.__height} meters"


pine = Tree(33)

pine.height

'This tree is 33 meters'

pine’ı tam sayı bir yükseklikle oluşturmuş olsak da, değerini @height.getter ile değiştirebildik.

Bunlar, bir Python sınıfında kapsülemeyi nasıl teşvik edebileceğimize dair örneklerdi. Unutmayın, kapsülleme hâlâ bir sözleşmedir çünkü dahili __height özel üyesini yine de bozabiliriz:

pine._Tree__height = "Gotcha!"

pine.height

'This tree is Gotcha! meters'

Python sınıflarındaki her şey özeldir demiyoruz; aksine her şey genelde herkese açıktır ve özel yöntemler de öyledir. Bu bir tasarım hatası değil, “Burada hepimiz yetişkiniz” yaklaşımının bir yansımasıdır.

İşte az önce gözden geçirdiğimiz Python erişim belirleyicilerine genel bir bakış:

Kapsülleme Uygularken En İyi Uygulamalar

Kodunuzun diğer deneyimli OOP’cuların yazdığı kodla iyi hizalanmasını sağlamak için takip edebileceğiniz bazı en iyi uygulamalar şunlardır:

1. Yalnızca sizin kullandığınız öznitelik veya yöntemler için korumalı ya da özel üyeler oluşturun. Korumalı veya özel üyeler dokümantasyondan hariç tutulur ve geliştirici olarak sizin haber vermeden değiştirebileceğinizi işaret eder; böylece başkalarının bunları kullanmasını caydırır.
2. Her bir sınıf özniteliği için mutlaka property oluşturmanız gerekmez. Çok sayıda özniteliği olan büyük sınıflarda attr.getter ve attr.setter yazmak baş ağrısına dönüşebilir.
3. Bir kullanıcı korumalı bir üyeye (_) her eriştiğinde uyarı vermeyi değerlendirin.
4. Özel üyeleri ölçülü kullanın, çünkü sözleşmeye aşina olmayanlar için kodu okunaksız hale getirebilirler.
5. Açıklı ğa kapalılıktan öncelik verin. Kapsülleme, kodun bakımını ve veri korumasını iyileştirmeyi amaçlar; bu nedenle sınıfınızın önemli uygulama ayrıntılarını tamamen gizlemeyin.
6. Salt-okunur property’ler oluşturmak istiyorsanız, @attr.setter yöntemini uygulamayın. Kullanıcılar property’ye erişebilir ama onu değiştiremez.
7. Kapsüllemenin bir sözleşme olduğunu, Python söz diziminin zorladığı bir özellik olmadığını her zaman hatırlayın.
8. Basit sınıflar için dataclass’ları kullanmayı düşünün; tek satırlık bir kodla sınıf kapsüllemesini etkinleştirmenize olanak tanırlar. Ancak dataclass’lar, öznitelik ve yöntemleri öngörülebilir daha basit sınıflar içindir. Daha fazla bilgi için bu dataclass’lar dersine göz atın.

Sonuç ve Ek Kaynaklar

Bu derste, Python’da nesne yönelimli programlamanın temel direklerinden birini öğrendik: kapsülleme.

Kapsülleme, sınıfınızın nesneleri içinde depolanan verilere kontrollü erişim tanımlamanızı sağlar. Bu sayede temiz, okunabilir ve verimli kod yazabilir, sınıf verilerinizin kazara değiştirilmesini veya silinmesini önleyebilirsiniz.

OOP bilginizi artırmak için bazı ilgili kaynaklar:

• Python OOP dersi
• Python’da Nesne Yönelimli Programlama
• Python’u Nasıl Ustalaşırsınız — Uzman Rehberi