🐣 🤱🏻 📓 सीपीथॉन में इंटेगर टाइप इंप्लीमेंटेशन ⛹🏾 🎂 🧚🏿

सीपीथॉन के स्मृति प्रबंधक , पंडों के कार्यान्वयन के विवरण के बारे में हैबर पर पहले से ही लेख थे, मैंने शब्दकोश को लागू करने के बारे में एक लेख लिखा था।

ऐसा लगता है कि आप एक नियमित पूर्णांक प्रकार के बारे में लिख सकते हैं? हालांकि, सब कुछ इतना सरल नहीं है और पूर्णांक प्रकार इतना स्पष्ट नहीं है।

अगर आप सोच रहे हैं कि x * 2 x << 1 से अधिक तेज क्यों है ।

और निम्नलिखित ट्रिक को क्रैंक कैसे करें:

>>> 42 == 4 True >>> 42 4 >>> 1 + 41 4

फिर आपको यह लेख पढ़ना चाहिए।

अजगर में कोई आदिम प्रकार नहीं हैं - सभी चर ऑब्जेक्ट हैं और डायनेमिक मेमोरी में आवंटित किए गए हैं। उसी समय, पूर्णांक केवल एक प्रकार (हम दशमलव नहीं मानते हैं) द्वारा दर्शाए जाते हैं - PyLongObject। कार्यान्वयन और घोषणाएँ जिनमें फाइलें longobject.h, longintrepr.h और longobject.c हैं।

 struct _longobject { PyObject_VAR_HEAD //       digit ob_digit[1]; //   };

CPython में किसी भी वस्तु में दो फ़ील्ड हैं: ob_refcnt - ऑब्जेक्ट के संदर्भ का काउंटर और ob_type - ऑब्जेक्ट के प्रकार के लिए पॉइंटर; ऑब्जेक्ट जो उनकी लंबाई को बदल सकते हैं, ob_size फ़ील्ड जोड़ा जाता है - वर्तमान आवंटित आकार (कम हो सकता है)।

इस प्रकार, पूर्णांक प्रकार को अलग-अलग अंकों से परिवर्तनीय लंबाई के एक सरणी द्वारा दर्शाया जाता है, इसलिए बॉक्स से बाहर अजगर लंबे अंकगणित का समर्थन करता है, भाषा के दूसरे संस्करण में एक अलग प्रकार का "साधारण" पूर्णांक था। "लंबे" पूर्णांक पत्र एल का उपयोग करके बनाए गए थे, या यदि ऑपरेशन के साथ संचालन का परिणाम। सामान्य लोगों द्वारा अतिप्रवाह के कारण, तीसरे संस्करण में इसे मना करने का निर्णय लिया गया।

  # python2 num1 = 42 print num1, type(num1) # 42 <type 'int'> num2 = 42L print num2, type(num2) # 42 <type 'long'> num3 = 2 ** 100 print num3, type(num3) # 1267650600228229401496703205376 <type 'long'>

_Longobject संरचना द्वारा संग्रहीत पूर्णांक मान इसके बराबर है:

s u m_{i = 0}^{a b s (o b_{s} i z e) - 1} o b_{d} i g i t_{i} * 2^{S H I F T * i}

$\ sum_ {i = 0} ^ {abs (ob \ _size) -1} {ob \ _digit_i * 2 ^ {SHIFT * i}}$

एक बिट के रूप में, 64-बिट सिस्टम पर 32-बिट अहस्ताक्षरित प्रकार (uint32_t) और 32-बिट पर 16-बिट अहस्ताक्षरित लघु प्रकार का उपयोग किया जाता है।

कार्यान्वयन में उपयोग किए जाने वाले एल्गोरिदम पिछले फॉर्मूले से SHIFT पर सख्त प्रतिबंध लगाते हैं, विशेष रूप से, इसे 15 से विभाजित किया जाना चाहिए, इसलिए अब cpython 64 और 32-बिट सिस्टम के लिए क्रमशः दो मूल्यों: 30 और 15 का समर्थन करता है। नकारात्मक मानों के लिए, ob_size का ऋणात्मक मान है, शून्य एक संख्या के लिए दिया जाता है जिसके लिए ob_size = 0 होता है।

अंकगणितीय संचालन करते समय, दुभाषिया ऑपरेंड की वर्तमान लंबाई की जांच करता है, यदि दोनों में एक बिट होता है, तो मानक अंकगणित किया जाता है।

 static PyObject * long_add(PyLongObject *a, PyLongObject *b) { ... //   -     if (Py_ABS(Py_SIZE(a)) <= 1 && Py_ABS(Py_SIZE(b)) <= 1) { //      return PyLong_FromLong(MEDIUM_VALUE(a) + MEDIUM_VALUE(b)); } ... };

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

 //     #define KARATSUBA_CUTOFF 70 //      #define KARATSUBA_SQUARE_CUTOFF (2 * KARATSUBA_CUTOFF)

 static PyObject * long_mul(PyLongObject *a, PyLongObject *b) { ... //   -     if (Py_ABS(Py_SIZE(a)) <= 1 && Py_ABS(Py_SIZE(b)) <= 1) { // stwodigits -  ,    // int64_t  64-   long  32-. stwodigits v = (stwodigits)(MEDIUM_VALUE(a)) * MEDIUM_VALUE(b); return PyLong_FromLongLong((long long)v); } ... // ""    O(N^2),     . i = a == b ? KARATSUBA_SQUARE_CUTOFF : KARATSUBA_CUTOFF; if (asize <= i) { if (asize == 0) return (PyLongObject *)PyLong_FromLong(0); else return x_mul(a, b); } ... };

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

तुलना फ़ंक्शन में "शॉर्ट" पूर्णांक के लिए एक विशेष मामला नहीं है।

 static int long_compare(PyLongObject *a, PyLongObject *b) { Py_ssize_t sign; // ,        //        if (Py_SIZE(a) != Py_SIZE(b)) { sign = Py_SIZE(a) - Py_SIZE(b); } else { Py_ssize_t i = Py_ABS(Py_SIZE(a)); //  ""        while (--i >= 0 && a->ob_digit[i] == b->ob_digit[i]) ; if (i < 0) sign = 0; else { sign = (sdigit)a->ob_digit[i] - (sdigit)b->ob_digit[i]; if (Py_SIZE(a) < 0) sign = -sign; } } return sign < 0 ? -1 : sign > 0 ? 1 : 0; }

संख्याओं की सारणी (सूची)

पूर्णांक प्रकार चर बनाते समय, दुभाषिया को गतिशील मेमोरी में पर्याप्त स्थान आवंटित करना चाहिए, फिर संदर्भ काउंटर (टाइप ssize_t), PyLongObject टाइप करने के लिए एक सूचक, बिट सरणी का वर्तमान आकार (भी ssize_t) सेट करें और सरणी को स्वयं प्रारंभ करें। 64-बिट सिस्टम के लिए, न्यूनतम संरचना का आकार है: 2 * ssize_t + सूचक + अंक = 2 * 8 + 8 + 4 = 28 बाइट्स। संख्याओं की सूची बनाते समय अतिरिक्त समस्याएं दिखाई देती हैं: चूंकि संख्याएं एक आदिम प्रकार नहीं हैं, और वस्तुओं के संदर्भ में अजगर स्टोर संदर्भों में सूचीबद्ध हैं, ऑब्जेक्ट क्रमिक रूप से गतिशील मेमोरी में नहीं हैं।

यह व्यवस्था सरणी पर चलना धीमा कर देती है: वास्तव में, यादृच्छिक पहुंच का प्रदर्शन किया जाता है, जिससे संक्रमण की भविष्यवाणी करना असंभव हो जाता है।

डायनेमिक मेमोरी के अत्यधिक आवंटन से बचने के लिए, जो ऑपरेटिंग समय को धीमा कर देता है और मेमोरी फ़्रेग्मेंटेशन में योगदान देता है, अनुकूलन को cpython में लागू किया गया है: स्टार्ट-अप चरण में, छोटे पूर्णांकों की एक सरणी पूर्व-आवंटित की गई है: -5 से 256 तक।

 #ifndef NSMALLPOSINTS #define NSMALLPOSINTS 257 //     python    . #endif #ifndef NSMALLNEGINTS #define NSMALLNEGINTS 5 #endif

नतीजतन, cpython में संख्याओं की सूची निम्नानुसार स्मृति में दर्शाई गई है:

स्क्रिप्ट से छोटे पूर्णांकों की पूर्व-चयनित सूची तक पहुंचने का अवसर है, जो इस लेख से लैस है और मानक ctypes विवरण:

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

 import ctypes #  PyLongObject class IntStruct(ctypes.Structure): #   _fields_ = [("ob_refcnt", ctypes.c_long), ("ob_type", ctypes.c_void_p), ("ob_size", ctypes.c_long), ("ob_digit", ctypes.c_int)] def __repr__(self): return ("IntStruct(ob_digit={self.ob_digit}, ob_size={self.ob_size}, " "refcount={self.ob_refcnt})").format(self=self) if __name__ == '__main__': #    42 int42 = IntStruct.from_address(id(42)) print(int42) int_minus_2 = IntStruct.from_address(id(-2)) print(int_minus_2) # ob_digit=2, ob_size=-1 #       int42.ob_digit = 4 print(4 == 42) # True print(1 + 41) # 4

ईमानदार PyLongObject इस सूची में संग्रहीत है, अर्थात्, उनके पास एक संदर्भ काउंटर है, उदाहरण के लिए, आप यह पता लगा सकते हैं कि आपकी स्क्रिप्ट और दुभाषिया उपयोग कितने शून्य हैं।

पूर्णांकों के आंतरिक कार्यान्वयन से यह निम्नानुसार है कि कैथीथॉन में अंकगणित तेजी से नहीं हो सकता है, जहां अन्य भाषाएं क्रमिक रूप से पुनरावृत्त होती हैं, संख्याओं को रजिस्टरों में पढ़ती हैं और सीधे कई प्रोसेसर निर्देशों को बुलाती हैं, साइफथॉन को पूरे स्मृति में टैग किया जाता है, बल्कि जटिल तरीके से प्रदर्शन करते हैं। एकल-बिट पूर्णांक के सरलतम मामले में, जिसमें एक निर्देश को कॉल करने के लिए पर्याप्त होगा, दुभाषिया को आकारों की तुलना करना होगा, फिर गतिशील मेमोरी में एक ऑब्जेक्ट बनाना होगा, सेवा क्षेत्रों को भरना होगा, और इसके लिए एक सूचक लौटना होगा; इसके अलावा, इन कार्यों के लिए जीआईएल लॉक की आवश्यकता है। अब आप समझ गए हैं कि सुन्न पुस्तकालय क्यों आया और यह इतना लोकप्रिय क्यों है।

मैं बुलियन में पूरे प्रकार के बारे में लेख को समाप्त करना चाहूंगा, अचानक, बूलियन प्रकार के बारे में जानकारी के साथ।

तथ्य यह है कि अजगर में लंबे समय तक बूलियन चर के लिए कोई अलग प्रकार नहीं था, सभी तार्किक फ़ंक्शन 0 और 1 लौटे। हालांकि, उन्होंने एक नए प्रकार को पेश करने का फैसला किया । उसी समय, इसे एक बाल प्रकार के रूप में पूरे में लागू किया गया था।

 PyTypeObject PyBool_Type = { PyVarObject_HEAD_INIT(&PyType_Type, 0) //       // ,       //     ob_size "bool", //   sizeof(struct _longobject), //    ... &PyLong_Type, //   ... bool_new, //  };

इसके अलावा, बूलियन प्रकार का प्रत्येक मान एक सिंगलटन है, बूलियन वेरिएबल ट्रू या फाल्स के उदाहरण के लिए एक संकेतक है (कोई भी समान तरीके से लागू नहीं किया जाता है)।

 struct _longobject _Py_FalseStruct = { PyVarObject_HEAD_INIT(&PyBool_Type, 0) { 0 } }; struct _longobject _Py_TrueStruct = { PyVarObject_HEAD_INIT(&PyBool_Type, 1) { 1 } }; static PyObject * bool_new(PyTypeObject *type, PyObject *args, PyObject *kwds) { PyObject *x = Py_False; long ok; if (!_PyArg_NoKeywords("bool", kwds)) return NULL; if (!PyArg_UnpackTuple(args, "bool", 0, 1, &x)) return NULL; ok = PyObject_IsTrue(x); if (ok < 0) return NULL; return PyBool_FromLong(ok); } PyObject *PyBool_FromLong(long ok) { PyObject *result; if (ok) result = Py_True; else result = Py_False; Py_INCREF(result); return result; }

PyObject_IsTrue (x) एक बूलियन मान की गणना करने के लिए एक मुश्किल तंत्र है, आप इसे यहां बूल फ़ंक्शन पर या दस्तावेज़ में देख सकते हैं।

इस तरह की विरासत कुछ मज़ेदार प्रभाव डालती है, जैसे कि ट्रू और 1 की सटीक समानता, ट्रू और 1 की चाबियाँ और सेट में कुंजी के रूप में अक्षमता और बूलियन प्रकार पर अंकगणितीय संचालन की वैधता:

 >>> True == 1 True >>> {True: "true", 1: "one"} {True: 'one'} >>> True * 2 + False / (5 * True) - (True << 3) -6.0 >>> False < -1 False

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

सीपीथॉन में इंटेगर टाइप इंप्लीमेंटेशन

संख्याओं की सारणी (सूची)

More articles: