🚶🏼 🧑🏿‍🤝‍🧑🏿 🎢 "शुद्ध अजगर" पुस्तक। पेशेवरों के लिए प्रोग्रामिंग की सूक्ष्मता

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

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

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

अंश "द क्रेजिएस्ट डिक्शनरी एक्सप्रेशन इन द वेस्ट"

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

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

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

>>> {True: '', 1: '', 1.0: ''}

मैं यहाँ इंतज़ार करूँगा ...

ठीक है, तैयार हो?

पायथन इंटरप्रेटर सत्र में उपरोक्त शब्दकोश अभिव्यक्ति का मूल्यांकन करते समय हमें निम्नलिखित परिणाम मिलते हैं:

 >>> {True: '', 1: '', 1.0: ''} {True: ''}

मैं स्वीकार करता हूं, जब मैंने पहली बार यह परिणाम देखा, तो मैं बहुत दुखी हुआ। लेकिन जब आप यहां हो रहे हैं, तब आप एक इत्मीनान से कदम-दर-चरण अध्ययन करेंगे। आइए विचार करें कि हमें यह क्यों मिला, मुझे कहना होगा, बहुत सहज परिणाम नहीं।

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

फिर, जब हम इसे भागों में विघटित करते हैं, तो हमारी शब्दकोश अभिव्यक्ति निर्देशों के निम्नलिखित अनुक्रम के बराबर होगी जो क्रम में निष्पादित होते हैं:

 >>> xs = dict() >>> xs[True] = '' >>> xs[1] = '' >>> xs[1.0] = ''

अजीब तरह से, पायथन इस शब्दकोश उदाहरण में इस्तेमाल की जाने वाली सभी कुंजियों को समान मानता है:

 >>> True == 1 == 1.0 True

ठीक है, लेकिन एक मिनट रुकिए। मुझे यकीन है कि आप सहज रूप से उस 1.0 == 1 को स्वीकार कर सकते हैं, लेकिन सच को भी 1 के बराबर क्यों माना जाता है? पहली बार जब मैंने इस शब्दकोश की अभिव्यक्ति देखी, तो यह वास्तव में मुझे हैरान कर गया।

पायथन डॉक्यूमेंटेशन में थोड़ा सा रमते हुए, मुझे पता चला कि पायथन बूल टाइप को इंट टाइप के उपवर्ग के रूप में मानता है। पायथन 2 और पायथन 3 में यह मामला है:

बूलियन प्रकार पूर्णांक प्रकार का एक उपप्रकार है, और बूलियन मान व्यवहार करते हैं, क्रमशः, मानों के रूप में लगभग सभी संदर्भों में 0 और 1, अपवाद के साथ कि जब एक स्ट्रिंग प्रकार में परिवर्तित किया जाता है, तो स्ट्रिंग मानों को क्रमशः 'गलत' या 'सही' लौटाया जाता है। '।

और हां, इसका मतलब यह है कि पायथन में, बूलियन मूल्यों को तकनीकी रूप से सूची या टुपल सूचक के रूप में इस्तेमाल किया जा सकता है:

 >>> ['', ''][True] ''

लेकिन आपको शायद इस तरह के तार्किक चर का उपयोग स्पष्टता (और आपके सहयोगियों के मानसिक स्वास्थ्य) के नाम पर नहीं करना चाहिए।

एक तरह से या किसी अन्य, हमारे शब्दकोश अभिव्यक्ति के लिए वापस।

पायथन भाषा के लिए, ये सभी मूल्य - ट्रू, 1 और 1.0 - समान शब्दकोश कुंजी का प्रतिनिधित्व करते हैं। जब दुभाषिया एक शब्दकोश अभिव्यक्ति का मूल्यांकन करता है, तो यह बार-बार ट्रू कुंजी के मूल्य को अधिलेखित करता है। यह बताता है कि बहुत अंत में परिणामी शब्दकोश में केवल एक कुंजी क्यों है।

इससे पहले कि हम आगे बढ़ें, मूल शब्दकोश अभिव्यक्ति पर एक और नज़र डालें:

 >>> {True: '', 1: '', 1.0: ''} {True: ''}

क्यों हम अभी भी यहाँ कुंजी के रूप में सच हो रहे हैं? बहुत अंत में बार-बार असाइनमेंट के कारण कुंजी भी 1.0 में नहीं बदलनी चाहिए?

पायथन इंटरप्रेटर के स्रोत कोड में थोड़ा शोध करने के बाद, मुझे पता चला कि जब कोई नया मान किसी महत्वपूर्ण वस्तु से जुड़ा होता है, तो पायथन खुद को इस मुख्य वस्तु को अपडेट नहीं करता है:

 >>> ys = {1.0: ''} >>> ys[True] = '' >>> ys {1.0: ''}

बेशक, यह एक प्रदर्शन अनुकूलन के रूप में समझ में आता है: यदि चाबियाँ समान मानी जाती हैं, तो मूल अपडेट को बर्बाद करने का समय क्यों?
पिछले उदाहरण में, आपने देखा कि कुंजी के रूप में मूल ट्रू ऑब्जेक्ट को कभी प्रतिस्थापित नहीं किया जाता है। इस कारण से, शब्दकोश का स्ट्रिंग प्रतिनिधित्व अभी भी कुंजी को ट्रू (1 या 1.0 के बजाय) के रूप में प्रिंट करता है।

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

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

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

यह तथ्य आपको त्वरित खोज कार्य करने की अनुमति देता है। लुकअप तालिका में कुंजी हैश मान ढूँढना अन्य कुंजी के साथ पूर्ण कुंजी ऑब्जेक्ट की तुलना करने और एक तुल्यता जांच करने की तुलना में बहुत तेज है।

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

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

 class AlwaysEquals: def __eq__(self, other): return True def __hash__(self): return id(self)

इस वर्ग की विशेषता दो पहलुओं से है।

सबसे पहले, क्योंकि __eq__ डंडर विधि हमेशा सही होती है, इस वर्ग के सभी उदाहरण किसी भी के बराबर होने का दिखावा करते हैं:

 >>> AlwaysEquals() == AlwaysEquals() True >>> AlwaysEquals() == 42 True >>> AlwaysEquals() == '?' True

और दूसरी बात, ऑलवेजइकल्स का प्रत्येक उदाहरण आईडी द्वारा निर्मित एक अद्वितीय हैश मान भी लौटाएगा () अंतर्निहित फ़ंक्शन:

 >>> objects = [AlwaysEquals(), AlwaysEquals(), AlwaysEquals()] >>> [hash(obj) for obj in objects] [4574298968, 4574287912, 4574287072]

पायथन में, आईडी () फ़ंक्शन रैम में किसी ऑब्जेक्ट का पता देता है, जो अद्वितीय होने की गारंटी है।

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

और, जैसा कि आप देख सकते हैं, निम्नलिखित उदाहरण में कुंजियाँ मेल नहीं खाती हैं, हालांकि तुलना हमेशा उन्हें एक दूसरे के समकक्ष दिखाएगी:

 >>> {AlwaysEquals(): '', AlwaysEquals(): ''} { <AlwaysEquals object at 0x110a3c588>: '', <AlwaysEquals object at 0x110a3cf98>: '' }

हम इस विचार को दूसरी तरफ से भी देख सकते हैं और जाँच सकते हैं कि क्या वही हैश मान लौटाना कुंजी को लिखने के लिए मजबूर करने का पर्याप्त कारण है:

 class SameHash: def __hash__(self): return 1

समाहश वर्ग के उदाहरणों की तुलना करने पर उन्हें एक दूसरे के समकक्ष नहीं दिखाया जाएगा, लेकिन वे सभी 1 के समान हैश होंगे:

 >>> a = SameHash() >>> b = SameHash() >>> a == b False >>> hash(a), hash(b) (1, 1)

आइए देखते हैं कि जब हम समहैश श्रेणी के उदाहरणों को शब्दकोश कुंजियों के रूप में उपयोग करने का प्रयास करते हैं तो पायथन शब्दकोश कैसे प्रतिक्रिया देते हैं:

 >>> {a: 'a', b: 'b'} { <SameHash instance at 0x7f7159020cb0>: 'a', <SameHash instance at 0x7f7159020cf8>: 'b' }

जैसा कि इस उदाहरण से पता चलता है, "कुंजी के अधिलेखित होने" का प्रभाव न केवल हैश मूल्य संघर्ष के कारण होता है।

डिस्क्स एक समतुल्यता जाँच करते हैं और दो मूल्य समान हैं, यह निर्धारित करने के लिए हैश मान की तुलना करें। आइए हमारे अध्ययन के परिणामों को संक्षेप में प्रस्तुत करने का प्रयास करें।

शब्दकोश अभिव्यक्ति {True: 'Yes', 1: 'no', 1.0: 'हो सकता है'} की गणना {True: 'संभव'} के रूप में की गई है, क्योंकि इस उदाहरण की सभी कुंजियों की तुलना, True, 1 और 1.0 से होती है, उन्हें दिखाएंगे। एक दूसरे के समतुल्य, और उन सभी के पास समान हैश मूल्य है:

 >>> True == 1 == 1.0 True >>> (hash(True), hash(1), hash(1.0)) (1, 1, 1)

शायद अब यह बहुत आश्चर्य की बात नहीं है कि हमें शब्दकोश की अंतिम स्थिति के रूप में सिर्फ एक परिणाम मिला है:

 >>> {True: '', 1: '', 1.0: ''} {True: ''}

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

यदि आपको इस अनुभाग में क्या हो रहा है, यह समझने में कठिन समय है, तो पायथन दुभाषिया सत्र में सभी कोड उदाहरणों के साथ प्रयोग करने का प्रयास करें। आपको पायथन भाषा के आंतरिक तंत्र के अपने ज्ञान का विस्तार करके पुरस्कृत किया जाएगा।

»पुस्तक की अधिक जानकारी प्रकाशक की वेबसाइट पर पाई जा सकती है
» सामग्री
» अंश

फेरीवालों के लिए कूपन पर 20% की छूट - पायथन

"शुद्ध अजगर" पुस्तक। पेशेवरों के लिए प्रोग्रामिंग की सूक्ष्मता »

अंश "द क्रेजिएस्ट डिक्शनरी एक्सप्रेशन इन द वेस्ट"

More articles: