दिलचस्प पोस्ट
एक MySQL डाटाबेस के प्रत्येक टेबल से सभी क्षेत्रों में खोजें प्रक्षेपक में अपेक्षित स्थितियां Form_for, form_tag के बीच का अंतर? कैसे VBA में स्ट्रिंग कंसेटनेट करें अजगर पुनरावर्ती और रिटर्न स्टेटमेंट एक निश्चित उपसमुच्चय आकार के साथ योग-सबसेट पावरशेल – प्रारंभ-प्रक्रिया और सीएमडीलाइन स्विच विभिन्न उत्पाद स्वादों के लिए विभिन्न निर्भरता को परिभाषित करने के तरीके जावा स्क्रिप्ट में एक रोमन अंक में कोई संख्या परिवर्तित करें कक्षा के भीतर पायथन कॉल फंक्शन SQL सर्वर: सभी अपर केस को उचित केस / शीर्षक केस में बनायें एक ही निर्देशिका या उप निर्देशिका के भीतर वर्ग को कैसे आयात करें? रूबी MYSQL2 मणि ​​विंडोज 7 पर स्थापना व्युत्पन्न टेम्पलेट क्लास का आधार टेम्प्लेट क्लास 'पहचानकर्ताओं तक पहुंच क्यों नहीं है? अवैध मॉनीटरस्टेट अपॉक्शन्स ऑन प्रतीक्षा () कॉल करें

पायथन: "..% (var) s .." का प्रयोग कर रहा है% स्थानीय लोगों () एक अच्छा अभ्यास है?

मैंने इस पैटर्न (या विरोधी-पैटर्न) की खोज की और मैं इसके साथ बहुत खुश हूं।

मुझे लगता है यह बहुत चुस्त है:

def example(): age = ... name = ... print "hello %(name)s you are %(age)s years old" % locals() 

कभी-कभी मैं अपने चचेरे भाई का उपयोग करता हूं:

 def example2(obj): print "The file at %(path)s has %(length)s bytes" % obj.__dict__ 

मुझे एक कृत्रिम टपल और गिनती मापदंड बनाने और ट्पले के अंदर% s मिलान स्थिति रखने की आवश्यकता नहीं है।

क्या आपको यह पसंद है? क्या आप इसका प्रयोग करेंगे? हां / नहीं, कृपया समझाएं

Solutions Collecting From Web of "पायथन: "..% (var) s .." का प्रयोग कर रहा है% स्थानीय लोगों () एक अच्छा अभ्यास है?"

यह छोटा अनुप्रयोगों के लिए ठीक है और कथित तौर पर "एक-ऑफ" स्क्रिप्ट, विशेष रूप से @ कोआइज़र.से द्वारा वर्णित vars वृद्धि के साथ और @ रेडगलीफ़ द्वारा उल्लिखित प्रारूप प्रारूप।

हालांकि, लंबी रखरखाव के जीवन और कई रखरखाव वाले बड़े अनुप्रयोगों के लिए इस अभ्यास को रखरखाव सिरदर्द हो सकता है, और मुझे लगता है कि जहां @ एस लोटल का उत्तर आ रहा है। मुझे इसमें शामिल कुछ मुद्दों की व्याख्या करें, क्योंकि वे ऐसे किसी व्यक्ति के लिए स्पष्ट नहीं हो सकते हैं जो बड़े अनुप्रयोगों (या ऐसे जानवरों के लिए पुन: उपयोग करने योग्य घटकों) के विकास और बनाए रखने के निशान नहीं रखते हैं।

एक "गंभीर" आवेदन में, आपके प्रारूप स्ट्रिंग को हार्ड-कोडित नहीं होगा – या, यदि आपके पास था, तो यह कुछ रूप में होगा जैसे कि _('Hello {name}.') , जहां गेटटेक्स्ट से आता है या समान I18n / L10n फ्रेमवर्क मुद्दा यह है कि ऐसे अनुप्रयोग (या पुन: उपयोग करने योग्य मॉड्यूल जो इस तरह के अनुप्रयोगों में उपयोग किए जा सकते हैं) को अंतर्राष्ट्रीयकरण (AKA i18n) और स्थानीकरण (AKA L10n) का समर्थन करना चाहिए: आप चाहते हैं कि आपका एप्लिकेशन "हैलो पॉल" देशों और संस्कृतियों, कुछ अन्य लोगों में "होला पॉल", अभी तक दूसरों में "सीयाओ पॉल", और आगे भी। इसलिए, वर्तमान स्थानीयकरण सेटिंग्स के आधार पर, प्रारूप स्ट्रिंग रनटाइम पर किसी अन्य के साथ स्वत: प्रतिस्थापित हो जाती है; कड़ी मेहनत के होने के बजाय, यह किसी प्रकार के डेटाबेस में रहता है सभी उद्देश्यों और प्रयोजनों के लिए, कल्पना कीजिए कि प्रारूप स्ट्रिंग हमेशा एक चर, एक स्ट्रिंग नहीं, शाब्दिक होती है।

तो, आपके पास क्या अनिवार्य रूप से है

 formatstring.format(**locals()) 

और आप तुच्छ नहीं देख सकते हैं कि कौन-से स्थानीय नाम फ़ॉर्मेटिंग का उपयोग करना होगा। आपको एल 10 एन डाटाबेस खोलना और ख़याल करना होगा, अलग-अलग सेटिंग्स में प्रारूप स्ट्रिंग का उपयोग करने जा रहे हैं, उन सभी को सत्यापित करें।

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

यदि आपके पास शानदार एकीकरण / प्रतिगमन परीक्षण है, तो टूटना बीटा रिलीज़ से पहले पकड़ा जाएगा – लेकिन क्यूए आपके लिए चीख देगा और रिलीज में देरी होगी … और, ईमानदारी से रहें, जबकि इकाई परीक्षण के साथ 100% कवरेज का लक्ष्य रखना उचित है, यह वास्तव में एकीकरण परीक्षण के साथ नहीं है, एक बार जब आप सेटिंग्स [[एल 10 एन के लिए और कई और कारणों के लिए] के संयोजी विस्फोट पर विचार करें और सभी निर्भरता के समर्थित संस्करण तो, आप केवल तुच्छ को तोड़ने का जोखिम नहीं लेते क्योंकि "वे क्यूए में पकड़े जाते हैं" (यदि आप करते हैं, तो आप बड़े एप या पुन: उपयोग करने योग्य घटकों को विकसित करने वाले वातावरण में लंबे समय तक नहीं रह सकते हैं 😉

इसलिए, व्यवहार में, आप "नाम" स्थानीय चरखी कभी नहीं हटाएंगे, भले ही उपयोगकर्ता अनुभव लोगों ने लंबे समय तक स्विच किया है कि एक अधिक उपयुक्त "वेलकम, ड्रेड ओव्हरलोड!" (और उपयुक्त रूप से L10n'ed संस्करणों) सभी क्योंकि आप locals() लिए गए locals()

इसलिए आप जिस तरह से अपने कोड को बनाए रखने और संपादित करने की आपकी क्षमता को गलत तरीके से क्रुद्ध कर रहे हैं – और हो सकता है कि "नाम" स्थानीय वैरिएबल केवल इसलिए मौजूद है क्योंकि यह किसी डीबी या पसंद से लाया गया है, इसलिए इसे (या कुछ अन्य स्थानीय) के आसपास सिर्फ क्रूरता नहीं है, यह आपके प्रदर्शन को भी कम कर रहा है क्या locals() की सतह सुविधा locals() मूल्य है ? -)

लेकिन रुको, बुरा है! कई उपयोगी सेवाओं के बीच एक lint एक प्रोग्राम (जैसे, उदाहरण के लिए, pylint ) आपके लिए कर सकता है, आपको अप्रयुक्त स्थानीय चर के बारे में चेतावनी देना है (इच्छा है कि यह अप्रयुक्त विश्व के लिए भी कर सकता है, लेकिन पुन: प्रयोज्य घटकों के लिए, यह बस एक बालक बहुत मुश्किल 😉 इस तरह आप सबसे प्रायः गलत वर्तनी को पकड़ लेंगे जैसे if ...: nmae = ... बहुत तेजी से और सस्ते में, एक इकाई-परीक्षण को तोड़कर और सफ़ाई काम करने के बजाय यह पता लगाने के लिए कि यह क्यों टूट गया (आप जुनूनी हैं , व्यापक इकाई परीक्षण जो अंत में इसे पकड़ेंगे, ठीक है? -) – लिंट आपको एक अप्रयुक्त स्थानीय चर के बारे में बताएगा और आप तुरंत इसे ठीक कर देंगे।

लेकिन यदि आपके पास आपके कोड में एक blah.format(**locals()) , या समतुल्य रूप से एक blah % locals() … आप blah.format(**locals()) , दोस्त! -) यह कैसे जानना nmae है कि क्या nmae में है वास्तव में एक अप्रयुक्त चर, या वास्तव में यह जो भी बाहरी फ़ंक्शन या विधि आप locals() से गुजर रहे हैं द्वारा उपयोग किया जाता है? ऐसा नहीं है – या तो यह किसी भी तरह से चेतावनी देने जा रहा है (अंततः आपको ऐसी चेतावनियों को अनदेखा करने या अक्षम करने के लिए प्रेरित करता है), या यह कभी भी चेतावनी नहीं देगा (उसी अंतिम प्रभाव के साथ: कोई चेतावनी नहीं 😉 ।

इसकी तुलना "निहित से बेहतर है" विकल्प के साथ तुलना करें …:

 blah.format(name=name) 

वहां – कोई भी रखरखाव, प्रदर्शन, और आई-आई-हम्परिंग-लिंट चिंताओं में से कोई भी अधिक लागू नहीं होता है; आनंद! आप इसे तुरंत संबंधित सभी लोगों के लिए स्पष्ट कर देते हैं (लिंट शामिल 😉 वास्तव में जो स्थानीय चर का उपयोग किया जा रहा है, और वास्तव में किस उद्देश्य से

मैं जा सकता था, लेकिन मुझे लगता है कि यह पोस्ट पहले से ही बहुत लंबा है 😉

तो, संक्षेप: " γνῶθι σεαυτόν !" हम्म, मेरा मतलब है, "खुद को जानो!" और "खुद" द्वारा मेरा मतलब है "आपके कोड का उद्देश्य और दायरा" यदि यह 1-ऑफ-या-थॉटबेट्स चीज़ है, तो कभी भी i18n और L10n'd नहीं होगा, भविष्य में रखरखाव की सबसे मुश्किल आवश्यकता होगी, कभी भी एक व्यापक संदर्भ, आदि, में पुन: उपयोग नहीं किया जाएगा, फिर आगे बढ़ो और locals() उपयोग करें locals() अपनी छोटी लेकिन साफ ​​सुविधा के लिए; यदि आप अन्यथा जानते हैं, या यहां तक ​​कि अगर आप पूरी तरह से निश्चित नहीं हैं, तो सावधानी के पक्ष में गलती करें और चीजों को और अधिक स्पष्ट करें – आप जो भी जा रहे हैं, उसके बारे में वर्तनी की छोटी असुविधा का सामना करें, और सभी परिणामी फायदे का आनंद लें।

बीटीडब्लू, यह सिर्फ उन उदाहरणों में से एक है जहां पायथन " locals() , एक-बंद, अन्वेषणपूर्ण, हो सकता है इंटरैक्टिव" प्रोग्रामिंग ( locals() से परे locals() बढ़ने वाले खतरनाक उपयुक्तता को अनुमति और समर्थन प्रदान करने के लिए दोनों का समर्थन करने का प्रयास कर रहा है – import * eval , exec , और कई अन्य तरीकों से आप सुविधा के लिए नामस्थान और जोखिम रखरखाव प्रभावों को मुस्करा सकते हैं), साथ ही साथ "बड़े, पुन: उपयोग करने योग्य, एंटरप्राइज़-वाई" ऐप्स और घटकों यह दोनों पर बहुत अच्छा काम कर सकता है, लेकिन तभी आप "अपने आप को जानते हैं" और "सुविधा" भागों का उपयोग करने से बचें, जब तक कि आप पूरी तरह से निश्चित हैं कि आप उन्हें खरीद सकते हैं। अधिक बार नहीं, मुख्य विचार यह है, "यह मेरे नामस्थानों के साथ क्या करता है, और उनके गठन और जागरूकता के बारे में जागरूकता, संकलक, लिंट और सी, मानव पाठक और रखरखाव, और इतने पर?"।

याद रखें, "नामस्थान एक महान विचार है – चलो उन में से अधिक करते हैं!" अजगर का ज़ेन कैसे निष्कर्ष निकाला है … लेकिन पायथन, "वयस्कों की सहमति के लिए भाषा" के रूप में, आपको अपने विकास पर्यावरण, लक्ष्य और प्रथाओं के परिणाम के रूप में परिभाषित करता है कि इसका क्या मतलब है की सीमाएं हैं। जिम्मेदारी से इस शक्ति का उपयोग करें! -)

दस लाख वर्षों में कभी नहीं। यह स्पष्ट नहीं है कि स्वरूपण के संदर्भ क्या है: locals में लगभग किसी भी चर का locals हो सकता है self.__dict__ रूप में अस्पष्ट नहीं है। भविष्य के डेवलपर्स को अपने सिर पर खरोंच करने के लिए पूरी तरह से भयानक है कि स्थानीय क्या है और स्थानीय क्या नहीं है।

यह एक जानबूझकर रहस्य है भविष्य में रखरखाव सिरदर्द के साथ अपने संगठन का नेतृत्व क्यों करें?

obj.__dict__ बजाय "चचेरे भाई" के बारे में, यह नए स्ट्रिंग स्वरूपण के साथ बहुत बेहतर दिखता है:

 def example2(obj): print "The file at {o.path} has {o.length} bytes".format(o=obj) 

मैं इसे repr विधियों के लिए बहुत उपयोग करता हूं, उदा

 def __repr__(self): return "{s.time}/{s.place}/{s.warning}".format(s=self) 

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

मैं लिखने की कोई आवश्यकता नहीं है, मुझे लिखने की ज़रूरत नहीं है – कम कोड अधिक कोड से बेहतर है और उदाहरण के लिए locals() का उपयोग करने की यह प्रथा मुझे कम कोड लिखने की अनुमति देती है और यह भी पढ़ने और समझने में बहुत आसान है।

"%(name)s" % <dictionary> या इससे भी बेहतर, "{name}".format(<parameters>) की योग्यता है

  • "% 0s" से अधिक पठनीय हो रहा है
  • तर्क आदेश से स्वतंत्र होने के नाते
  • स्ट्रिंग में सभी तर्कों का उपयोग करने के लिए मजबूर नहीं है

मैं str.format () के पक्ष में होता, क्योंकि यह ऐसा करने का तरीका होना चाहिए जो पायथन 3 में ( पीईपी 3101 के अनुसार), और पहले से ही 2.6 से उपलब्ध है। locals() साथ locals() हालांकि, आपको ऐसा करना होगा:

 print("hello {name} you are {age} years old".format(**locals())) 

अंतर्निर्मित vars([object]) का उपयोग करना ( प्रलेखन ) आपके लिए दूसरा नज़र बेहतर बना सकता है:

 def example2(obj): print "The file at %(path)s has %(length)s bytes" % vars(obj) 

प्रभाव बिल्कुल एक ही है

अब ऐसा करने का एक आधिकारिक तरीका है, पायथन 3.6.0 के रूप में: स्वरूपित स्ट्रिंग लीटरल ।

यह इस तरह काम करता है:

 f'normal string text {local_variable_name}' 

इन के बजाय उदाहरण:

 "hello %(name)s you are %(age)s years old" % locals() "hello {name}s you are {age}s years old".format(**locals()) 

बस ऐसा करें:

 f"hello {name}s you are {age}s years old" 

यहां आधिकारिक उदाहरण है:

 >>> name = "Fred" >>> f"He said his name is {name}." 'He said his name is Fred.' >>> width = 10 >>> precision = 4 >>> value = decimal.Decimal("12.34567") >>> f"result: {value:{width}.{precision}}" # nested fields 'result: 12.35' 

संदर्भ:

  • अजगर 3.6 नया क्या है
  • पीईपी 498
  • भाषा संबंधी विश्लेषण का विवरण