Python'da Bellek Dostu Sınıflar Nasıl Yazılır

Python'da bellek dostu sınıflar yazmak, farklı sistem kısıtları altında da iyi performans gösteren sağlam uygulamalar geliştirmek için gereklidir. Verimli bellek kullanımı, daha az kaynak tüketerek uygulamanın çalışma süresini hızlandırır ve ölçeklenebilirliği artırır; bu da özellikle bellek kapasitesinin sınırlı olduğu ortamlarda önemlidir.

Bu yazıda Python'da bellek yönetiminin temellerini tanıtacak ve bellek dostu sınıflar yazmak için farklı pratik teknikler sunacağım. İster karmaşık sistemler ister basit betikler geliştiriyor olun, bu içgörüler daha temiz ve daha verimli Python kodu yazmanıza yardımcı olacak.

Python'da Bellek Yönetiminin Temelleri

Python'un bellek yönetim sistemi sofistike bir yapıya sahiptir ve bellek işlemlerinin karmaşıklığını üstlenerek geliştirmeyi basitleştirmek üzere tasarlanmıştır. Bu sistem, Python uygulamalarının verimli çalışmasını sağlamak için gereklidir.

Python belleği nasıl yönetir

Python'un bellek yönetiminin merkezinde özel bir yığın (private heap) bulunur. Tüm Python nesneleri ve veri yapıları burada saklanır. Programcılar bu özel yığına doğrudan erişemez; bunun yerine Python'un bellek yönetim sistemi aracılığıyla nesnelerle etkileşime girerler.

Bellek yönetim sistemi şunları kullanır:

• Bellek ayırıcılar: Python, bellek bloklarının ayrılmasını ve serbest bırakılmasını yöneten yerleşik bir bellek ayırıcısı kullanır. Bu ayırıcı, daha önce tahsis edilmiş bellek bloklarını yeniden kullanarak gelecekteki tahsisleri hızlandıran "free list" mekanizmasıyla küçük nesneler için optimize edilmiştir. Listeler ve sözlükler gibi daha karmaşık nesneler için Python, boyut değişimlerini yönetmek üzere dinamik bellek tahsisi uygular.
• Bellek havuzları: Python, ek yükü ve parçalanmayı en aza indirmek için belleği nesne boyutuna göre havuzlara ayırır. Bu, benzer boyuttaki nesneleri gruplandırarak belleğin daha verimli yönetilmesine yardımcı olur.

Belleğin serbest bırakılması ve çöp toplama

Python çöp toplamayı iki yönlü bir yaklaşımla gerçekleştirir:

• Başvuru sayımı: Bu birincil yöntemdir; Python her nesnenin referanslarını izler. Bir nesnenin referans sayısı sıfıra düştüğünde, yani artık ona referans kalmadığında, bellek ayırıcısı bellek alanını anında serbest bırakır.
• Döngüsel çöp toplayıcı: Python, yalnızca başvuru sayımıyla yönetilemeyen döngüsel referansları ele almak için bir döngüsel çöp toplayıcı içerir. Bu toplayıcı, birbirine referans veren ancak programın başka yerlerinde artık kullanılmayan nesne gruplarını periyodik olarak tespit eder ve temizler.

Bellek kullanımını profilleme ve iyileştirme

Bellek kullanımını anlamak ve optimize etmek, uygulama performansını korumak için kritiktir. 

Python, standart hata ayıklamanın ötesinde içgörüler sunan ve geliştiricilerin bellek verimsizliklerini tespit edip gidermesine yardımcı olan çeşitli bellek profilleme araçları sunar:

• pympler: Bellek kullanımını izleyen ve nesne uzayını analiz eden kapsamlı bir araçtır; ayrıntılı bellek incelemeleri için uygundur.
• memory_profiler: Satır bazında bellek kullanım analizi sunar; böylece geliştiriciler bellek tüketiminin yüksek olduğu satırları tam olarak belirleyebilir.
• tracemalloc: Python standart kütüphanesine entegredir; bellek tahsislerini izlemeye ve sızıntıları tespit etmeye yardımcı olur, bellek tahsis eğilimlerine dair içgörüler sağlar.

Bu eğitimde pympler kütüphanesini kullanacağız; terminalinizde pip paket yöneticisiyle kurabilirsiniz:

pip install pymplerAltyapı:

Bellek profilleme hakkında daha fazlasını şu eğitimimizden okuyabilirsiniz — Python'da Bellek Profillemeye Giriş. 

Python'da Bellek Dostu Sınıflar Yazma Teknikleri

Artık Python'da bellek yönetiminin temellerini anladığımıza göre, bellek dostu sınıflar yazmak için bazı ileri teknikleri inceleyelim.

1. Sınıf yapısını __slots__ ile optimize etme

Python'da her sınıf örneğinin örnek değişkenlerini saklamak için __dict__ adlı bir sözlüğü vardır. Bu, yeni değişkenlerin dinamik olarak atanmasına olanak tanısa da özellikle çok sayıda sınıf örneği oluşturulduğunda önemli bir bellek ek yüküne yol açabilir. __slots__ tanımlayarak Python'a sabit bir öznitelik kümesi için alan ayırmasını söylersiniz ve dinamik sözlüğe duyulan ihtiyaç ortadan kalkar.

__slots__ kullanmanın iki temel faydası vardır:

• Azaltılmış bellek kullanımı: Örnek sözlüğü olmadan her nesne daha az bellek kullanır. Milyonlarca sınıf örneğine ihtiyaç duyulduğunda, örnek başına tasarruf çarpan etkisi yaratır.
• Daha hızlı öznitelik erişimi: Özniteliklere __slots__ üzerinden erişmek, sözlük üzerinden erişmekten daha hızlıdır; çünkü doğrudan öznitelik araması yapar ve sözlük erişimindeki karma tablo işlemlerini atlar.

Pratik örnek: İki boyutlu uzayda noktalar

İki boyutlu uzayda bir noktayı temsil eden basit bir sınıfı ele alalım:

class PointWithoutSlots:
   def __init__(self, x, y):
       self.x = x
       self.y = y

class PointWithSlots:
   __slots__ = ('x', 'y')
   def __init__(self, x, y):
       self.x = x
       self.y = yAltyapı:

PointWithoutSlots sınıfında her örneğin __dict__ sözlüğü x ve y özniteliklerini saklar; buna karşılık PointWithSlots sınıfında bu sözlük bulunmaz; bu da örnek başına daha az bellek kullanımına yol açar.

Bellek kullanımındaki farkı göstermek için bin tane nokta oluşturalım ve toplam belleği pympler paketiyle ölçelim:

from pympler import asizeof

points_without_slots = [PointWithoutSlots(i, i) for i in range(1000)]
points_with_slots = [PointWithSlots(i, i) for i in range(1000)]

print("Total memory (without __slots__):", asizeof.asizeof(points_without_slots))
print("Total memory (with __slots__):", asizeof.asizeof(points_with_slots))Altyapı:

Gördüğümüz çıktı şöyledir:

Yuvalarla birlikte ve yuvalar olmadan bellek karşılaştırması

Çıktı genellikle, PointWithSlots örneğinin PointWithoutSlots'tan daha az bellek tükettiğini gösterir; bu da örnek başına bellek ek yükünü azaltmada __slots__'un etkinliğini ortaya koyar.

__slots__ kullanmanın sınırlamaları

__slots__ bellek optimizasyonu için faydalı olsa da bazı sınırlamalarla birlikte gelir:

• Esneklik eksikliği: __slots__ tanımlandığında, örneklere dinamik olarak yeni öznitelikler ekleyemezsiniz.
• Kalıtım karmaşıklıkları: __slots__ tanımlı bir sınıf kalıtıldığında, alt sınıfın da bellek optimizasyonundan yararlanmaya devam etmek için __slots__ tanımlaması gerekir; bu da sınıf tasarımını karmaşıklaştırabilir. 

Bu sınırlamalara rağmen, __slots__ kullanımı, özellikle sıkı bellek kısıtlarının bulunduğu veya örnek sayısının çok yüksek olduğu ortamlarda Python uygulamalarında bellek kullanımını optimize etmeyi hedefleyen geliştiriciler için güçlü bir araçtır.

2. Bellek dostu tasarım kalıplarını uygulama

Bellek dostu tasarım kalıpları, Python uygulamalarında bellek kullanımını ve yönetimini optimize etmeye yardımcı olan mimari çözümlerdir. 

Sınıf tasarımında bellek verimliliği için özellikle etkili iki kalıp Flyweight ve Singleton'dır. Çok sayıda sınıf örneği veya paylaşılan veriler içeren senaryolarda doğru şekilde uygulandıklarında, bu kalıplar bellek tüketimini ciddi ölçüde azaltabilir.

Flyweight tasarım kalıbı

Flyweight tasarım kalıbı, tüm verileri her nesnede tutmak yerine ortak durumun bir kısmını birden çok nesne arasında paylaşarak toplam bellek ayak izini önemli ölçüde azaltır.

Her bir dairenin bir renk, yarıçap ve koordinatlara sahip olduğu bir çizim uygulamasında grafik daireleri temsil eden bir sınıfı düşünün. Flyweight kalıbını kullanarak, birçok daire tarafından paylaşılması muhtemel olan renk ve yarıçap, paylaşılan nesnelerde saklanabilir:

class Circle:
   # Flyweight object
   def __init__(self, color):
       self.color = color
   def draw(self, radius, x, y):
       print(f"Drawing a {self.color} circle with radius {radius} at ({x},{y})")

class CircleFactory:
   # Factory to manage Flyweight objects
   _circles = {}
   @classmethod
   def get_circle(cls, color):
       if not cls._circles.get(color):
           cls._circles[color] = Circle(color)
       return cls._circles[color]Altyapı:

Bu örnekte, birden çok daire örneği, renge bağlı olarak CircleFactory'den alınan aynı Circle nesnesini paylaşır; böylece renk verisi bir kez saklanarak bellek daha verimli kullanılır.

Belleğin nasıl tasarruf edildiğini görmek için bu sınıfı kullanarak örnekler oluşturalım.

import sys

factory = CircleFactory()
circle1 = factory.get_circle("Red")
circle2 = factory.get_circle("Red")
circle3 = factory.get_circle("Blue")

print("Memory address of circle1:", id(circle1))
print("Memory address of circle2:", id(circle2))
print("Memory address of circle3:", id(circle3))
print ("-----------------------------")
print("Memory used by circle1:", sys.getsizeof(circle1))
print("Memory used by circle2:", sys.getsizeof(circle2))
print("Memory used by circle3:", sys.getsizeof(circle3))Altyapı:

Gördüğümüz çıktı şöyledir:

Flyweight tasarım kalıbı için bellek kullanımı

Şunu görebiliriz: circle1 ve circle2 aynı bellek adresine sahiptir; bu da gerçekten aynı nesne oldukları ("Red" rengi için aynı örneği paylaştıkları) anlamına gelir. circle3 farklı bir renkteki ("Blue") daireyi temsil ettiğinden bellek adresi de farklıdır.

circle1 ve circle2'nin aynı örnek olması, CircleFactory'nin bu ikisi arasında Circle örneğini başarıyla paylaştığını gösterir. Bellek verimliliği tam da burada devreye girer: Uygulamanızda Flyweight kalıbını kullanarak bin adet kırmızı daire olsaydı, hepsi renk için tek bir Circle örneğini paylaşırdı; her birinin ayrı bir Circle örneği olmasına gerek kalmazdı; böylece önemli miktarda bellek tasarrufu sağlanırdı.

Singleton tasarım kalıbı

Singleton kalıbı, bir sınıfın yalnızca bir örneğe sahip olmasını ve bu örneğe küresel bir erişim noktası sağlanmasını garanti eder. Bu kalıp, uygulama genelinde yapılandırmaların veya paylaşılan kaynakların yönetimi için kullanışlıdır; paylaşılan kaynakları veya yapılandırma verilerini birden fazla yerde çoğaltmayarak bellek ek yükünü azaltır.

Database sınıfını ele alalım:

class Database:
   _instance = None
   def __new__(cls):
       if cls._instance is None:
           cls._instance = super(Database, cls).__new__(cls)
           # Initialize any attributes of the instance here
       return cls._instance
   def connect(self):
       # method to simulate database connection
       return "Connection established"Altyapı:

Bu uygulamada, Database kaç kez örneklenirse örneklensin, tek bir paylaşılan örneğin kullanılmasını sağlar; böylece birden fazla özdeş nesneden kaçınılarak bellek korunur.

Bunu aşağıdaki kodla kontrol edebiliriz:

db1 = Database()
print(db1.connect())
db2 = Database()
print(db1 is db2) Altyapı:

Çıktı aşağıdaki gibidir:

Singleton tasarım kalıbı için örnek oluşturma

"True" çıktısı, db1 ve db2 değişkenlerinin aynı örneğe referans verdiğini gösterir.

Bu kalıplar, düşünceli bir tasarımın bellek verimliliğini nasıl önemli ölçüde iyileştirebileceğini gösterir. Uygun tasarım kalıplarını seçip uygulayarak geliştiriciler Python uygulamalarını daha yalın ve daha performanslı hale getirebilir.

3. Sınıflarda yerleşik veri türlerini kullanma

Uygun Python yerleşik veri türünü seçmek, bellek verimliliğini önemli ölçüde etkileyebilir. Yerleşik türler, Python yorumlayıcısındaki içsel uygulamaları sayesinde performans ve bellek kullanımı için optimize edilmiştir. 

Örneğin, kendilerine özgü özellikleri nedeniyle, bazı kullanım durumlarında demetler (tuple) ve kümeler (set), listeler ve sözlüklere kıyasla daha bellek dostu seçenekler olabilir.

Demetler genel olarak sabit boyutlu oldukları ve oluşturulduktan sonra değiştirilemedikleri için listelerden daha az bellek kullanır; bu da Python'un dahili mekanizmalarının depolamayı optimize etmesine olanak tanır. Oluşturulduktan sonra değiştirilmesine gerek olmayan verileri işlemek üzere tasarlanmış sınıflar için demetler mükemmel bir seçimdir.

Pratik örnek: Çokgen sınıfları

Değerleri saklamak için sırasıyla demet ve liste kullanan iki basit Çokgen sınıfını düşünün:

class PolygonWithTuple:
   def __init__(self, points):
       self.points = tuple(points)  # Storing points as a tuple
   def display_points(self):
       return self.points

class PolygonWithList:
   def __init__(self, points):
       self.points = list(points)  # Storing points as a list
   def display_points(self):
       return self.pointsAltyapı:

Bellek kullanımını karşılaştırmak için her iki sınıfın örneklerini oluşturabiliriz:

from pympler import asizeof

points = [(1, 2), (3, 4), (5, 6), (7, 8)]

# Creating instances of each class
polygon_tuple = PolygonWithTuple(points)
polygon_list = PolygonWithList(points)

# Memory usage comparison using pympler
print("Total memory used by Polygon with Tuple:", asizeof.asizeof(polygon_tuple))
print("Total memory used by Polygon with List:", asizeof.asizeof(polygon_list))Altyapı:

Elde ettiğimiz çıktı şöyledir:

Demetler ve listeler için bellek karşılaştırması

Bu çıktı, demetin genellikle listeden daha az bellek kullandığını ve dolayısıyla PolygonWithTuple sınıfının, geometrik koordinatlar gibi sabit ve değişmez verileri saklamak için daha bellek dostu olduğunu gösterir.

4. Tembel değerlendirme için üreticilerden yararlanma

Python'da üreticiler (generator) özellikle büyük veri kümeleriyle çalışırken bellek yönetimi için güçlü bir araçtır.

Üreticiler, verileri her seferinde bir öğe olacak şekilde işler; böylece herhangi bir anda yalnızca gerekli olan kısım belleğe yüklenir. Bu tembel değerlendirme yöntemi, büyük hacimli verilerin işlendiği ancak aynı anda yalnızca küçük bir kısmının işlenmesine ihtiyaç duyulan uygulamalarda faydalıdır; böylece toplam bellek ayak izi azalır.

Pratik örnek: Büyük veri kümelerini işleme

Kullanıcı kayıtlarından oluşan büyük bir veri kümesini işlemesi gereken ve örneğin kullanıcıların ortalama yaşını hesaplayan bir uygulamayı düşünün. Tüm kayıtları bir listeye yüklemek (bu, önemli miktarda bellek tüketebilir) yerine, bir üretici her seferinde bir kaydı işleyebilir.

def process_records(file_name):
   """Generator that yields user ages from a file one at a time."""
   with open(file_name, 'r') as file:
       for line in file:
           user_data = line.strip().split(',')
           yield int(user_data[1]) 

def average_age(file_name):
   """Calculate the average age from user records."""
   total_age = 0
   count = 0
   for age in process_records(file_name):
       total_age += age
       count += 1
   return total_age / count if count else 0

print("Average Age:", average_age('user_data.csv'))Altyapı:

Bu örnekte, process_records() üretici fonksiyonu bir dosyayı satır satır okur, ilgili verileri tamsayıya çevirir ve yield eder. Bu, her seferinde yalnızca bir satırlık verinin bellekte tutulduğu anlamına gelir ve bellek kullanımını en aza indirir. average_age() fonksiyonu ise üreticiyi tüketir; toplam yaşı ve sayıyı biriktirir; böylece tüm veri kümesini aynı anda bellekte tutmaya hiç gerek kalmaz.

Dolayısıyla tembel değerlendirme yaklaşımını kullanarak bellek tasarrufu yapabilir ve uygulamaların duyarlılığını ve ölçeklenebilirliğini artırabiliriz.

5. Döngüsel referanslardan kaçınma

Döngüsel referanslar, iki veya daha fazla nesnenin birbirine referans vermesiyle oluşur. Bu durum, listeler, sözlükler gibi yapılarla ya da birbirine referans veren örneklerin bulunduğu daha karmaşık sınıf tanımlarıyla fark edilmeden meydana gelebilir ve bir döngü oluşturur.

Bellek yönetiminin temellerinde gördüğümüz gibi, Python döngüsel referansları tespit edip temizlemek için ek bir çöp toplayıcıya sahiptir. Ancak bu mekanizmaya güvenmek bellek kullanımının artmasına ve verimsizliklere yol açabilir:

• Gecikmeli temizlik: Döngüsel çöp toplayıcı sürekli değil, periyodik olarak çalışır. Bu da döngüsel referanslara dahil olan nesnelerin gereksiz yere bellek tüketerek ihtiyaç kalmadıktan hemen sonra geri kazanılmayabileceği anlamına gelir.
• Performans ek yükü: Döngüsel çöp toplayıcı, döngüsel referansları periyodik olarak kontrol edip temizlemek için ek kaynak gerektirir ve bu durum performansı etkileyebilir.

Pratik örnek: Ağaç veri yapısı

Her düğümün çocuklarına ve isteğe bağlı olarak ebeveynine referans tuttuğu ağaç benzeri bir veri yapısındaki tipik bir kullanım durumunu düşünün. Bu ebeveyn-çocuk bağlantısı, kolaylıkla döngüsel referanslar oluşturabilir.

class TreeNode:
   def __init__(self, value, parent=None):
       self.value = value
       self.parent = parent
       self.children = []
   def add_child(self, child):
       child.parent = self  # Set parent reference
       self.children.append(child)

root = TreeNode("root")
child = TreeNode("child1", root)
root.add_child(child)Altyapı:

Bu örnekte, root, children listesi aracılığıyla child'a referans verir ve child, parent özniteliği aracılığıyla root'a referans verir. Herhangi başka bir müdahale olmadan bu kurulum döngüsel referans oluşturabilir.

Döngüsel referanslardan kaçınmak için zayıf referanslar kullanma

Zayıf referanslar, tüm veri yapısını yeniden tasarlamadan döngüsel referansları kırmanın veya önlemenin etkili bir yoludur. 

Python'un weakref modülü, bir nesnenin referans sayısını artırmayan bir referans oluşturmayı sağlar. Bu zayıf referans, referans verilen nesnenin çöp toplayıcı tarafından toplanmasını engellemez; böylece döngüsel referanslarla ilişkili bellek sızıntıları önlenir.

Önceki sınıfı zayıf referanslar kullanacak şekilde şu şekilde değiştirebiliriz:

import weakref

class TreeNode:
   def __init__(self, value, parent=None):
       self.value = value
       self.parent = weakref.ref(parent) if parent else None
       self.children = []
   def add_child(self, child):
       child.parent = weakref.ref(self)
       self.children.append(child)
root = TreeNode("root")
child = TreeNode("child1", root)
root.add_child(child)Altyapı:

Bu sınıfta, parent özniteliği artık ebeveyn düğüme zayıf bir referanstır. Bu, ebeveyn düğümüne başka güçlü referanslar olmadığı sürece, çocuk düğüm hâlâ mevcut olsa bile ebeveyn düğümünün çöp toplayıcı tarafından toplanabileceği anlamına gelir. 

Bu yaklaşım, bu tür yapılarda döngüsel referanslarla tipik olarak ilişkilendirilen bellek sızıntısı sorunlarını etkili bir şekilde önler.

Sonuç

Bu yazıda Python'da bellek yönetiminin temellerini tanıttık ve pratik örnekler ile bellek karşılaştırmaları eşliğinde, bellek dostu sınıflar yazmaya yönelik beş ileri tekniği sunduk. Bu teknikleri ve en iyi uygulamaları projelerinize dahil ederek ölçeklenebilir ve verimli uygulamalar geliştirmenizi umuyoruz. 

Şunlara göz atmanızı öneririz: Python Programming öğrenme yolu; burada yazılım mühendisliği ilkeleri ve nesne yönelimli programlama ve verimli Python kodu yazma konuları yer alır.