🏒 🏩 🧣 सीपीथॉन में स्ट्रिंग प्रकार कार्यान्वयन 🏯 😃 👨🏽‍💼

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

आइए इतिहास में एक छोटे से विषयांतर से शुरुआत करते हैं। 1990-91 में अजगर दिखाई दिया। प्रारंभ में, जब अजगर में बेस एन्कोडिंग विकसित हो रहा था, तो एक एकल-बाइट, अच्छी पुरानी एस्की थी। लेकिन, लगभग उसी समय (थोड़ी देर बाद), मानवता एन्कोडिंग के "चिड़ियाघर" से निपटने के लिए थक गई थी, और 1991 में यूनिकोड मानक प्रस्तावित किया गया था। हालांकि, पहली बार भी, यह काम नहीं किया। दो-बाइट एन्कोडिंग की शुरूआत हुई, लेकिन बहुत जल्द यह स्पष्ट हो गया कि दो बाइट्स सभी के लिए पर्याप्त नहीं होंगे, एक 4-बाइट एन्कोडिंग प्रस्तावित किया गया था। दुर्भाग्य से, प्रत्येक चरित्र के लिए 4 बाइट्स आवंटित करना डिस्क स्थान और मेमोरी की बर्बादी की तरह लग रहा था, विशेष रूप से उन देशों में जहां एक एकल बाइट ascii पहले पर्याप्त थी। कई बैसाखी को अधिक वर्णों का समर्थन करने के लिए 2-बाइट एन्कोडिंग में देखा गया था, और यह सब एन्कोडिंग के "चिड़ियाघर" के साथ पिछली स्थिति जैसा था।

लेकिन 1993 में utf-8 पेश किया गया था। जो एक समझौता था: एससीआई utf-8 का एक वैध उपसमूह था, अन्य सभी पात्रों ने इसका विस्तार किया, हालांकि, इस संभावना का समर्थन करने के लिए, मुझे प्रत्येक चरित्र की एक निश्चित लंबाई के साथ भाग लेना था। लेकिन यह वह था जिसे ~~हर किसी~~ को यूनिकोड बनने के लिए ~~शासन~~ करने के लिए नियत किया गया था, अर्थात, अधिकांश कार्यक्रमों द्वारा समर्थित एक एन्कोडिंग जिसमें अधिकांश फाइलें संग्रहीत होती हैं। यह विशेष रूप से इंटरनेट के विकास से प्रभावित था, क्योंकि वेब पेज आमतौर पर सिर्फ यूएफ -8 का उपयोग करते थे।

इस एन्कोडिंग के लिए समर्थन को धीरे-धीरे प्रोग्रामिंग भाषाओं में पेश किया गया था, जैसे कि अजगर को utf-8 से पहले विकसित किया गया था, और इसलिए अन्य एन्किंग्स का उपयोग किया गया था। एक अच्छी संख्या 100 के साथ पीईपी है जिसमें यूनिकोड समर्थन पर चर्चा की गई है। और PEP-0263 में स्रोत फ़ाइलों की एन्कोडिंग की घोषणा करना संभव हो गया। एस्कोडिंग अभी भी बेस एन्कोडिंग था, यूको प्रीफिक्स को यूनिकोड स्ट्रिंग्स घोषित करने के लिए उपयोग किया गया था, उनके साथ काम करना अभी भी सुविधाजनक और प्राकृतिक नहीं था। लेकिन निम्नलिखित पाषंड बनाने का अवसर था:

class 비빔밥: _ = 2 א = 비빔밥() print(א)

3 दिसंबर 2008 को, पूरे अजगर समुदाय के लिए एक ऐतिहासिक घटना हुई (और यह देखते हुए कि यह भाषा अब व्यापक रूप से कैसे फैल गई है, तब, शायद, पूरी दुनिया के लिए) - अजगर 3 को छोड़ दिया गया था। यह एक बार और सभी के लिए समस्याओं का अंत करने का निर्णय लिया गया था। कई एनकोडिंग, और इसलिए यूनिकोड आधार एन्कोडिंग बन गया है। लेकिन हमें याद है कि एन्कोडिंग जटिल है और पहली बार काम नहीं करता है। इस बार यह काम नहीं किया

यूटीएफ -8 की बड़ी खामी यह है कि चरित्र की लंबाई तय नहीं है, जो इस तथ्य की ओर जाता है कि सूचकांक तक पहुंचने के रूप में इस तरह के एक सरल ऑपरेशन में जटिलता ओ (एन) है, क्योंकि तत्व की ऑफसेट अग्रिम में ज्ञात नहीं है, इसके अलावा, बफर के आकार को जानना; एक स्ट्रिंग के भंडारण के लिए आवंटित, आप वर्णों में इसकी लंबाई की गणना नहीं कर सकते।

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

प्रत्येक प्लेटफ़ॉर्म की अपनी एन्कोडिंग थी, जिससे कोड पोर्टेबिलिटी की समस्या हो सकती थी
ट्रिकी वर्णों के लिए मेमोरी की खपत और / या एन्कोडिंग समस्याएं जो दो बाइट्स में फिट नहीं होती हैं

PEP-393 में इन समस्याओं का समाधान प्रस्तावित किया गया था, और हम इसके बारे में बात करेंगे।

सूचकांक और अन्य परिचालनों द्वारा पहुंच को सुविधाजनक बनाने के लिए, पात्रों की एक सरणी के रूप में लाइनों को छोड़ने का निर्णय लिया गया था, हालांकि, वर्णों की लंबाई अलग-अलग होने लगी। एक स्ट्रिंग बनाते समय, दुभाषिया सभी वर्णों को स्कैन करता है और प्रत्येक बाइट की संख्या के लिए आवंटित करता है जो "सबसे बड़ा" एक को संग्रहीत करने के लिए आवश्यक है, अर्थात, यदि आप एक एस्की स्ट्रिंग की घोषणा करते हैं, तो सभी वर्ण एकल-बाइट होंगे, हालांकि, यदि आप स्ट्रिंग में एक वर्ण जोड़ने का निर्णय लेते हैं सिरिलिक से, सभी वर्ण पहले से ही दो-बाइट होंगे। तीन संभावित विकल्प हैं: प्रति वर्ण 1, 2, और 4 बाइट्स।

स्ट्रिंग प्रकार (PyUnicodeObject) इस प्रकार घोषित किया गया है :

 /* Strings allocated through PyUnicode_FromUnicode(NULL, len) use the PyUnicodeObject structure. The actual string data is initially in the wstr block, and copied into the data block using _PyUnicode_Ready. */ typedef struct { PyCompactUnicodeObject _base; union { void *any; Py_UCS1 *latin1; Py_UCS2 *ucs2; Py_UCS4 *ucs4; } data; /* Canonical, smallest-form Unicode buffer */ } PyUnicodeObject;

बदले में, PyCompactUnicodeObject निम्नलिखित संरचना का प्रतिनिधित्व करता है (कुछ सरलीकरण और मेरी टिप्पणियों के साथ प्रदान की गई):

 /*    ascii  */ typedef struct { PyASCIIObject _base; Py_ssize_t utf8_length; /*    utf-8  (  \0 )*/ char *utf8; /* UTF-8  ( \0 )*/ Py_ssize_t wstr_length; /*  code point  wstr. */ } PyCompactUnicodeObject; /*   ascii  */ typedef struct { PyObject_HEAD /*   (     ) */ Py_ssize_t length; /*  code point   */ Py_hash_t hash; /*   -1,      */ struct { /* SSTATE_NOT_INTERNED (0) SSTATE_INTERNED_MORTAL (1) SSTATE_INTERNED_IMMORTAL (2) */ unsigned int interned:2; /*  : - PyUnicode_WCHAR_KIND (0): * wchar_t (16  32 ,     ( )) - PyUnicode_1BYTE_KIND (1): - PyUnicode_2BYTE_KIND (2): - PyUnicode_4BYTE_KIND (4): */ unsigned int kind:3; /*    ( ,        ,   -  data   ). */ unsigned int compact:1; /*       U+0000-U+007F (ASCII) */ unsigned int ascii:1; /* ,    ,     */ unsigned int ready:1; unsigned int :24; } state; wchar_t *wstr; /* wchar_t  (  \0 ) */ } PyASCIIObject;

इस प्रकार 4 लाइन अभ्यावेदन संभव हैं:

विरासत स्ट्रिंग, तैयार है

  * structure = PyUnicodeObject structure *   : !PyUnicode_IS_COMPACT(op) && kind != PyUnicode_WCHAR_KIND * kind = PyUnicode_1BYTE_KIND, PyUnicode_2BYTE_KIND or PyUnicode_4BYTE_KIND * compact = 0 * ready = 1 * data.any is not NULL * utf8   data.any  utf8_length = length  ascii = 1 * utf8_length = 0  utf8 is NULL * wstr   with data.any  wstr_length = length  kind=PyUnicode_2BYTE_KIND and sizeof(wchar_t)=2 or if kind=PyUnicode_4BYTE_KIND and sizeof(wchar_4)=4 * wstr_length = 0  wstr is NULL

विरासत स्ट्रिंग, तैयार नहीं है

  * structure = PyUnicodeObject *   : kind == PyUnicode_WCHAR_KIND * length = 0 (use wstr_length) * hash = -1 * kind = PyUnicode_WCHAR_KIND * compact = 0 * ascii = 0 * ready = 0 * interned = SSTATE_NOT_INTERNED * wstr is not NULL * data.any is NULL * utf8 is NULL * utf8_length = 0

कॉम्पैक्ट ascii

  * structure = PyASCIIObject *   : PyUnicode_IS_COMPACT_ASCII(op) * kind = PyUnicode_1BYTE_KIND * compact = 1 * ascii = 1 * ready = 1 * (length —  utf8  wstr ) * (data    ) * (  ascii    utf8 string   data)

सघन

  * structure = PyCompactUnicodeObject *   : PyUnicode_IS_COMPACT(op) && !PyUnicode_IS_ASCII(op) * kind = PyUnicode_1BYTE_KIND, PyUnicode_2BYTE_KIND or PyUnicode_4BYTE_KIND * compact = 1 * ready = 1 * ascii = 0 * utf8  data  * utf8_length = 0  utf8 is NULL * wstr   data  wstr_length=length  kind=PyUnicode_2BYTE_KIND and sizeof(wchar_t)=2 or if kind=PyUnicode_4BYTE_KIND and sizeof(wchar_t)=4 * wstr_length = 0  wstr is NULL * (data    )

यह ध्यान दिया जाना चाहिए कि अजगर 3 भी `यू` उपसर्ग के माध्यम से यूनिकोड स्ट्रिंग्स की घोषणा के लिए वाक्यविन्यास का समर्थन करता है।

 >>> b = u"" >>> b ''

यह सुविधा केवल फरवरी 2012 में अजगर 3.3 में PEP-414 में दूसरे संस्करण से तीसरे संस्करण में पोर्टिंग कोड की सुविधा के लिए जोड़ी गई थी, मैं आपको याद दिला दूं कि अजगर 3 दिसंबर 2008 में जारी किया गया था, लेकिन कोई भी संक्रमण के साथ जल्दी में नहीं था।

इस ज्ञान और मानक ctypes मॉड्यूल के साथ सशस्त्र, हम स्ट्रिंग के आंतरिक क्षेत्रों तक पहुंच सकते हैं।

 import ctypes import enum import sys class Interned(enum.Enum): # SSTATE_NOT_INTERNED (0) # SSTATE_INTERNED_MORTAL (1) # SSTATE_INTERNED_IMMORTAL (2) # If interned != SSTATE_NOT_INTERNED, the two references from the # dictionary to this object are *not* counted in ob_refcnt. SSTATE_NOT_INTERNED = 0 SSTATE_INTERNED_MORTAL = 1 SSTATE_INTERNED_IMMORTAL = 2 class Kind(enum.Enum): PyUnicode_WCHAR_KIND = 0 PyUnicode_1BYTE_KIND = 1 PyUnicode_2BYTE_KIND = 2 PyUnicode_4BYTE_KIND = 4 # PyUnicodeObject class StrStruct(ctypes.Structure): _fields_ = [("refcnt", ctypes.c_long), ("type", ctypes.c_void_p), ("length", ctypes.c_long), ("hash", ctypes.c_void_p), # ascii fields ("_interned", ctypes.c_uint, 2), ("_kind", ctypes.c_uint, 3), ("compact", ctypes.c_uint, 1), ("ascii", ctypes.c_uint, 1), ("ready", ctypes.c_uint, 1), ("_rest_state", ctypes.c_uint, 16), # for future use ("wstr", ctypes.c_wchar_p), # PyCompactUnicodeObject ("utf8_length", ctypes.c_ssize_t), # Number of bytes in utf8, excluding the terminating \0. ("utf8", ctypes.c_char_p), ("wstr_length", ctypes.c_ssize_t), # Number of code points ("data", ctypes.c_void_p) # canonical, smallest-form Unicode buffer ] _printable_fields = ("refcnt", "length", "hash", "interned", "kind", "compact", "ascii", "ready", "wstr", "utf8_length", "utf8", "wstr_length", "data") @property def interned(self): return Interned(self._interned) @property def kind(self): return Kind(self._kind) def __repr__(self): new_line = '\n' # f-string expression part cannot include a backslash return f"StrStruct({new_line.join(f'{key}={getattr(self, key)}' for key in self._printable_fields)})" if __name__ == '__main__': string = sys.argv[1] s = StrStruct.from_address(id(string)) print(s)

और यहां तक कि दुभाषिया को "तोड़", जैसा कि आपने पिछले भाग में किया था।

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

ऐसा करने के लिए, ऊपर वर्णित कोड को निम्न में बदलें:

 def make_some_magic(str1, str2): s1 = StrStruct.from_address(id(str1)) s2 = StrStruct.from_address(id(str2)) s2.data = s1.data if __name__ == '__main__': string = "비빔밥" string2 = "háč" print(string == string2) # False make_some_magic(string, string2) print(string == string2) # True

ये उदाहरण पायथन 3.6 में जोड़े गए स्ट्रिंग प्रक्षेप का उपयोग करते हैं। पायथन ने तुरंत तारों को आउटपुट करने की इस पद्धति पर नहीं आये:% वाक्यविन्यास, प्रारूप, कुछ प्रति जैसे की कोशिश की गई थी (उदाहरणों के साथ अधिक विस्तृत विवरण यहां पाया जा सकता है )।
शायद अपने समय के लिए यह बदलाव (अजगर के 3.8 से पहले अपने `: =` ऑपरेटर के साथ) सबसे विवादास्पद था। चर्चा (और निंदा) दोनों रेडिट और यहां तक कि पीईपी के रूप में आयोजित की गई थी। सुधार / सुधार के विचार आई-लाइनों को जोड़ने के रूप में व्यक्त किए गए थे जिसके लिए उपयोगकर्ता अपने पार्सर लिख सकते हैं, बेहतर नियंत्रण के लिए और एसक्यूएल इंजेक्शन और अन्य समस्याओं से बचने के लिए। हालाँकि, यह परिवर्तन स्थगित कर दिया गया था, ताकि लोगों को एफ-लाइनों की आदत हो और समस्याओं की पहचान हो, यदि कोई हो।

एफ-लाइनों की एक ख़ासियत है (कमियां): आप उनमें स्लेश के साथ विशेष वर्ण निर्दिष्ट नहीं कर सकते, उदाहरण के लिए, '\ n' '\ t'। हालांकि, इसे आसानी से एक अलग लाइन घोषित किया जा सकता है जिसमें विशेष वर्ण होते हैं और इसे f-लाइन से गुजारते हैं, जो ऊपर दिए गए उदाहरण में किया गया था, लेकिन आप नेस्टेड कोष्ठक का उपयोग कर सकते हैं।

 >>> number = 2 >>> precision = 3 >>> f"{number:.{precision}f}" 2.000 # , format     >>> "{:{}f}".format(number, precision) 2.000

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

दो तारों की तुलना करते समय, यह जांचा जाता है कि क्या स्ट्रिंगर्स के संकेत एक ही पते को संदर्भित करते हैं, यदि नहीं, तो चरित्र-दर-वर्ण तुलना या मेमकैंप उन मामलों में शुरू किया जाता है जहां यह अनुमेय है।

 int PyUnicode_Compare(PyObject *left, PyObject *right) { if (PyUnicode_Check(left) && PyUnicode_Check(right)) { if (PyUnicode_READY(left) == -1 || PyUnicode_READY(right) == -1) return -1; /*     */ if (left == right) return 0; return unicode_compare(left, right); //    memcmp }   }

हालाँकि, हैश मान अप्रत्यक्ष रूप से तुलना को प्रभावित करता है। तथ्य यह है कि cpython में, स्ट्रिंग्स को नजरबंद किया जाता है, अर्थात् एक ही शब्दकोश में संग्रहीत किया जाता है। यह सभी पंक्तियों के लिए सही नहीं है, सभी स्थिरांक, शब्दकोश कुंजियाँ, फ़ील्ड और चर, और 20 से कम की लंबाई वाली असिसी लाइनों को नजरबंद किया जाता है।

 if __name__ == '__main__': string = sys.argv[1] string2 = sys.argv[2] print(id(string) == id(string2))

 $ python check_interned.py aa True $ python check_interned.py 비빔밥 비빔밥 False $ python check_interned.py aaaaaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaaa False

और खाली स्ट्रिंग आमतौर पर सिंगलटन है

 static PyUnicodeObject * _PyUnicode_New(Py_ssize_t length) { PyUnicodeObject *unicode; size_t new_size; /* Optimization for empty strings */ if (length == 0 && unicode_empty != NULL) { Py_INCREF(unicode_empty); return (PyUnicodeObject*)unicode_empty; } ... }

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

सीपीथॉन में स्ट्रिंग प्रकार कार्यान्वयन

More articles: