👨🏾‍⚖️ ☀️ 🈁 पायथन बहुत सी मेमोरी खा जाता है या वस्तुओं के आकार को कैसे कम किया जाए? 📴 👩🏽‍🤝‍👩🏻 ✒️

एक स्मृति समस्या तब उत्पन्न हो सकती है जब आपको प्रोग्राम निष्पादन के दौरान बड़ी संख्या में ऑब्जेक्ट्स की आवश्यकता होती है, खासकर अगर उपलब्ध रैम के कुल आकार पर प्रतिबंध हैं।

निम्नलिखित वस्तुओं के आकार को कम करने के लिए कुछ तरीकों का अवलोकन है, जो शुद्ध पायथन में कार्यक्रमों के लिए आवश्यक RAM की मात्रा को काफी कम कर सकता है।

सादगी के लिए, हम पायथन में संरचनाओं को x , y , z साथ अंक का प्रतिनिधित्व करने के लिए नाम से समन्वयित मूल्यों तक पहुंच के साथ समन्वय पर विचार करेंगे।

dict

छोटे कार्यक्रमों में, विशेष रूप से लिपियों में, संरचनात्मक जानकारी का प्रतिनिधित्व करने के लिए अंतर्निहित dict का उपयोग करना काफी सरल और सुविधाजनक है:

 >>> ob = {'x':1, 'y':2, 'z':3} >>> x = ob['x'] >>> ob['y'] = y

पायथन 3.6 में कुंजियों के एक व्यवस्थित सेट के साथ अधिक "कॉम्पैक्ट" कार्यान्वयन के आगमन के साथ, dict और भी आकर्षक हो गया है। हालाँकि, रैम में इसके ट्रेस का आकार देखें:

 >>> print(sys.getsizeof(ob)) 240

यह बहुत सारी मेमोरी लेता है, खासकर यदि आपको अचानक बड़ी संख्या में उदाहरण बनाने की आवश्यकता होती है:

प्रतियों की संख्या	ट्रेस का आकार
1000000	240 एमबी
10000000	2.40 जीबी
100000000	24 जीबी

कक्षा उदाहरण

उन लोगों के लिए जो कक्षाओं में सब कुछ बंद करना पसंद करते हैं, इसे विशेषता नाम से एक्सेस के साथ एक वर्ग के रूप में परिभाषित करना बेहतर है:

 class Point: # def __init__(self, x, y, z): self.x = x self.y = y self.z = z >>> ob = Point(1,2,3) >>> x = ob.x >>> ob.y = y

वर्ग उदाहरण की संरचना दिलचस्प है:

मैदान	आकार (बाइट्स)
PyGC_Head	24
PyObject_HEAD	16
__weakref__	8
__dict__	8
कुल:	56

यहां __weakref__ इस ऑब्जेक्ट की तथाकथित कमजोर संदर्भों की एक सूची का लिंक है, __dict__ फ़ील्ड वर्ग के उदाहरण शब्दकोश का एक लिंक है जिसमें उदाहरण की विशेषताओं के मान शामिल हैं (ध्यान दें कि 64-बिट प्लेटफ़ॉर्म पर 8 बाइट्स पर लिंक होता है)। पायथन 3.3 के साथ शुरू, एक साझा शब्दकोश कुंजी स्थान का उपयोग कक्षा के सभी उदाहरणों के लिए किया जाता है। यह स्मृति में उदाहरण ट्रेस का आकार कम करता है:

 >>> print(sys.getsizeof(ob), sys.getsizeof(ob.__dict__)) 56 112

परिणामस्वरूप, बड़ी संख्या में वर्ग उदाहरण एक नियमित शब्दकोश ( dict ) की तुलना में स्मृति में एक छोटा पदचिह्न छोड़ देते हैं:

प्रतियों की संख्या	ट्रेस का आकार
1000000	168 एमबी
10000000	1.68 जीबी
100000000	16.8 जीबी

यह देखना आसान है कि उदाहरण शब्दकोश के आकार के कारण स्मृति में उदाहरण का निशान अभी भी बड़ा है।

Slots के साथ कक्षा का उदाहरण

स्मृति में एक उदाहरण के निशान में एक महत्वपूर्ण कमी __dict__ और __weakref__ को समाप्त करके प्राप्त की जाती है। यह __slots__ साथ "ट्रिक" से __slots__ :

 class Point: __slots__ = 'x', 'y', 'z' def __init__(self, x, y, z): self.x = x self.y = y self.z = z >>> ob = Point(1,2,3) >>> print(sys.getsizeof(ob)) 64

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

मैदान	आकार (बाइट्स)
PyGC_Head	24
PyObject_HEAD	16
एक्स	8
y	8
z	8
कुल:	64

वर्ग परिभाषा में __slots__ का उपयोग करने से इस तथ्य की ओर जाता है कि स्मृति में बड़ी संख्या में उदाहरणों का ट्रेस काफी कम हो जाता है:

प्रतियों की संख्या	ट्रेस का आकार
1000000	64 एमबी
10000000	640 एमबी
100000000	6.4 जीबी

वर्तमान में, यह प्रोग्राम मेमोरी में क्लास इंस्टेंस के ट्रेस को कम करने के लिए मुख्य विधि है।

यह कमी इस तथ्य से प्राप्त होती है कि ऑब्जेक्ट हेडर के बाद ऑब्जेक्ट्स के संदर्भ मेमोरी में संग्रहीत किए जाते हैं, और उन तक पहुंच विशेष डिस्क्रिप्टर का उपयोग करके की जाती है जो क्लास डिक्शनरी में हैं:

 >>> pprint(Point.__dict__) mappingproxy( .................................... 'x': <member 'x' of 'Point' objects>, 'y': <member 'y' of 'Point' objects>, 'z': <member 'z' of 'Point' objects>})

__slots__ साथ एक वर्ग बनाने की प्रक्रिया को स्वचालित करने के लिए एक __slots__ पुस्तकालय है। नाम namedlist.namedlist फ़ंक्शन __slots__ साथ वर्ग के समान एक वर्ग संरचना बनाता है:

 >>> Point = namedlist('Point', ('x', 'y', 'z'))

एक और अटैच पैकेज आपको __slots__ साथ और बिना कक्षाएं बनाने की प्रक्रिया को स्वचालित करने की अनुमति देता है।

टपल

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

 >>> ob = (1,2,3) >>> x = ob[0] >>> ob[1] = y #

टुपल उदाहरण काफी कॉम्पैक्ट हैं:

 >>> print(sys.getsizeof(ob)) 72

वे __slots__ साथ वर्ग उदाहरणों की तुलना में स्मृति में 8 बाइट्स पर कब्जा कर लेते हैं, क्योंकि स्मृति में __slots__ ट्रेस में फ़ील्ड की संख्या भी होती है:

मैदान	आकार (बाइट्स)
PyGC_Head	24
PyObject_HEAD	16
ob_size	8
[0]	8
[1]	8
[2]	8
कुल:	72

Namedtuple

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

इन वर्गों को उत्पन्न करने की प्रक्रिया को स्वचालित करने के लिए namedtuple फ़ंक्शन namedtuple तैयार किया गया है:

 >>> Point = namedtuple('Point', ('x', 'y', 'z'))

यह टपल का एक उपवर्ग बनाता है, जो नाम से खेतों तक पहुंचने के लिए हैंडल को परिभाषित करता है। हमारे उदाहरण के लिए, यह कुछ इस तरह दिखेगा:

  class Point(tuple): # @property def _get_x(self): return self[0] @property def _get_y(self): return self[1] @property def _get_y(self): return self[2] # def __new__(cls, x, y, z): return tuple.__new__(cls, (x, y, z))

ऐसे वर्गों के सभी उदाहरणों में टुपल के समान स्मृति में एक निशान है। उदाहरणों की एक बड़ी संख्या एक छोटे से स्मृति पदचिह्न छोड़ती है:

प्रतियों की संख्या	ट्रेस का आकार
1000000	72 एमबी
10000000	720 एमबी

रिकॉर्डक्लास: जीसी के बिना नामांकित नामांकित उत्परिवर्तित

चूंकि tuple और, तदनुसार, namedtuple वर्ग गैर-उत्परिवर्तित वस्तुओं को इस अर्थ में उत्पन्न करते हैं कि एक ob.x मान ऑब्जेक्ट अब किसी अन्य मान ऑब्जेक्ट के साथ संबद्ध नहीं किया जा सकता है, एक उत्परिवर्तित नेमप्ले वैरिएंट के लिए एक अनुरोध उत्पन्न हुआ है। चूंकि पायथन में एक अंतर्निहित प्रकार नहीं होता है जो एक टपल के समान होता है जो असाइनमेंट का समर्थन करता है, कई विविधताएं बनाई गई हैं। हम रिकॉर्डक्लास पर ध्यान केंद्रित करेंगे, जिसे स्टैकओवरफ्लो रेटिंग मिली थी। इसके अलावा, इसकी मदद से tuple प्रकार की वस्तुओं के ट्रेस के आकार की तुलना में मेमोरी में किसी ऑब्जेक्ट के ट्रेस के आकार को कम करना संभव है।

रिकॉर्डक्लास पैकेज में, प्रकार recordclass.mutabletuple पेश किया गया है, जो लगभग ट्यूपल के समान है, लेकिन समर्थन भी करता है। इसके आधार पर, उप-वर्ग बनाए जाते हैं जो नामांकितों के लगभग समान होते हैं, लेकिन नए मानों को फ़ील्ड में (नए उदाहरण बनाए बिना) असाइन करने का भी समर्थन करते हैं। recordclass फ़ंक्शन, recordclass फ़ंक्शन की तरह, ऐसी कक्षाओं के निर्माण को स्वचालित करता है:

  >>> Point = recordclass('Point', ('x', 'y', 'z')) >>> ob = Point(1, 2, 3)

कक्षा के उदाहरणों में PyGC_Head के समान संरचना होती है, लेकिन केवल PyGC_Head बिना:

मैदान	आकार (बाइट्स)
PyObject_HEAD	16
ob_size	8
एक्स	8
y	8
y	8
कुल:	48

डिफ़ॉल्ट रूप से, recordclass फ़ंक्शन एक वर्ग को जन्म देता है जो परिपत्र कचरा संग्रह तंत्र में शामिल नहीं है। आमतौर पर, recordclass और recordclass का उपयोग उन वर्गों को स्पॉन करने के लिए किया जाता है जो रिकॉर्ड या सरल (गैर-पुनरावर्ती) डेटा संरचनाओं का प्रतिनिधित्व करते हैं। पायथन में उनका सही उपयोग परिपत्र संदर्भ उत्पन्न नहीं करता है। इस कारण से, डिफ़ॉल्ट PyGC_Head द्वारा उत्पन्न वर्गों के उदाहरणों का पता PyGC_Head टुकड़ा से PyGC_Head है, जो उन वर्गों के लिए आवश्यक है जो चक्रीय कचरा संग्रहण तंत्र का समर्थन करते हैं (अधिक सटीक रूप से: PyTypeObject ध्वज PyTypeObject संरचना में वर्ग फ़ील्ड के PyTypeObject बनाया गया है)।

बड़ी संख्या में उदाहरणों का ट्रेस आकार __slots__ वर्ग के उदाहरणों की तुलना में छोटा होता है:

प्रतियों की संख्या	ट्रेस का आकार
1000000	48 एमबी
10000000	480 एमबी
100000000	4.8 जीबी

Dataobject

recordclass लाइब्रेरी में प्रस्तावित एक अन्य समाधान इस विचार पर आधारित है: स्मृति में भंडारण संरचना का उपयोग करने के लिए, __slots__ साथ कक्षाओं के __slots__ , लेकिन चक्रीय कचरा संग्रह के तंत्र में भाग लेने के लिए नहीं। वर्ग को recordclass.make_dataclass फ़ंक्शन का उपयोग करके recordclass.make_dataclass है:

  >>> Point = make_dataclass('Point', ('x', 'y', 'z'))

इस तरह बनाया गया डिफ़ॉल्ट वर्ग उत्परिवर्तित उदाहरण बनाता है।

एक और तरीका यह है कि recordclass.dataobject से विरासत में वर्ग घोषणा का उपयोग करें:

 class Point(dataobject): x:int y:int z:int

इस तरह से बनाई गई कक्षाएं ऐसे उदाहरण उत्पन्न करेंगी जो परिपत्र कचरा संग्रह के तंत्र में भाग नहीं लेते हैं। स्मृति में उदाहरण की संरचना __slots__ के समान है, लेकिन PyGC_Head शीर्षलेख के बिना:

मैदान	आकार (बाइट्स)
PyObject_HEAD	16
एक्स	8
y	8
y	8
कुल:	40

 >>> ob = Point(1,2,3) >>> print(sys.getsizeof(ob)) 40

खेतों तक पहुंचने के लिए, विशेष डिस्क्रिप्टर का उपयोग ऑब्जेक्ट की शुरुआत के सापेक्ष फ़ील्ड को एक्सेस करने के लिए किया जाता है, जिसे क्लास डिक्शनरी में रखा जाता है:

 mappingproxy({'__new__': <staticmethod at 0x7f203c4e6be0>, ....................................... 'x': <recordclass.dataobject.dataslotgetset at 0x7f203c55c690>, 'y': <recordclass.dataobject.dataslotgetset at 0x7f203c55c670>, 'z': <recordclass.dataobject.dataslotgetset at 0x7f203c55c410>})

बड़ी संख्या में उदाहरणों का पता लगाने का आकार CPython के लिए सबसे छोटा संभव है:

प्रतियों की संख्या	ट्रेस का आकार
1000000	40 एमबी
10000000	400 एमबी
100000000	4.0 जीबी

Cython

साइथन का उपयोग करने पर आधारित एक दृष्टिकोण है । इसका लाभ यह है कि फ़ील्ड सी भाषा प्रकारों के मूल्यों को ले सकते हैं। शुद्ध पायथन से खेतों तक पहुंचने के लिए डेस्क्रिप्टर्स स्वचालित रूप से बनाए जाते हैं। उदाहरण के लिए:

 cdef class Python: cdef public int x, y, z def __init__(self, x, y, z): self.x = x self.y = y self.z = z

इस स्थिति में, उदाहरणों की मेमोरी का आकार भी छोटा होता है:

 >>> ob = Point(1,2,3) >>> print(sys.getsizeof(ob)) 32

स्मृति में एक उदाहरण ट्रेस में निम्न संरचना होती है:

मैदान	आकार (बाइट्स)
PyObject_HEAD	16
एक्स	4
y	4
y	4
खाली है	4
कुल:	32

बड़ी संख्या में प्रतियां का आकार छोटा है:

प्रतियों की संख्या	ट्रेस का आकार
1000000	32 एमबी
10000000	320 एमबी
100000000	3.2 जीबी

हालांकि, यह याद रखना चाहिए कि जब पायथन कोड से प्रवेश किया जाता है, तो प्रत्येक बार int से पायथन ऑब्जेक्ट और इसके विपरीत रूपांतरण किया जाएगा।

Numpy

बड़ी मात्रा में डेटा के लिए बहुआयामी या रिकॉर्ड सरणियों का उपयोग स्मृति में लाभ देता है। हालांकि, शुद्ध पायथन में कुशल प्रसंस्करण के लिए, आपको प्रसंस्करण विधियों का उपयोग करना चाहिए जो कि numpy पैकेज से कार्यों का उपयोग करने पर ध्यान केंद्रित करते हैं।

 >>> Point = numpy.dtype(('x', numpy.int32), ('y', numpy.int32), ('z', numpy.int32)])

शून्य और आरओ के साथ आरम्भ किए गए ए और N तत्वों को फंक्शन का उपयोग करके बनाया जाता है:

  >>> points = numpy.zeros(N, dtype=Point)

सरणी का आकार सबसे छोटा संभव है:

प्रतियों की संख्या	ट्रेस का आकार
1000000	12 एमबी
10000000	120 एमबी
100000000	1.20 जीबी

सरणी तत्वों और तारों के नियमित उपयोग के लिए पायथन ऑब्जेक्ट रूपांतरण की आवश्यकता होगी
C int और इसके विपरीत के मूल्य में। किसी एकल पंक्ति में एक एकल तत्व वाले परिणाम को निकालना। उसका ट्रैक इतना कॉम्पैक्ट नहीं होगा:

  >>> sys.getsizeof(points[0]) 68

इसलिए, जैसा कि ऊपर उल्लेख किया गया है, पायथन कोड में, numpy पैकेज से कार्यों का उपयोग करके सरणियों को संसाधित करना आवश्यक है।

निष्कर्ष

एक स्पष्ट और सरल उदाहरण का उपयोग करते हुए, यह सत्यापित करना संभव था कि पायथन प्रोग्रामिंग भाषा (सीपीथॉन) के डेवलपर्स और उपयोगकर्ताओं के समुदाय के पास वस्तुओं द्वारा उपयोग की जाने वाली स्मृति की मात्रा को कम करने के लिए वास्तविक अवसर हैं।

पायथन बहुत सी मेमोरी खा जाता है या वस्तुओं के आकार को कैसे कम किया जाए?