👩🏻‍🚒 ⏱️ 🍻 अजगर बहुत सी मेमोरी खा जाता है या वस्तुओं के आकार को कैसे कम किया जाता है? 🔉 ⚾️ 🆎

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

नीचे वस्तुओं के आकार को कम करने के कुछ तरीकों का अवलोकन है, जो शुद्ध अजगर में कार्यक्रमों के लिए आवश्यक 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 8tes पर कब्जा करता है)। पायथन 3.3 में शुरू, साझा स्थान का उपयोग कक्षा के सभी उदाहरणों के लिए शब्दकोश में कुंजियों को संग्रहीत करने के लिए किया जाता है। यह RAM में उदाहरण ट्रेस का आकार कम करता है:

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

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

उदाहरणों की संख्या	आकार
1000000	168 एमबी
10000000	1.68 जी.बी.
100000000	16.8 जी.बी.

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

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

RAM में एक क्लास इंस्टेंस के आकार में महत्वपूर्ण कमी __dict__ और __weakref__ को समाप्त करके प्राप्त की जाती है। यह __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

RAM में ऑब्जेक्ट का आकार काफी छोटा हो गया है:

क्षेत्र	आकार (बाइट्स)
PyGC_Head	24
PyObject_HEAD	16
एक्स	8
y	8
z	8
कुल:	64

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

उदाहरणों की संख्या	आकार
1000000	64 एमबी
10000000	640 एमबी
100000000	6.4 Gb

वर्तमान में, यह रैम में एक वर्ग के उदाहरण की मेमोरी फ़ुटप्रिंट को काफी हद तक कम करने का मुख्य तरीका है।

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

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

__slots__ साथ एक वर्ग बनाने की प्रक्रिया को स्वचालित करने के लिए, एक पुस्तकालय [नाम सूची] ( https://pypi.org/project/onymlist ) है। नाम namedlist.namedlist फ़ंक्शन namedlist.namedlist साथ एक वर्ग बनाता है:

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

एक और पैकेज [अटर्म्स] ( https://pypi.org/project/attrs ) आपको __slots__ साथ और बिना दोनों के कक्षाएं बनाने की प्रक्रिया को स्वचालित करने की अनुमति देता है।

टपल

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

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

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

 >>> 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

चूंकि टूपल का उपयोग बहुत व्यापक रूप से किया जाता है, एक दिन एक अनुरोध था कि आप अभी भी खेतों तक पहुंच सकते हैं और नाम से भी। इस अनुरोध का उत्तर मॉड्यूल collections.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_z(self): return self[2] # def __new__(cls, x, y, z): return tuple.__new__(cls, (x, y, z))

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

उदाहरणों की संख्या	आकार
1000000	72 एमबी
10000000	720 एमबी
100000000	7.2 जी.बी.

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

चूंकि tuple और, तदनुसार, नेमटुपल -क्लेसेस इस अर्थ में अपरिवर्तनीय वस्तुएं उत्पन्न करते हैं कि विशेषता ob.x को अब किसी अन्य मान ऑब्जेक्ट के साथ जोड़ा नहीं जा सकता है, एक उत्परिवर्तित नेटल अप वेरिएंट के लिए अनुरोध उत्पन्न हुआ है। चूंकि पायथन में कोई अंतर्निहित प्रकार नहीं है जो कार्य का समर्थन करने वाले टपल के समान है, कई विकल्प बनाए गए हैं। हम [recordclass] ( https://pypi.org/project/recordclass ) पर ध्यान केंद्रित करेंगे, जिसे [stackoverflow] ( https://stackoverflow.com/questions/29290359/existence-of-mutable- बेनाम- की रेटिंग प्राप्त हुई है tuple-in -python / 29419745)। इसके अलावा इसका उपयोग tuple -जैसी वस्तुओं के आकार की तुलना में रैम में वस्तुओं के आकार को कम करने के लिए किया जा सकता है।

पैकेज रिकॉर्डक्लास टाइप recordclass.mutabletuple का परिचय 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 का उपयोग रिकॉर्ड या सरल (गैर-पुनरावर्ती) डेटा संरचनाओं का प्रतिनिधित्व करने वाली कक्षाएं उत्पन्न करने के लिए किया जाता है। पाइथन में इनका सही तरीके से उपयोग करने से सर्कुलर रेफरेंस उत्पन्न नहीं होता है। इस कारण से, recordclass द्वारा उत्पन्न वर्गों के उदाहरणों के recordclass , PyGC_Head fragment is excluded, which is necessary for classes supporting the cyclic garbage collection mechanism (more precisely: in the PyTypebbject structure, corresponding to the created class, in the झंडे के field, by default, the flag Py_TPFLAGS_HAVE_GC 'सेट नहीं है)।

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

उदाहरणों की संख्या	आकार
1000000	48 एमबी
10000000	480 एमबी
100000000	4.8 जी.बी.

Dataobject

रिकॉर्डक्लास लाइब्रेरी में प्रस्तावित एक अन्य समाधान इस विचार पर आधारित है: __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__ के मामले में __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

[साइथॉन] ( https://cython.org ) के उपयोग के आधार पर एक दृष्टिकोण है। इसका लाभ यह है कि क्षेत्र सी भाषा परमाणु प्रकार के मूल्यों पर ले जा सकते हैं। शुद्ध पायथन से खेतों तक पहुँचने के लिए डिस्क्रिप्टर्स स्वचालित रूप से बनाए जाते हैं। उदाहरण के लिए:

 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 से Python ऑब्जेक्ट और इसके विपरीत में रूपांतरण किया जाएगा।

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 Gb

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

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

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

निष्कर्ष

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

अजगर बहुत सी मेमोरी खा जाता है या वस्तुओं के आकार को कैसे कम किया जाता है?