python - पायथन स्ट्रिंग स्वरूपण:% बनाम .format




6 Answers

कुछ ऐसा है जो मॉड्यूल ऑपरेटर (%) नहीं कर सकता, 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
python performance logging string-formatting

पायथन 2.6 ने मौजूदा % ऑपरेटर से थोड़ा अलग वाक्यविन्यास के साथ 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. इसके अलावा जब स्ट्रिंग स्वरूपण पाइथन में होता है? उदाहरण के लिए, यदि मेरा लॉगिंग स्तर उच्च पर सेट किया गया है तो क्या मैं अभी भी निम्नलिखित % ऑपरेशन करने के लिए हिट लेगा? और यदि हां, तो क्या इससे बचने का कोई तरीका है?

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



पायथन 3.6 (2016) के रूप में आप वैरिएबल को बदलने के लिए f-strings का उपयोग कर सकते हैं:

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

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

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




लेकिन कृपया सावधान रहें, अभी मौजूदा कोड में '{}'.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'

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




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

उदाहरण (पायथन 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() विधि का उपयोग करने पर विचार कर सकते हैं।




एक साइड नोट के रूप में, आपको लॉगिंग के साथ नई शैली स्वरूपण का उपयोग करने के लिए प्रदर्शन हिट करने की आवश्यकता नहीं है। आप किसी ऑब्जेक्ट को 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




पायथन संस्करण> = 3.6 के लिए ( पीईपी 498 देखें)

s1='albha'
s2='beta'

f'{s1}{s2:>10}'

#output
'albha      beta'



Related