Nesne Yönelimli Programlama (OOP), yazılımı modüler, esnek ve yönetilebilir kılmak için çeşitli prensipler ve mekanizmalar sunar. Bu prensiplerden en önemlilerinden biri olan Kapsülleme (Encapsulation), verinin (niteliklerin) ve o veriyi işleyen davranışların (metotların) mantıksal bir bütünlük içinde bir araya getirilmesi ve nesnenin iç detaylarının dış dünyadan korunması fikrine dayanır. Kapsüllemenin temel amaçlarından biri, nesnenin iç durumuna doğrudan ve kontrolsüz erişimi engelleyerek veri bütünlüğünü sağlamak ve uygulama detaylarını gizlemektir.

Birçok geleneksel OOP dilinde (Java, C++, C# gibi), kapsüllemeyi uygulamak ve veri gizliliğini sağlamak için erişim belirleyiciler (access modifiers) olarak adlandırılan anahtar kelimeler (genellikle public, private, protected) kullanılır. Bu belirleyiciler, bir sınıf üyesinin (nitelik veya metot) sınıf dışından veya alt sınıflardan erişilebilirliğini katı bir şekilde kontrol eder.

Ancak Python, bu konuda farklı bir yaklaşım benimser. Python’da Java veya C++’daki gibi katı private veya protected anahtar kelimeleri bulunmaz. Bunun yerine, Python geliştiriciler arasındaki güvene ve konvansiyonlara (geleneklere) dayanır. Bu durum, Python'a yeni başlayanlar veya başka dillerden gelenler için kafa karıştırıcı olabilir. "Eğer katı kısıtlamalar yoksa, Python'da kapsülleme nasıl sağlanır?" sorusu sıkça sorulur.

Bu rehberde, geleneksel erişim belirleyicilerin ne anlama geldiğini açıklayacak, Python’un erişim kontrolüne yaklaşımını detaylandıracak (public, tek alt çizgi _ ile “protected” konvansiyonu, çift alt çizgi __ ile “private” isim karmaşası), bu mekanizmaların kapsülleme prensibiyle nasıl bir ilişki içinde olduğunu inceleyecek ve Python’da kontrollü erişim sağlamanın “Pythonic” yollarını (özellikle @property dekoratörünü) ele alacağız.

Bölüm 1: Erişim Belirleyiciler Kavramı (Genel OOP)
Python’un yaklaşımını anlamadan önce, diğer dillerde yaygın olan erişim belirleyici kavramlarına kısaca göz atmak faydalıdır. Bu kavramlar, bir sınıf üyesine kimlerin erişebileceğini tanımlar:

Public (Genel/Halka Açık):
Erişim: Her yerden erişilebilir (sınıfın içinden, alt sınıflardan, sınıf dışından).
Amaç: Sınıfın dış dünya ile iletişim kurmasını sağlayan resmi arayüzü oluşturur. Metotlar ve bazen de doğrudan değiştirilmesinde sakınca olmayan nitelikler public yapılır.
Anahtar Kelime (Örnek): Java/C#/C++’da public (veya bazen varsayılan).
Protected (Korumalı):
Erişim: Tanımlandığı sınıfın içinden ve o sınıftan türeyen alt sınıflardan erişilebilir. Genellikle aynı paket (package) içindeki diğer sınıflardan da erişime izin verilebilir (dile göre değişir). Sınıf dışından doğrudan erişim genellikle kısıtlıdır veya yoktur.
Amaç: Sınıfın iç implementasyonunun bir parçası olan ancak alt sınıfların kullanması veya override etmesi gerekebilecek üyeler için kullanılır. Dış dünyanın doğrudan erişmesi istenmez.
Anahtar Kelime (Örnek): Java/C#’da protected, C++'da protected.
Private (Özel):
Erişim: Sadece ve sadece tanımlandığı sınıfın içinden erişilebilir. Alt sınıflar veya sınıf dışındaki hiçbir kod bu üyelere doğrudan erişemez.
Amaç: Sınıfın tamamen içsel olan uygulama detaylarını, yardımcı fonksiyonlarını veya hassas verilerini dış dünyadan tamamen gizlemek için kullanılır. Bu, en katı erişim seviyesidir ve kapsüllemenin bilgi gizleme yönünü en güçlü şekilde uygular.
Anahtar Kelime (Örnek): Java/C#/C++’da private.
Bu katı erişim kontrolü, derleyici veya yorumlayıcı tarafından zorunlu kılınır ve geliştiricinin yanlışlıkla veya kasıtlı olarak sınıfın iç yapısını bozmasını engellemeyi hedefler.

Bölüm 2: Python’un Yaklaşımı: Güven ve Konvansiyon
Python, “We are all consenting adults here” (Hepimiz anlaşan yetişkinleriz) felsefesini benimser. Bu, dilin geliştiricilere güvendiği ve katı kısıtlamalar koymak yerine, neyin “içsel” neyin “dışsal” olduğunu belirtmek için konvansiyonlar kullandığı anlamına gelir.

Python’da teknik olarak hiçbir şey gerçekten private veya protected değildir. Yeterince isterseniz, her niteliğe ve metoda dışarıdan erişmenin bir yolu genellikle bulunur. Ancak, kullanılan konvansiyonlar geliştiricilere güçlü sinyaller verir ve bu sinyallere uymak iyi bir programlama pratiğidir.

Python’daki erişim seviyeleri ve bunlarla ilişkili konvansiyonlar şunlardır:

2.1. Public (Genel/Halka Açık)
Tanımlama: Herhangi bir alt çizgi () ile başlamayan tüm nitelikler ve metotlar varsayılan olarak public kabul edilir.
Erişim: Her yerden serbestçe erişilebilir.
Amaç: Sınıfın dış dünyaya sunduğu resmi arayüzdür. Sınıfı kullananların bu üyelere güvenle erişebilmesi ve kullanabilmesi beklenir. Sınıf yazarı, bu public arayüzün gelecekteki versiyonlarda (mümkün olduğunca) uyumlu kalacağını ima eder.
class ArabaPublic:
def __init(self, marka):
self.marka = marka # Public nitelik
self.hiz = 0 # Public nitelik
def hizlan(self, miktar): # Public metot
self.hiz += miktar
print(f"{self.marka} hızlandı: {self.hiz}")
araba = ArabaPublic("Tesla")
print(araba.marka) # Public erişim
araba.hiz = 50 # Public erişim ve değiştirme
araba.hizlan(30) # Public metot çağrısı
2.2. “Protected” Konvansiyonu: Tek Alt Çizgi ()
Tanımlama: İsimleri tek bir alt çizgi ile başlar (örn: self.bakiye, def _hesapla_faiz(self):).
Anlamı: Bu bir konvansiyondur, teknik bir kısıtlama değildir. Geliştiriciye şu mesajı verir: “Bu üye, sınıfın iç implementasyonunun bir parçasıdır veya alt sınıflar tarafından kullanılmak üzere tasarlanmıştır. Lütfen bu üyeye sınıfın dışından doğrudan erişmeyin veya değiştirmeyin. Eğer yaparsanız, sorumluluk size aittir, çünkü gelecekte bu iç detay değişebilir ve kodunuz bozulabilir.”
Erişim: Teknik olarak public üyeler gibi erişilebilir. Python erişimi engellemez. from module import * ifadesi genellikle alt çizgi ile başlayan isimleri import etmez, bu da bir nebze koruma sağlar ama asıl amaç bu değildir.
Kullanım Amacı:
Sınıfın iç işleyişi için gerekli olan ama dış arayüzün parçası olmayan yardımcı değişkenler veya metotlar.
Alt sınıfların override etmesi veya kullanması beklenen, ancak son kullanıcıların doğrudan çağırmaması gereken “yarı-özel” üyeler.
İleride public yapılabilecek veya tamamen kaldırılabilecek deneysel veya geçici üyeler.
class BankaHesabi:
def __init_(self, hesap_no, bakiye=0):
self.hesap_no = hesap_no # Public
self._bakiye = bakiye # Protected konvansiyonu
def _logla(self, mesaj): # Protected metot konvansiyonu
print(f"[LOG {self.hesap_no}]: {mesaj}")
def para_yatir(self, miktar): # Public arayüz
if miktar > 0:
self._bakiye += miktar
self._logla(f"{miktar} TL yatırıldı.")
return True
self._logla("Geçersiz yatırma miktarı.")
return False
def bakiye_goster(self): # Public arayüz
self._logla("Bakiye sorgulandı.")
return self._bakiye
hesap = BankaHesabi("12345", 500)
hesap.para_yatir(200)
print(f"Güncel Bakiye: {hesap.bakiye_goster()}")

DİKKAT: Aşağıdakiler teknik olarak mümkün ama yapılmamalı!

print(f"Doğrudan bakiye erişimi (yapılmamalı): {hesap.bakiye}")
hesap._bakiye = -1000 # Doğrudan müdahale, kapsüllemeyi bozar!
print(f"Bozulan bakiye: {hesap._bakiye}")
hesap._logla("Bu log dışarıdan çağrılmamalıydı.")
2.3. “Private” Konvansiyonu: Çift Alt Çizgi () ve İsim Karmaşası (Name Mangling)
Tanımlama: İsimleri en az iki alt çizgi ile başlar ve en fazla bir alt çizgi ile biter (örn: self.gizli_veri, def __ozel_hesaplama(self):). Not: __init_ gibi dunder metotları bu kapsama girmez.
Mekanizma: İsim Karmaşası (Name Mangling): Python, bu tür isimleri otomatik olarak SinifAdiuyeAdi formatına çevirir. Örneğin, Veri sınıfındaki self.deger aslında self._Verideger olur.
Asıl Amaç: İsim Çakışmalarını Önleme: Bu mekanizmanın temel amacı, alt sınıfların yanlışlıkla üst sınıftaki aynı isimli bir “private” üyeyi ezmesini veya kullanmasını engellemektir. Kalıtım hiyerarşilerinde isim alanlarını korumaya yöneliktir.
Gizlilik Etkisi: Doğrudan erişimi nesne.uyeAdi şeklinde engeller (AttributeError verir). Bu, tek alt çizgiden daha güçlü bir "erişme" sinyali verir. Ancak, gerçek bir gizlilik sağlamaz çünkü değiştirilmiş isme (nesne._SinifAdiuyeAdi) hala erişilebilir.
Erişim: Sınıf içinden orijinal isimle (self.uyeAdi) erişilir. Sınıf dışından veya alt sınıflardan (doğrudan üst sınıfın private üyesine erişmeye çalışırken) orijinal isimle erişilemez. Değiştirilmiş isimle erişim mümkündür ama kesinlikle önerilmez.
class GizliSayac:
def __init(self):
self.sayac = 0 # "Private" nitelik (name mangling)
def __arttir(self): # "Private" metot (name mangling)
self.sayac += 1
def tikla(self): # Public arayüz
self.arttir() # İçeriden orijinal isimle erişim
print("Tiklandı!")
def deger_getir(self): # Public arayüz
return self._sayac # İçeriden orijinal isimle erişim
s = GizliSayac()
s.tikla()
s.tikla()
print(f"Sayaç Değeri: {s.deger_getir()}") # 2

Dışarıdan erişim denemeleri

try:
print(s.sayac)
except AttributeError as e:
print(f"\nHata (Doğrudan __ Erişim): {e}")
try:
s.arttir()
except AttributeError as e:
print(f"Hata (Doğrudan __ Metot): {e}")

Name mangling ile erişim (YAPILMAMALI!)

print(f"\nMangled isimle erişim: {s.GizliSayacsayac}")
s._GizliSayac_arttir()
print(f"Mangled metot çağrısı sonrası: {s.deger_getir()}") # 3
Bölüm 3: Kapsülleme ve Erişim Belirleyiciler (Konvansiyonlar) Arasındaki İlişki
Şimdi bu iki kavramı birleştirelim:

Kapsülleme, OOP’nin bir prensibidir. Veri ve metotları birleştirme ve iç detayları gizleme fikridir. Amacı veri bütünlüğü, esneklik ve modülerlik sağlamaktır.
Erişim Belirleyiciler (veya Python’daki karşılığı olan isim konvansiyonları), kapsüllemenin özellikle bilgi gizleme yönünü uygulamak için kullanılan mekanizmalardır.
İlişkiyi şöyle özetleyebiliriz:

Public Üyeler: Kapsüllemenin dış dünyaya açılan arayüzünü oluştururlar. Bunlar, nesneyle güvenli bir şekilde etkileşim kurmanın beklenen yoludur.
Protected Üyeler (): Kapsüllemenin "iç çemberini" temsil ederler. Dış kullanıcıların doğrudan kurcalamaması gereken, ancak belki alt sınıfların ihtiyaç duyabileceği implementasyon detaylarıdır. Geliştiriciye "dikkatli ol" sinyali verirler.
Private Üyeler (_): Kapsüllemenin daha korunaklı bir katmanıdır. Asıl amacı kalıtımda isim çakışmalarını önlemek olsa da, aynı zamanda bir üyeye dışarıdan yanlışlıkla erişilmesini zorlaştırarak bilgi gizlemeye katkıda bulunur. Ancak bu, aşılamaz bir engel değildir.
Python’un yaklaşımı, katı kurallar yerine geliştiricinin sorumluluğuna ve anlayışına dayanır. Tek alt çizgi ve çift alt çizgi, diğer geliştiricilere o üyenin kullanım amacı hakkında önemli ipuçları verir. Bu konvansiyonlara saygı duymak, temiz, sürdürülebilir ve işbirlikçi kod yazmanın önemli bir parçasıdır.

Kapsülleme bir amaçtır, erişim belirleyici konvansiyonları ise (Python’da) bu amaca ulaşmak için kullanılan araçlardan (veya daha çok işaretlerden) biridir.

Bölüm 4: Python’da Kontrollü Erişim Sağlama: Property’ler
Peki, Python’da niteliklere erişimi gerçekten kontrol etmek, değer atandığında doğrulama yapmak veya değer okunduğunda hesaplama yapmak istiyorsak ne yapmalıyız? Konvansiyonlar erişimi engellemediğine göre, daha sağlam bir mekanizmaya ihtiyaç duyarız.

Geleneksel getter/setter metotları bir seçenek olsa da (Bölüm 3.1'de tartışıldı), Python’un daha zarif çözümü property’lerdir.

@property, @isim.setter, ve @isim.deleter dekoratörleri, metotları sanki public niteliklermiş gibi davranacak şekilde sarmalamamızı sağlar. Bu, dışarıdan basit bir nesne.nitelik erişimi ve nesne.nitelik = deger ataması gibi görünürken, arka planda bizim tanımladığımız getter ve setter metotlarının çalışmasını sağlar.

Bu yaklaşım, kapsüllemenin faydalarını (veri doğrulama, kontrollü erişim, iç implementasyonu gizleme) Pythonic ve temiz bir sözdizimi ile sunar.

class Sicaklik:
def init(self, derece_celsius=0):
# Başlangıçta doğrudan setter'ı çağırmak iyi bir pratik
self.celsius = derece_celsius # Bu @celsius.setter'ı tetikler
@property
def celsius(self):
"""Celsius cinsinden sıcaklığı alır."""
print("Getter çağrıldı (_celsius okunuyor)")
# Genellikle korumalı/özel bir değişkenden okunur
return self._celsius
@celsius.setter
def celsius(self, deger):
"""Celsius cinsinden sıcaklığı ayarlar (doğrulama ile)."""
print(f"Setter çağrıldı (deger={deger})")
# Mutlak sıfırın (-273.15 C) altında olamaz kontrolü
if deger < -273.15:
raise ValueError("Sıcaklık mutlak sıfırın altında olamaz!")
self._celsius = deger # Doğrulama başarılı, iç değişkene ata
@property
def fahrenheit(self):
"""Sıcaklığı Fahrenheit cinsinden hesaplayıp döndürür (hesaplanan property)."""
print("Fahrenheit getter çağrıldı (hesaplanıyor)")
return (self.celsius * 9/5) + 32
# Fahrenheit için bir setter da tanımlayabiliriz (isteğe bağlı)
@fahrenheit.setter
def fahrenheit(self, deger):
"""Fahrenheit cinsinden sıcaklık alır ve Celsius'a çevirip ayarlar."""
print(f"Fahrenheit setter çağrıldı (deger={deger})")
celsius_degeri = (deger - 32) * 5/9
# Celsius setter'ını kullanarak doğrulama ve atama yapalım
self.celsius = celsius_degeri

Kullanım

termometre = Sicaklik(25) # Setter çağrılır: deger=25

Okuma (Getter'ları tetikler)

print(f"\nCelsius: {termometre.celsius}") # Getter çağrıldı... -> 25
print(f"Fahrenheit: {termometre.fahrenheit}") # Getter çağrıldı... Fahrenheit getter çağrıldı... -> 77.0

Atama (Setter'ları tetikler)

print("\nFahrenheit üzerinden atama yapılıyor...")
termometre.fahrenheit = 212 # Fahrenheit setter -> Celsius setter çağrılır
print(f"Yeni Celsius: {termometre.celsius}") # Getter çağrıldı... -> 100.0
print("\nCelsius üzerinden geçersiz atama denemesi...")
try:
termometre.celsius = -300 # Celsius setter ValueError fırlatır
except ValueError as e:
print(f"Hata Yakalandı: {e}")

İç değişkene doğrudan erişim (önerilmez)

print(termometre._celsius)

Property’ler sayesinde:

Sınıfın kullanıcısı basit bir nitelik erişimi (termometre.celsius, termometre.fahrenheit) yapar.
Arka planda, değer atandığında doğrulama (setter’da), değer okunduğunda hesaplama (fahrenheit getter’ında) gibi işlemler şeffaf bir şekilde yapılır.
İç saklama mekanizması (_celsius) dış dünyadan gizlenmiş olur (konvansiyonel olarak).
Bu, Python’da kapsüllemeyi sağlamanın en yaygın ve tavsiye edilen yoludur.

Bölüm 5: Sonuç: Python’da Kapsülleme ve Erişim Kontrolü
Kapsülleme, Nesne Yönelimli Programlamanın temel bir ilkesidir ve kodun daha güvenli, esnek ve yönetilebilir olmasını sağlar. Veri ve metotları birleştirirken, aynı zamanda iç uygulama detaylarını gizleyerek kontrollü bir arayüz sunmayı hedefler.

Python, diğer dillerden farklı olarak erişim kontrolü için katı anahtar kelimeler yerine konvansiyonlara dayanır:

Public: Varsayılan, dış arayüz.
Protected (): İç kullanım veya alt sınıflar için bir uyarı niteliğinde konvansiyon.
Private (_): Kalıtımda isim çakışmasını önlemek için isim karmaşası (name mangling) uygulayan bir mekanizma, gerçek gizlilik değil.
Bu konvansiyonlar, geliştiriciler arasında bir iletişim aracı görevi görür ve kodun niyetini anlamaya yardımcı olur. Ancak teknik olarak erişimi engellemezler.

Niteliklere erişimi gerçekten kontrol etmek, doğrulama eklemek veya hesaplama yapmak gerektiğinde, Python’un property mekanizması (@property, @setter, @deleter dekoratörleri ile) en temiz ve "Pythonic" çözümü sunar. Property'ler, basit nitelik erişimi sözdizimini korurken arka planda getter/setter mantığının çalışmasını sağlayarak kapsüllemeyi etkili bir şekilde uygular.

Sonuç olarak, Python’da kapsülleme, katı kurallardan çok geliştiricinin disiplinine ve konvansiyonlara uymasına dayanır. Erişim belirleyici konvansiyonlarını anlamak ve property’leri doğru şekilde kullanmak, Python’da sağlam, esnek ve bakımı kolay nesne yönelimli kodlar yazmanın anahtarıdır.

Abdulkadir Güngör - Kişisel WebSite
Abdulkadir Güngör - Kişisel WebSite
Abdulkadir Güngör - Özgeçmiş
Github
Github
Linkedin