दिलचस्प पोस्ट
एचटीएमएल युक्त टैग छोडो, टैग को अनदेखा करें निष्पादन योग्य अमान्य पात्रताओं के साथ हस्ताक्षर किए गए थे मौजूदा डेटाबेस से asp.net MVC5 पहचान प्रमाणन कैसे जोड़ना क्या span /> का प्रयोग बंद हो सकता है? लोक बनाम आईएलओक बनाम ix बनाम बनाम आईट? यह कैसे निजी चर सुलभ है? एकाधिक कार्यपत्रकों के साथ एक्सेल में रिपोर्टिंग सेवाएं निर्यात रीसायट करने के लिए mysql समय को कम करने और डिस्क पर टीएमपी लिखना बाश में दो फ्लोटिंग प्वाइंट नंबर की तुलना कैसे करें? वास्तव में एमईएफ एक डि आईओसी कंटेनर क्यों नहीं है? जीसीसी मेसेफाइल त्रुटि: "लक्ष्य बनाने के लिए कोई नियम नहीं है …" समारोह eregi () नापसंद है क्रोम रेंडरिंग समस्या शरीर में उल के साथ निश्चित स्थिति एंकर एक्सएमएल सीरियललाइज़ेशन के लिए स्ट्रिंगर्राइटर का उपयोग करना एक स्क्रिप्ट टैग के भीतर आवश्यक सीडीएटीए अनुभाग कब है?

पायथन स्ट्रिंग स्वरूपण:% बनाम। प्रारूप

पायथन 2.6 ने str.format() ऑपरेटर से थोड़ा भिन्न सिंटैक्स के साथ str.format() विधि की शुरुआत की। कौन सा बेहतर है और किस परिस्थितियों के लिए?

  1. निम्नलिखित प्रत्येक विधि का उपयोग करता है और इसका एक ही परिणाम है, तो क्या अंतर है?

     #!/usr/bin/python sub1 = "python string!" sub2 = "an arg" a = "i am a %s" % sub1 b = "i am a {0}".format(sub1) c = "with %(kwarg)s!" % {'kwarg':sub2} d = "with {kwarg}!".format(kwarg=sub2) print a # "i am a python string!" print b # "i am a python string!" print c # "with an arg!" print d # "with an arg!" 
  2. इसके अलावा जब स्ट्रिंग फॉर्मेटिंग पायथन में होती है? उदाहरण के लिए, यदि मेरा लॉगिंग स्तर HIGH पर सेट है, तो क्या मैं निम्नलिखित % ऑपरेशन को चलाने के लिए अभी भी हिट लेगा? और यदि हां, तो क्या इस से बचने का कोई तरीका है?

     log.debug("some debug info: %s" % some_info) 

वेब के समाधान से एकत्रित समाधान "पायथन स्ट्रिंग स्वरूपण:% बनाम। प्रारूप"

अपने पहले प्रश्न का उत्तर देने के लिए …। .format कई तरीकों से अधिक परिष्कृत लगता है % बारे में एक कष्टप्रद बात यह भी है कि वह या तो एक वैरिएबल या ट्यूपल कैसे ले सकता है आपको लगता था कि निम्नलिखित हमेशा काम करेंगे:

 "hi there %s" % name 

फिर भी, यदि name होना (1, 2, 3) , तो वह एक TypeError फेंक देगा। यह हमेशा प्रिंट करने की गारंटी देने के लिए आपको करना होगा

 "hi there %s" % (name,) # supply the single argument as a single-item tuple 

जो सिर्फ बदसूरत है .format में उन मुद्दों पर नहीं है इसके अलावा दूसरे उदाहरण में, आपने दिया था। .format उदाहरण बहुत साफ दिख रहा है।

आप इसका उपयोग क्यों नहीं करेंगे?

  • इसके बारे में नहीं जानते (मुझे पढ़ने से पहले)
  • पायथन 2.5 के साथ संगत होना है

आपके दूसरे प्रश्न का उत्तर देने के लिए, स्ट्रिंग फ़ॉर्मेटिंग किसी अन्य ऑपरेशन के साथ-साथ स्ट्रिंग स्वरूपण अभिव्यक्ति के मूल्यांकन के दौरान होती है। और पायथन, आलसी भाषा नहीं है, कार्यों को कॉल करने से पहले अभिव्यक्तियों का मूल्यांकन करता है, इसलिए आपके log.debug उदाहरण में, "some debug info: %s"%some_info पहले का मूल्यांकन करेगा, जैसे "some debug info: roflcopters are active" , तो वह स्ट्रिंग log.debug()log.debug() पास हो log.debug()

कुछ मॉड्यूलो ऑपरेटर (%) ऐसा नहीं कर सकता, afaik:

 tu = (12,45,22222,103,6) print '{0} {2} {1} {2} {3} {2} {4} {2}'.format(*tu) 

परिणाम

 12 22222 45 22222 103 22222 6 22222 

बहुत उपयोगी।

एक अन्य बिंदु: फ़ंक्शन format() , एक फ़ंक्शन होने के नाते, अन्य कार्यों में तर्क के रूप में उपयोग किया जा सकता है:

 li = [12,45,78,784,2,69,1254,4785,984] print map('the number is {}'.format,li) print from datetime import datetime,timedelta once_upon_a_time = datetime(2010, 7, 1, 12, 0, 0) delta = timedelta(days=13, hours=8, minutes=20) gen =(once_upon_a_time +x*delta for x in xrange(20)) print '\n'.join(map('{:%Y-%m-%d %H:%M:%S}'.format, gen)) 

का परिणाम:

 ['the number is 12', 'the number is 45', 'the number is 78', 'the number is 784', 'the number is 2', 'the number is 69', 'the number is 1254', 'the number is 4785', 'the number is 984'] 2010-07-01 12:00:00 2010-07-14 20:20:00 2010-07-28 04:40:00 2010-08-10 13:00:00 2010-08-23 21:20:00 2010-09-06 05:40:00 2010-09-19 14:00:00 2010-10-02 22:20:00 2010-10-16 06:40:00 2010-10-29 15:00:00 2010-11-11 23:20:00 2010-11-25 07:40:00 2010-12-08 16:00:00 2010-12-22 00:20:00 2011-01-04 08:40:00 2011-01-17 17:00:00 2011-01-31 01:20:00 2011-02-13 09:40:00 2011-02-26 18:00:00 2011-03-12 02:20:00 

यह मानते हुए कि आप पायथन के logging मॉड्यूल का उपयोग कर रहे हैं, तो आप स्ट्रिंग फ़ॉर्मेटिंग तर्क को अपने आप स्वरूपण करने के बजाय .debug() विधि के तर्क के रूप में पारित कर सकते हैं:

 log.debug("some debug info: %s", some_info) 

जो स्वरूपण करने से बचा जाता है जब तक कि लॉगर वास्तव में कुछ लॉग करता है

पायथन 3.6 के रूप में आप नामों से तारों में परिवर्तन कर सकते हैं:

 >>> origin = "London" >>> destination = "Paris" >>> f"from {origin} to {destination}" 'from London to Paris' 

नोट f" उपसर्ग। यदि आप इसे अजगर 3.5 या पहले में देखते हैं, तो आपको एक SyntaxError मिलेगा।

https://docs.python.org/3.6/reference/lexical_analysis.html#f-strings देखें।

पीईपी 3101 पायथन 3 में नए, उन्नत स्ट्रिंग फॉर्मेटिंग के साथ % ऑपरेटर के प्रतिस्थापन का प्रस्ताव करता है, जहां यह डिफ़ॉल्ट होगा।

लेकिन कृपया सावधान रहें, बस अब मुझे एक समस्या मिली है जब सभी % को बदलने की कोशिश करते हुए। मौजूदा कोड में '{}'.format(unicode_string) : '{}'.format(unicode_string) यूनिकोड_स्ट्रिंग एन्कोड करने का प्रयास करेगा और शायद असफल हो जायेगी।

बस इस पायथन इंटरैक्टिव सत्र लॉग को देखें:

 Python 2.7.2 (default, Aug 27 2012, 19:52:55) [GCC 4.1.2 20080704 (Red Hat 4.1.2-48)] on linux2 ; s='й' ; u=u'й' ; s '\xd0\xb9' ; u u'\u0439' 

s सिर्फ एक स्ट्रिंग है (पायथन 3 में 'बाइट सरणी' कहा जाता है) और u एक यूनिकोड स्ट्रिंग है (पायथन 3 में 'स्ट्रिंग' कहलाता है):

 ; '%s' % s '\xd0\xb9' ; '%s' % u u'\u0439' 

जब आप यूनिकोड ऑब्जेक्ट को % ऑपरेटर के पैरामीटर के रूप में देते हैं तो यह यूनिकोड स्ट्रिंग का उत्पादन करेगा, भले ही मूल स्ट्रिंग यूनिकोड न हो:

 ; '{}'.format(s) '\xd0\xb9' ; '{}'.format(u) Traceback (most recent call last): File "<stdin>", line 1, in <module> UnicodeEncodeError: 'latin-1' codec can't encode character u'\u0439' in position 0: ordinal not in range(256) 

लेकिन .format फ़ंक्शन "यूनिकोडईएनकोड त्रुटि" बढ़ाएगा:

 ; u'{}'.format(s) u'\xd0\xb9' ; u'{}'.format(u) u'\u0439' 

और यह यूनिकोड तर्क के साथ ठीक काम करेगा यदि मूल स्ट्रिंग यूनिकोड हो।

 ; '{}'.format(u'i') 'i' 

या यदि तर्क स्ट्रिंग को एक स्ट्रिंग में परिवर्तित किया जा सकता है (तथाकथित 'बाइट सरणी')

फिर भी .format का एक अन्य लाभ (जो मुझे जवाब में नहीं दिखाई देता है): यह ऑब्जेक्ट गुण ले सकता है

 In [12]: class A(object): ....: def __init__(self, x, y): ....: self.x = x ....: self.y = y ....: In [13]: a = A(2,3) In [14]: 'x is {0.x}, y is {0.y}'.format(a) Out[14]: 'x is 2, y is 3' 

या, एक कीवर्ड तर्क के रूप में:

 In [15]: 'x is {ax}, y is {ay}'.format(a=a) Out[15]: 'x is 2, y is 3' 

जहां तक ​​मैं बता सकता हूं, यह संभव नहीं है %

जैसा कि मैंने आज की खोज की है, % माध्यम से तारण करने का पुराना तरीका Decimal , अजगर का दशमलव दशमलव बिंदु और फ्लोटिंग बिंदु अंकगणित, बॉक्स के बाहर का समर्थन नहीं करता।

उदाहरण (Python 3.3.5 का प्रयोग करके):

 #!/usr/bin/env python3 from decimal import * getcontext().prec = 50 d = Decimal('3.12375239e-24') # no magic number, I rather produced it by banging my head on my keyboard print('%.50f' % d) print('{0:.50f}'.format(d)) 

आउटपुट:

0.00000000000000000000000312375239000000009907464850 0.00000000000000000000000312375239000000000000000000

निश्चित रूप से कार्य-आस-पास हो सकते हैं लेकिन आप अभी भी format() पद्धति का उपयोग करने पर विचार कर सकते हैं।

% मेरे परीक्षण से format तुलना में बेहतर प्रदर्शन देता है

टेस्ट कोड:

पायथन 2.7.2:

 import timeit print 'format:', timeit.timeit("'{}{}{}'.format(1, 1.23, 'hello')") print '%:', timeit.timeit("'%s%s%s' % (1, 1.23, 'hello')") 

परिणाम:

 > format: 0.470329046249 > %: 0.357107877731 

पायथन 3.5.2

 import timeit print('format:', timeit.timeit("'{}{}{}'.format(1, 1.23, 'hello')")) print('%:', timeit.timeit("'%s%s%s' % (1, 1.23, 'hello')")) 

परिणाम

 > format: 0.5864730989560485 > %: 0.013593495357781649 

यह पायथन 2 में दिखता है, अंतर छोटा है, जबकि पायथन 3 में, % format से बहुत तेज है।

धन्यवाद कोड के लिए क्रिस कॉगडन।

एक साइड नोट के रूप में, लॉगिंग के साथ आपको नई स्टाइल फॉर्मेटिंग का उपयोग करने के लिए प्रदर्शन हिट लेने की आवश्यकता नहीं है। आप logging.debug , logging.info , आदि के लिए किसी भी ऑब्जेक्ट पास कर सकते हैं जो __str__ जादुई विधि का कार्यान्वयन करते हैं। जब लॉगिंग मॉड्यूल ने निर्णय लिया है कि उसे आपके संदेश ऑब्जेक्ट को छोड़ना चाहिए (जो भी हो), ऐसा करने से पहले उसे str(message_object) कहते हैं तो आप ऐसा कुछ कर सकते हैं:

 import logging class NewStyleLogMessage(object): def __init__(self, message, *args, **kwargs): self.message = message self.args = args self.kwargs = kwargs def __str__(self): args = (i() if callable(i) else i for i in self.args) kwargs = dict((k, v() if callable(v) else v) for k, v in self.kwargs.items()) return self.message.format(*args, **kwargs) N = NewStyleLogMessage # Neither one of these messages are formatted (or calculated) until they're # needed # Emits "Lazily formatted log entry: 123 foo" in log logging.debug(N('Lazily formatted log entry: {0} {keyword}', 123, keyword='foo')) def expensive_func(): # Do something that takes a long time... return 'foo' # Emits "Expensive log entry: foo" in log logging.debug(N('Expensive log entry: {keyword}', keyword=expensive_func)) 

यह सब पायथन 3 प्रलेखन ( https://docs.python.org/3/howto/logging-cookbook.html#formatting-styles ) में वर्णित है। हालाँकि, यह पायथन 2.6 के साथ भी काम करेगा ( https://docs.python.org/2.6/library/logging.html#using-arbitrary-objects-as-messages )।

इस तकनीक का उपयोग करने के एक लाभ, तथ्य के अलावा, कि यह स्वरूपण-शैली अज्ञेयवादी है, यह आलसी मूल्यों की अनुमति देता है जैसे कि ऊपर महंगी_फंक्शन यह पायथन डॉक्स में दिए गए सलाह के लिए एक और अधिक सुरुचिपूर्ण विकल्प प्रदान करता है: https://docs.python.org/2.6/library/logging.html#optimization

एक स्थिति है जहां % मदद कर सकता है जब आप regex अभिव्यक्तियाँ स्वरूपण कर रहे हैं उदाहरण के लिए,

 '{type_names} [az]{2}'.format(type_names='triangle|square') 

IndexError उठाता है इस स्थिति में, आप उपयोग कर सकते हैं:

 '%(type_names)s [az]{2}' % {'type_names': 'triangle|square'} 

यह regex को '{type_names} [az]{{2}}' रूप में लिखने से बचा जाता है यह उपयोगी हो सकता है जब आपके पास दो regexes हों, जहां एक को अकेले प्रारूप के बिना प्रयोग किया जाता है, लेकिन दोनों का समापन स्वरूपित है।