Python में मेमोरी-कुशल क्लासेज़ कैसे लिखें

Python में मेमोरी-कुशल क्लासेज़ लिखना ऐसी मज़बूत एप्लिकेशन विकसित करने के लिए आवश्यक है जो विभिन्न सिस्टम बाधाओं में भी अच्छा प्रदर्शन करें। कुशल मेमोरी उपयोग एप्लिकेशन रनटाइम को तेज़ करता है और कम संसाधन खपत के साथ स्केलेबिलिटी बढ़ाता है, जो विशेष रूप से सीमित मेमोरी वाले वातावरण में महत्वपूर्ण होता है।

इस लेख में, मैं आपको Python में मेमोरी प्रबंधन की बुनियादी बातें बताऊंगा और मेमोरी-कुशल क्लासेज़ लिखने की अलग-अलग व्यावहारिक तकनीकें प्रस्तुत करूंगा। चाहे आप जटिल सिस्टम बना रहे हों या साधारण स्क्रिप्ट, ये जानकारियाँ आपको और अधिक साफ़-सुथरा और कुशल Python कोड लिखने में मदद करेंगी।

Python में मेमोरी प्रबंधन की बुनियादी बातें

Python का मेमोरी प्रबंधन सिस्टम परिष्कृत है और मेमोरी ऑपरेशनों की जटिलता को संभालकर विकास को सरल बनाने के लिए डिज़ाइन किया गया है। यह सिस्टम इस बात को सुनिश्चित करने के लिए आवश्यक है कि Python एप्लिकेशन कुशलता से चलें।

Python मेमोरी को कैसे मैनेज करता है

Python के मेमोरी प्रबंधन के केंद्र में प्राइवेट हीप होता है। यहीं पर सभी Python ऑब्जेक्ट और डेटा स्ट्रक्चर संग्रहीत होते हैं। प्रोग्रामर सीधे इस प्राइवेट हीप तक पहुँच नहीं सकते; वे Python के मेमोरी प्रबंधन सिस्टम के माध्यम से ऑब्जेक्ट के साथ इंटरैक्ट करते हैं।

मेमोरी प्रबंधन सिस्टम उपयोग करता है:

• मेमोरी अलोकेटर: Python एक इन-बिल्ट मेमोरी अलोकेटर का उपयोग करता है जो मेमोरी ब्लॉकों के आवंटन और डीलोकेशन को प्रबंधित करता है। यह अलोकेटर छोटे ऑब्जेक्ट के लिए “फ्री लिस्ट्स” का उपयोग करके ऑप्टिमाइज़ करता है, जो पहले से आवंटित मेमोरी ब्लॉकों को पुन: उपयोग करके भविष्य के आवंटनों को तेज़ करता है। अधिक जटिल ऑब्जेक्ट, जैसे लिस्ट और डिक्शनरी, के लिए Python उनके आकार के बदलावों को संभालने हेतु डायनेमिक मेमोरी अलोकेशन का उपयोग करता है।
• मेमोरी पूल: Python ओवरहेड और फ्रैग्मेंटेशन को कम करने के लिए ऑब्जेक्ट आकार के अनुसार मेमोरी को पूल्स में व्यवस्थित करता है। इससे समान आकार के ऑब्जेक्ट को समूहित कर मेमोरी का अधिक कुशल प्रबंधन होता है।

मेमोरी डीलोकेशन और गारबेज कलेक्शन

Python गारबेज कलेक्शन के लिए द्वि-आयामी दृष्टिकोण अपनाता है:

• रेफ़रेंस काउंटिंग: यह प्राथमिक विधि है जिसमें Python प्रत्येक ऑब्जेक्ट के रेफ़रेंस को ट्रैक करता है। जब किसी ऑब्जेक्ट का रेफ़रेंस काउंट शून्य पर आ जाता है, यानी उस पर कोई रेफ़रेंस नहीं रहता, तो मेमोरी अलोकेटर उसकी मेमोरी तुरंत मुक्त कर देता है।
• साइक्लिक गारबेज कलेक्टर: परस्पर रेफ़रेंस (सर्कुलर रेफ़रेंस) को संभालने के लिए Python में एक साइक्लिक गारबेज कलेक्टर शामिल है, जिसे केवल रेफ़रेंस काउंटिंग से संभाला नहीं जा सकता। यह कलेक्टर समय-समय पर ऐसे ऑब्जेक्ट समूहों की पहचान कर उन्हें साफ करता है जो एक-दूसरे को रेफ़रेंस करते हैं लेकिन प्रोग्राम में अन्यत्र उपयोग में नहीं हैं।

मेमोरी उपयोग का प्रोफाइलिंग और ऑप्टिमाइज़ेशन

मेमोरी उपयोग को समझना और उसका अनुकूलन करना एप्लिकेशन प्रदर्शन बनाए रखने के लिए अत्यंत महत्वपूर्ण है। 

Python मेमोरी प्रोफाइलिंग के कई टूल प्रदान करता है, जो मानक डीबगिंग से आगे की अंतर्दृष्टि देते हैं और डेवलपर्स को मेमोरी अक्षमताओं की पहचान व समाधान में मदद करते हैं:

• pympler: एक व्यापक टूल जो मेमोरी उपयोग को ट्रैक करता है और ऑब्जेक्ट स्पेस का विश्लेषण करता है, विस्तृत मेमोरी जाँच के लिए उपयुक्त।
• memory_profiler: लाइन-दर-लाइन मेमोरी उपयोग का विश्लेषण प्रदान करता है, जिससे डेवलपर्स उन सटीक लाइनों की पहचान कर सकते हैं जहाँ मेमोरी खपत अधिक है।
• tracemalloc: Python स्टैंडर्ड लाइब्रेरी में एकीकृत, tracemalloc मेमोरी अलोकेशन को ट्रैक करने और लीक्स का पता लगाने में मदद करता है, तथा अलोकेशन ट्रेंड्स पर अंतर्दृष्टि देता है।

हम इस ट्यूटोरियल में pympler लाइब्रेरी का उपयोग करेंगे, और आप इसे टर्मिनल पर pip पैकेज मैनेजर से इंस्टॉल कर सकते हैं:

pip install pymplerसंचालित द्वारा

मेमोरी प्रोफाइलिंग के बारे में और पढ़ें हमारे ट्यूटोरियल — Python में मेमोरी प्रोफाइलिंग का परिचय। 

Python में मेमोरी-कुशल क्लासेज़ लिखने की तकनीकें

अब जब हमने Python में मेमोरी प्रबंधन की बुनियाद समझ ली है, तो मेमोरी-कुशल क्लासेज़ लिखने की कुछ उन्नत तकनीकों पर नज़र डालते हैं।

1. __slots__ के साथ क्लास संरचना का अनुकूलन

Python में, प्रत्येक क्लास इंस्टेंस में इंस्टेंस वेरिएबल्स रखने के लिए __dict__ नामक एक डिक्शनरी होती है। यद्यपि यह नए वेरिएबल्स के डायनेमिक असाइनमेंट की अनुमति देती है, परंतु बहुत सारे क्लास इंस्टेंस बनाने पर यह उल्लेखनीय मेमोरी ओवरहेड का कारण बन सकती है। __slots__ परिभाषित करके, आप Python को एक निश्चित सेट के एट्रिब्यूट्स के लिए जगह आवंटित करने को कहते हैं, जिससे डायनेमिक डिक्शनरी की आवश्यकता समाप्त हो जाती है।

__slots__ के दो मुख्य फायदे हैं:

• मेमोरी उपयोग में कमी: इंस्टेंस डिक्शनरी न होने पर प्रत्येक ऑब्जेक्ट कम मेमोरी उपयोग करता है। जब लाखों क्लास इंस्टेंस की ज़रूरत हो, तो प्रति इंस्टेंस होने वाली यह बचत गुणा होकर महत्वपूर्ण हो जाती है।
• एट्रिब्यूट एक्सेस की गति में वृद्धि: __slots__ के माध्यम से एट्रिब्यूट्स तक पहुँचना डिक्शनरी के मुकाबले तेज़ होता है, क्योंकि यह सीधे एट्रिब्यूट लुकअप करता है और डिक्शनरी एक्सेस में शामिल हैश-टेबल ऑपरेशन को स्किप कर देता है।

व्यावहारिक उदाहरण: द्वि-आयामी स्पेस में बिंदु

एक साधारण क्लास पर विचार करें जो द्वि-आयामी स्पेस में एक बिंदु का प्रतिनिधित्व करती है:

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 = yसंचालित द्वारा

PointWithoutSlots क्लास में, प्रत्येक इंस्टेंस में __dict__ होता है जिसमें x और y एट्रिब्यूट्स स्टोर होते हैं, जबकि PointWithSlots क्लास में ऐसा नहीं है, जिससे प्रति इंस्टेंस कम मेमोरी उपयोग होती है।

मेमोरी उपयोग में अंतर दिखाने के लिए, आइए हज़ार पॉइंट बनाते हैं और pympler पैकेज का उपयोग करके कुल मेमोरी मापते हैं:

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))संचालित द्वारा

जो आउटपुट हमें दिखाई देता है:

स्लॉट्स के साथ और बिना मेमोरी तुलना

आम तौर पर आउटपुट दिखाता है कि PointWithSlots के इंस्टेंस, PointWithoutSlots की तुलना में कम मेमोरी लेते हैं, जो प्रति-इंस्टेंस मेमोरी ओवरहेड को घटाने में __slots__ की प्रभावशीलता दर्शाता है।

__slots__ उपयोग की सीमाएँ

हालाँकि __slots__ मेमोरी ऑप्टिमाइज़ेशन के लिए उपयोगी हैं, इनके साथ कुछ सीमाएँ आती हैं:

• अनम्यता: एक बार __slots__ परिभाषित होने के बाद, आप इंस्टेंस में नए एट्रिब्यूट्स डायनेमिक रूप से नहीं जोड़ सकते।
• इनहेरिटेंस की जटिलताएँ: यदि किसी क्लास में __slots__ हैं और वह इनहेरिट होती है, तो सबक्लास को भी मेमोरी ऑप्टिमाइज़ेशन का लाभ बनाए रखने के लिए __slots__ परिभाषित करने होंगे, जो क्लास डिज़ाइन को जटिल बना सकता है। 

इन सीमाओं के बावजूद, __slots__ का उपयोग उन डेवलपर्स के लिए एक शक्तिशाली टूल है जो Python एप्लिकेशन में मेमोरी उपयोग का अनुकूलन करना चाहते हैं—विशेषकर सख्त मेमोरी बाधाओं वाले वातावरण में या जहाँ इंस्टेंस की संख्या बहुत अधिक हो।

2. मेमोरी-कुशल डिज़ाइन पैटर्न लागू करना

मेमोरी-कुशल डिज़ाइन पैटर्न ऐसे आर्किटेक्चरल समाधान हैं जो Python एप्लिकेशन में मेमोरी उपयोग और प्रबंधन को अनुकूलित करने में मदद करते हैं। 

क्लास डिज़ाइन में मेमोरी दक्षता के लिए दो विशेष रूप से प्रभावी पैटर्न हैं: फ्लाइवेट और सिंगलटन। जब इन्हें उन परिदृश्यों में सही ढंग से लागू किया जाता है जिनमें बड़ी संख्या में क्लास इंस्टेंस या साझा डेटा शामिल होते हैं, तो ये पैटर्न मेमोरी खपत को काफी हद तक घटा सकते हैं।

फ्लाइवेट डिज़ाइन पैटर्न

फ्लाइवेट डिज़ाइन पैटर्न में प्रत्येक ऑब्जेक्ट में सभी डेटा रखने के बजाय कई ऑब्जेक्ट के बीच स्टेट के सामान्य हिस्सों को साझा किया जाता है, जिससे कुल मेमोरी फ़ुटप्रिंट में उल्लेखनीय कमी आती है।

एक ड्रॉइंग एप्लिकेशन में ग्राफिकल सर्किल दर्शाने वाली क्लास पर विचार करें, जहाँ प्रत्येक सर्किल का रंग, त्रिज्या और कॉर्डिनेट्स होते हैं। फ्लाइवेट पैटर्न का उपयोग करते हुए, रंग और त्रिज्या, जो कई सर्किल में सामान्य हो सकते हैं, साझा ऑब्जेक्ट में संग्रहीत किए जा सकते हैं:

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]संचालित द्वारा

इस उदाहरण में, कई सर्किल इंस्टेंस रंग के आधार पर CircleFactory के Circle ऑब्जेक्ट को साझा करते हैं, जिससे रंग डेटा एक बार ही संग्रहीत होकर मेमोरी का अधिक कुशल उपयोग सुनिश्चित होता है।

आइए इस क्लास का उपयोग करके इंस्टेंस बनाते हैं और समझते हैं कि मेमोरी कैसे बचती है।

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))संचालित द्वारा

जो आउटपुट हमें दिखाई देता है:

फ्लाइवेट डिज़ाइन पैटर्न के लिए मेमोरी उपयोग

हम देखते हैं कि circle1 और circle2 का मेमोरी पता समान है, यानी वे वास्तव में वही एक ऑब्जेक्ट हैं (रंग “Red” के लिए एक ही इंस्टेंस साझा करते हुए)। circle3 का मेमोरी पता अलग है क्योंकि यह अलग रंग (“Blue”) वाले सर्किल का प्रतिनिधित्व करता है।

circle1 और circle2 का एक ही इंस्टेंस होना दर्शाता है कि CircleFactory ने इन दोनों के बीच Circle इंस्टेंस को सफलतापूर्वक साझा किया। यही वह जगह है जहाँ मेमोरी दक्षता आती है: यदि आपके एप्लिकेशन में फ्लाइवेट पैटर्न का उपयोग करते हुए हज़ार लाल सर्किल हों, तो वे सभी रंग के लिए एक ही Circle इंस्टेंस साझा करेंगे, बजाय इसके कि प्रत्येक के पास अपना अलग Circle इंस्टेंस हो—इस प्रकार मेमोरी में उल्लेखनीय बचत होगी।

सिंगलटन डिज़ाइन पैटर्न

सिंगलटन पैटर्न यह सुनिश्चित करता है कि किसी क्लास का केवल एक ही इंस्टेंस हो और उसी तक वैश्विक पहुँच उपलब्ध हो। यह पैटर्न कॉन्फ़िगरेशन या एप्लिकेशन-व्यापी साझा संसाधनों को मैनेज करने में उपयोगी है, क्योंकि यह साझा संसाधन या कॉन्फ़िगरेशन डेटा की कई जगहों पर नकल से बचकर मेमोरी ओवरहेड घटाता है।

इस Database क्लास पर विचार करें:

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"संचालित द्वारा

इस इम्प्लीमेंटेशन में, Database यह सुनिश्चित करता है कि चाहे इसे कितनी भी बार इंस्टैंशिएट किया जाए, केवल एक ही साझा इंस्टेंस का उपयोग हो—इस प्रकार एक जैसे कई ऑब्जेक्ट बनने से बचकर मेमोरी की बचत होती है।

इसे हम निम्न कोड से जाँच सकते हैं:

db1 = Database()
print(db1.connect())
db2 = Database()
print(db1 is db2) संचालित द्वारा

आउटपुट इस प्रकार है:

सिंगलटन डिज़ाइन पैटर्न के लिए इंस्टेंस निर्माण

“True” का आउटपुट दर्शाता है कि db1 और db2 वेरिएबल एक ही इंस्टेंस को संदर्भित करते हैं।

ये पैटर्न दिखाते हैं कि सोच-समझकर किया गया डिज़ाइन मेमोरी दक्षता को कितना बढ़ा सकता है। उपयुक्त डिज़ाइन पैटर्न चुनकर और उन्हें लागू करके, डेवलपर्स अपने Python एप्लिकेशन को अधिक हल्का और प्रदर्शनकारी बना सकते हैं।

3. क्लासेज़ में बिल्ट-इन डेटा टाइप्स का उपयोग

उपयुक्त Python के बिल्ट-इन डेटा टाइप चुनना मेमोरी दक्षता पर काफ़ी असर डाल सकता है। बिल्ट-इन टाइप्स को Python इंटरप्रेटर के आंतरिक इम्प्लीमेंटेशन के कारण प्रदर्शन और मेमोरी उपयोग के लिए ऑप्टिमाइज़ किया गया है। 

उदाहरण के लिए, अपनी खास विशेषताओं के कारण कुछ उपयोग-प्रसंगों में ट्यूपल और सेट, लिस्ट और डिक्शनरी की तुलना में अधिक मेमोरी-कुशल विकल्प हो सकते हैं।

ट्यूपल सामान्यतः लिस्ट से कम मेमोरी लेते हैं क्योंकि उनका आकार तय होता है और बनने के बाद उन्हें बदला नहीं जा सकता। इससे Python के आंतरिक तंत्र उनके स्टोरेज को बेहतर ढंग से ऑप्टिमाइज़ कर पाते हैं। ऐसी क्लासेज़ के लिए जो निर्माण के बाद डेटा में बदलाव नहीं करतीं, ट्यूपल उत्तम विकल्प हैं।

व्यावहारिक उदाहरण: पॉलिगॉन क्लासेज़

दो साधारण पॉलिगॉन क्लासेज़ पर विचार करें जो क्रमशः ट्यूपल और लिस्ट का उपयोग कर मान संग्रहीत करती हैं:

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.pointsसंचालित द्वारा

हम दोनों क्लासेज़ के इंस्टेंस बनाकर मेमोरी उपयोग की तुलना कर सकते हैं:

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))संचालित द्वारा

हमें जो आउटपुट मिलता है:

ट्यूपल और लिस्ट के लिए मेमोरी तुलना

यह आउटपुट दिखाता है कि ट्यूपल आमतौर पर लिस्ट से कम मेमोरी लेते हैं, जिससे स्थिर, अपरिवर्तनीय डेटा जैसे ज्यामितीय कॉर्डिनेट्स को संग्रहीत करने के लिए PolygonWithTuple क्लास अधिक मेमोरी-कुशल सिद्ध होती है।

4. लेज़ी इवैल्यूएशन के लिए जेनरेटर का लाभ उठाना

Python में जेनरेटर बड़े डेटासेट के साथ काम करते समय मेमोरी को प्रभावी ढंग से मैनेज करने का एक शक्तिशाली टूल हैं।

जेनरेटर डेटा को एक समय में एक आइटम के रूप में प्रोसेस करने देते हैं, जिससे किसी भी क्षण केवल आवश्यक डेटा ही मेमोरी में लोड होता है। लेज़ी इवैल्यूएशन की यह विधि उन एप्लिकेशन में लाभदायक है जहाँ बड़े पैमाने पर डेटा संभाला जाता है, परंतु एक समय में केवल थोड़ा-सा डेटा ही प्रोसेस करना होता है—इस प्रकार कुल मेमोरी फ़ुटप्रिंट घटता है।

व्यावहारिक उदाहरण: बड़े डेटासेट प्रोसेस करना

ऐसी एप्लिकेशन पर विचार करें जिसे उपयोगकर्ता रिकॉर्ड्स के बड़े डेटासेट को प्रोसेस करना है, जैसे उपयोगकर्ताओं की औसत आयु निकालना। सभी रिकॉर्ड्स को लिस्ट में लोड करने (जो काफी मेमोरी ले सकता है) के बजाय, जेनरेटर एक समय में एक रिकॉर्ड प्रोसेस कर सकता है।

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'))संचालित द्वारा

इस उदाहरण में, process_records() जेनरेटर फ़ंक्शन फ़ाइल को एक-एक लाइन करके पढ़ता है, प्रासंगिक डेटा को पूर्णांक में बदलता है और उसे यील्ड करता है। इसका अर्थ है कि किसी भी समय मेमोरी में केवल एक लाइन का डेटा रहता है, जिससे मेमोरी उपयोग न्यूनतम होता है। average_age() फ़ंक्शन जेनरेटर को कंज़्यूम करता है और बिना पूरे डेटासेट को एक साथ मेमोरी में रखे, कुल आयु और काउंट जोड़ता जाता है।

इस तरह, लेज़ी इवैल्यूएशन दृष्टिकोण अपनाकर हम मेमोरी बचा सकते हैं और एप्लिकेशन की प्रतिसाद-क्षमता व स्केलेबिलिटी बढ़ा सकते हैं।

5. सर्कुलर रेफ़रेंस से बचना

सर्कुलर रेफ़रेंस तब होते हैं जब दो या अधिक ऑब्जेक्ट एक-दूसरे को रेफ़रेंस करते हैं। यह सूचियों, डिक्शनरी या और अधिक जटिल क्लास परिभाषाओं जैसे ढाँचों में सूक्ष्म रूप से हो सकता है, जहाँ इंस्टेंस एक-दूसरे के रेफ़रेंस रखते हैं और एक लूप बन जाता है।

जैसा कि हमने मेमोरी प्रबंधन की बुनियादी बातों में देखा, Python में सर्कुलर रेफ़रेंस का पता लगाने और उन्हें साफ़ करने के लिए एक अतिरिक्त गारबेज कलेक्टर है। फिर भी, इस तंत्र पर निर्भर रहना मेमोरी उपयोग और दक्षता पर प्रतिकूल प्रभाव डाल सकता है:

• सफाई में देरी: साइक्लिक गारबेज कलेक्टर निरंतर नहीं, बल्कि समय-समय पर चलता है। इसका मतलब है कि सर्कुलर रेफ़रेंस में शामिल ऑब्जेक्ट्स, उनकी आवश्यकता न रहने पर भी, तुरंत रिक्लेम नहीं किए जा सकते और अनावश्यक मेमोरी घेरते रहते हैं।
• प्रदर्शन ओवरहेड: साइक्लिक गारबेज कलेक्टर को समय-समय पर जाँच और सफाई के लिए अतिरिक्त संसाधनों की आवश्यकता होती है, जो प्रदर्शन को प्रभावित कर सकता है।

व्यावहारिक उदाहरण: एक ट्री डेटा स्ट्रक्चर

एक सामान्य उपयोग-मामले पर विचार करें—ट्री जैसे डेटा स्ट्रक्चर में—जहाँ प्रत्येक नोड अपने बच्चों का रेफ़रेंस रख सकता है और वैकल्पिक रूप से अपने पैरेंट का भी। यह पैरेंट-चाइल्ड लिंकिंग आसानी से सर्कुलर रेफ़रेंस बना सकती है।

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)संचालित द्वारा

इस उदाहरण में, root अपने children लिस्ट के माध्यम से child को रेफ़रेंस करता है, और child अपने parent एट्रिब्यूट के माध्यम से root को रेफ़रेंस करता है। यह सेटअप बिना किसी और हस्तक्षेप के सर्कुलर रेफ़रेंस बना सकता है।

सर्कुलर रेफ़रेंस से बचने के लिए वीक रेफ़रेंस का उपयोग

वीक रेफ़रेंस, पूरे डेटा स्ट्रक्चर को फिर से डिज़ाइन किए बिना सर्कुलर रेफ़रेंस को तोड़ने या रोकने का एक प्रभावी तरीका हैं। 

Python का weakref मॉड्यूल किसी ऑब्जेक्ट के लिए ऐसा रेफ़रेंस बनाने देता है जो उसके रेफ़रेंस काउंट को नहीं बढ़ाता। यह वीक रेफ़रेंस रेफ़रेंस किए गए ऑब्जेक्ट को गारबेज कलेक्ट होने से नहीं रोकता, जिससे सर्कुलर रेफ़रेंस से जुड़े मेमोरी लीक रोके जा सकते हैं।

पिछली क्लास को वीक रेफ़रेंस इस्तेमाल करने के लिए हम इस प्रकार संशोधित कर सकते हैं:

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)संचालित द्वारा

इस क्लास में, parent एट्रिब्यूट अब पैरेंट नोड का वीक रेफ़रेंस है। इसका मतलब है कि यदि पैरेंट के लिए अन्य कोई स्ट्रॉन्ग रेफ़रेंस नहीं है, तो चाइल्ड नोड मौजूद रहते हुए भी पैरेंट नोड गारबेज कलेक्ट हो सकता है। 

यह तरीका ऐसे ढाँचों में सर्कुलर रेफ़रेंस से सामान्यतः जुड़े मेमोरी लीक मुद्दों को कुशलता से रोकता है।

निष्कर्ष

इस लेख में Python में मेमोरी प्रबंधन की बुनियादी बातें बताई गईं और व्यावहारिक उदाहरणों व मेमोरी तुलना के साथ मेमोरी-कुशल क्लासेज़ लिखने की पाँच उन्नत तकनीकें प्रस्तुत की गईं। हमें उम्मीद है कि आप इन तकनीकों और सर्वोत्तम प्रथाओं को अपने प्रोजेक्ट्स में अपनाकर स्केलेबल और कुशल एप्लिकेशन बनाएँगे। 

हम आपको हमारा Python प्रोग्रामिंग ट्रैक देखने के लिए प्रोत्साहित करते हैं, जिसमें सॉफ़्टवेयर इंजीनियरिंग सिद्धांत और ऑब्जेक्ट-ओरिएंटेड प्रोग्रामिंग शामिल हैं, तथा कुशल Python कोड लिखना भी कवर किया गया है।