Python Language
स्ट्रिंग स्वरूपण

परिचय

वाक्य - विन्यास

• "{}"। प्रारूप (42) ==> "42"
• "{0}"। प्रारूप (42) ==> "42"
• {{0: .2f} "। प्रारूप (42) ==>" 42.00 "
• "{0: .0f}"। प्रारूप (42.1234) ==> "42"
• {{उत्तर} "। प्रारूप (no_answer = 41, उत्तर = 42) ==>" 42 "
• {{उत्तर: .2f} "। प्रारूप (no_answer = 41, उत्तर = 42) ==>" 42.00 "
• {{[कुंजी]} "। प्रारूप ({'कुंजी': 'मूल्य'}) ==>" मूल्य "
• "{[1]}"। प्रारूप (['शून्य', 'एक', 'दो']) ==> "एक"
• {{उत्तर} = {उत्तर} "। प्रारूप (उत्तर = 42) ==>" 42 = 42 "
• '' .जॉइन (['स्टैक', 'ओवरफ्लो']) ==> "स्टैक ओवरफ्लो"

टिप्पणियों

स्ट्रिंग प्रारूपण की मूल बातें

foo = 1
bar = 'bar'
baz = 3.14

आप आउटपुट स्वरूपित करने के लिए str.format का उपयोग कर सकते हैं। ब्रैकेट जोड़े को तर्कों के साथ उस क्रम में प्रतिस्थापित किया जाता है जिसमें तर्क पारित किए जाते हैं:

print('{}, {} and {}'.format(foo, bar, baz))
# Out: "1, bar and 3.14"

इंडेक्स को कोष्ठक के अंदर भी निर्दिष्ट किया जा सकता है। संख्या str.format फ़ंक्शन (0-आधारित) को दिए गए तर्कों के अनुक्रमित के अनुरूप हैं।

print('{0}, {1}, {2}, and {1}'.format(foo, bar, baz))
# Out: "1, bar, 3.14, and bar"
print('{0}, {1}, {2}, and {3}'.format(foo, bar, baz))
# Out: index out of range error

नामित तर्कों का भी उपयोग किया जा सकता है:

print("X value is: {x_val}. Y value is: {y_val}.".format(x_val=2, y_val=3))
# Out: "X value is: 2. Y value is: 3."

ऑब्जेक्ट विशेषताएँ str.format में पारित होने पर संदर्भित की जा सकती हैं:

class AssignValue(object):
    def __init__(self, value):
        self.value = value
my_value = AssignValue(6)
print('My value is: {0.value}'.format(my_value))  # "0" is optional
# Out: "My value is: 6"

शब्दकोश कुंजियों का उपयोग किया जा सकता है:

my_dict = {'key': 6, 'other_key': 7}
print("My other key is: {0[other_key]}".format(my_dict))  # "0" is optional
# Out: "My other key is: 7"

समान सूची और अपवित्र सूचकांक पर लागू होता है:

my_list = ['zero', 'one', 'two']
print("2nd element is: {0[2]}".format(my_list))  # "0" is optional
# Out: "2nd element is: two"

नोट: str.format अलावा, Python modulo ऑपरेटर % --also को स्ट्रिंग फ़ॉर्मेटिंग या इंटरपोलेशन ऑपरेटर ( PEP 3101 देखें) के रूप में भी प्रस्तुत करता है - स्ट्रिंग्स को फ़ॉर्मेट करने के लिए। str.format % उत्तराधिकारी है और यह अधिक से अधिक लचीलेपन की पेशकश करता है, उदाहरण के लिए कई प्रतिस्थापनों को पूरा करना आसान बनाता है।

तर्क अनुक्रमणिकाओं के अलावा, आप घुंघराले ब्रैकेट के अंदर एक प्रारूप विनिर्देश भी शामिल कर सकते हैं। यह एक अभिव्यक्ति है कि विशेष नियमों का पालन करती है और एक पेट से पहले आना चाहिए है ( : )। प्रारूप विनिर्देश के पूर्ण विवरण के लिए डॉक्स देखें। प्रारूप विनिर्देश का एक उदाहरण संरेखण निर्देश है :~^20 ( ^ केंद्र संरेखण के लिए खड़ा है, कुल चौड़ाई 20, इस चरित्र के साथ भरें:

'{:~^20}'.format('centered')
# Out: '~~~~~~centered~~~~~~'

format % साथ व्यवहार संभव नहीं है, उदाहरण के लिए तर्कों की पुनरावृत्ति:

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

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

number_list = [12,45,78]
print map('the number is {}'.format, number_list)
# Out: ['the number is 12', 'the number is 45', 'the number is 78']   
    

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(5))
    
print '\n'.join(map('{:%Y-%m-%d %H:%M:%S}'.format, gen))
#Out: 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

संरेखण और गद्दी

'{:~<9s}, World'.format('Hello')
# 'Hello~~~~, World'

'{:~>9s}, World'.format('Hello')
# '~~~~Hello, World'

'{:~^9s}'.format('Hello')
# '~~Hello~~'

'{:0=6d}'.format(-123)
# '-00123'

नोट: आप स्ट्रिंग फ़ंक्शंस ljust() , rjust() , center() , zfill() का उपयोग करके समान परिणाम प्राप्त कर सकते हैं, हालाँकि ये फ़ंक्शन 2.5 संस्करण के बाद से zfill() हैं।

प्रारूप शाब्दिक (एफ-स्ट्रिंग)

शाब्दिक प्रारूप तार में पेश किए गए पीईपी 498 (Python3.6 और ऊपर की तरफ), तो आपको आगे जोड़ते करने की इजाजत दी f एक स्ट्रिंग शाब्दिक की शुरुआत करने के लिए प्रभावी ढंग से करने के लिए लागू .format वर्तमान क्षेत्र में सभी चर के साथ यह करने के लिए।

>>> foo = 'bar'
>>> f'Foo is {foo}'
'Foo is bar'

यह अलाइनमेंट और डॉट नोटेशन सहित अधिक उन्नत प्रारूप स्ट्रिंग्स के साथ भी काम करता है।

>>> f'{foo:^7s}'
'  bar  '

नोट: f'' python2 में unicode लिए b'' लिए bytes या u'' तरह एक विशेष प्रकार को निरूपित नहीं करता है। फ़ॉर्मेटिंग को तुरंत लागू किया जाता है, जिसके परिणामस्वरूप सामान्य हलचल होती है।

प्रारूप के तार भी नेस्टेड हो सकते हैं:

>>> price = 478.23
>>> f"{f'${price:0.2f}':*>20s}"
'*************$478.23'

एफ-स्ट्रिंग में अभिव्यक्तियों का मूल्यांकन बाएं से दाएं क्रम में किया जाता है। यह तभी पता लगाने योग्य है जब भावों के दुष्प्रभाव हों:

>>> def fn(l, incr):
...    result = l[0]
...    l[0] += incr
...    return result
...
>>> lst = [0]
>>> f'{fn(lst,2)} {fn(lst,3)}'
'0 2'
>>> f'{fn(lst,2)} {fn(lst,3)}'
'5 7'
>>> lst
[10]

स्ट्रिंग प्रारूपण के साथ

कोई भी वर्ग __format__ विधि के माध्यम से अपने स्वयं के स्ट्रिंग स्वरूपण सिंटैक्स को कॉन्फ़िगर कर सकता है। कि इस का आसान उपयोग करता है मानक अजगर पुस्तकालय में एक प्रकार है datetime प्रकार है, जहां एक का उपयोग कर सकते strftime सीधे कोड प्रारूपित भीतर की तरह str.format :

>>> from datetime import datetime
>>> 'North America: {dt:%m/%d/%Y}.  ISO: {dt:%Y-%m-%d}.'.format(dt=datetime.now())
'North America: 07/21/2016.  ISO: 2016-07-21.'

आधिकारिक दस्तावेज़ में डेटाइम फॉर्मेटर्स की सूची की एक पूरी सूची पाई जा सकती है।

गेटिटेम और गेटैट्र का उपयोग करके प्रारूप

कोई भी डेटा संरचना जो __getitem__ का समर्थन __getitem__ है, उनकी नेस्टेड संरचना को स्वरूपित किया जा सकता है:

person = {'first': 'Arthur', 'last': 'Dent'} 
'{p[first]} {p[last]}'.format(p=person) 
# 'Arthur Dent'

getattr() का उपयोग करके ऑब्जेक्ट विशेषताओं तक पहुँचा जा सकता है:

class Person(object):
    first = 'Zaphod'
    last = 'Beeblebrox'

'{p.first} {p.last}'.format(p=Person())
# 'Zaphod Beeblebrox'

फ्लोट स्वरूपण

>>> '{0:.0f}'.format(42.12345)
'42'

>>> '{0:.1f}'.format(42.12345)
'42.1'

>>> '{0:.3f}'.format(42.12345)
'42.123'

>>> '{0:.5f}'.format(42.12345)
'42.12345'

>>> '{0:.7f}'.format(42.12345)
'42.1234500'

संदर्भित करने के अन्य तरीके के लिए एक ही पकड़:

>>> '{:.3f}'.format(42.12345)
'42.123'

>>> '{answer:.3f}'.format(answer=42.12345)
'42.123'

फ्लोटिंग पॉइंट नंबर को वैज्ञानिक अंकन या प्रतिशत के रूप में भी स्वरूपित किया जा सकता है:

>>> '{0:.3e}'.format(42.12345)
'4.212e+01'

>>> '{0:.0%}'.format(42.12345)
'4212%'

आप {0} और {name} नोटेशन को भी मिला सकते हैं। यह विशेष रूप से तब उपयोगी है जब आप 1 घोषणा के साथ सभी चर को पूर्व-निर्दिष्ट संख्या में गोल करना चाहते हैं:

>>> s = 'Hello'
>>> a, b, c = 1.12345, 2.34567, 34.5678
>>> digits = 2

>>> '{0}! {1:.{n}f}, {2:.{n}f}, {3:.{n}f}'.format(s, a, b, c, n=digits)
'Hello! 1.12, 2.35, 34.57'

न्यूमेरिकल वैल्यूज़ का प्रारूपण

.format() विधि विभिन्न स्वरूपों में किसी संख्या की व्याख्या कर सकती है, जैसे:

>>> '{:c}'.format(65)    # Unicode character
'A'

>>> '{:d}'.format(0x0a)  # base 10
'10'

>>> '{:n}'.format(0x0a)  # base 10 using current locale for separators
'10'

विभिन्न आधारों के लिए पूर्णांकों को प्रारूपित करें (हेक्स, ऑक्टो, बाइनरी)

>>> '{0:x}'.format(10) # base 16, lowercase - Hexadecimal
'a'

>>> '{0:X}'.format(10) # base 16, uppercase - Hexadecimal
'A'

>>> '{:o}'.format(10) # base 8 - Octal
'12'

>>> '{:b}'.format(10) # base 2 - Binary
'1010'

>>> '{0:#b}, {0:#o}, {0:#x}'.format(42) # With prefix
'0b101010, 0o52, 0x2a'

>>> '8 bit: {0:08b}; Three bytes: {0:06x}'.format(42) # Add zero padding
'8 bit: 00101010; Three bytes: 00002a'

आरजीबी फ्लोट टपल को एक रंग हेक्स स्ट्रिंग में बदलने के लिए प्रारूपण का उपयोग करें:

>>> r, g, b = (1.0, 0.4, 0.0)
>>> '#{:02X}{:02X}{:02X}'.format(int(255 * r), int(255 * g), int(255 * b))
'#FF6600'

केवल पूर्णांकों को परिवर्तित किया जा सकता है:

>>> '{:x}'.format(42.0)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: Unknown format code 'x' for object of type 'float'

एक वर्ग के लिए कस्टम स्वरूपण

ध्यान दें:

नीचे सब कुछ str.format पद्धति, साथ ही format फ़ंक्शन पर लागू होता है। नीचे दिए गए पाठ में, दोनों विनिमेय हैं।

format फ़ंक्शन में दिए गए प्रत्येक मान के लिए, पायथन उस तर्क के लिए एक __format__ विधि की तलाश करता है। इसलिए आपका स्वयं का कस्टम वर्ग यह निर्धारित करने के लिए अपनी स्वयं की __format__ विधि कर सकता है कि format फ़ंक्शन आपके वर्ग को कैसे प्रदर्शित करेगा और प्रारूपित करेगा और यह विशेषता है।

इस तुलना में अलग है __str__ विधि के रूप में, __format__ विधि आप खाते में स्वरूपण भाषा, संरेखण, क्षेत्र आदि चौड़ाई सहित भी अपनी स्वयं की फ़ॉर्मेटिंग भाषा एक्सटेंशन ले जा सकते हैं, और (यदि आप चाहें) अपने स्वयं के प्रारूप विनिर्देशक लागू है, और। 1

object.__format__(self, format_spec)

उदाहरण के लिए :

# Example in Python 2 - but can be easily applied to Python 3

class Example(object):
    def __init__(self,a,b,c):
        self.a, self.b, self.c = a,b,c

    def __format__(self, format_spec):
        """ Implement special semantics for the 's' format specifier """
        # Reject anything that isn't an s
        if format_spec[-1] != 's':
            raise ValueError('{} format specifier not understood for this object', format_spec[:-1])

        # Output in this example will be (<a>,<b>,<c>)
        raw = "(" + ",".join([str(self.a), str(self.b), str(self.c)]) + ")"
        # Honor the format language by using the inbuilt string format
        # Since we know the original format_spec ends in an 's' 
        # we can take advantage of the str.format method with a 
        # string argument we constructed above
        return "{r:{f}}".format( r=raw, f=format_spec )

inst = Example(1,2,3)
print "{0:>20s}".format( inst )
# out :              (1,2,3)
# Note how the right align and field width of 20 has been honored.

ध्यान दें:

अपने कस्टम वर्ग एक कस्टम नहीं है, तो __format__ विधि और वर्ग का एक उदाहरण के लिए पारित कर दिया है format समारोह, को Python2 हमेशा की वापसी मान का उपयोग करेगा __str__ विधि या __repr__ निर्धारित करने के लिए क्या मुद्रित करने के लिए (और अगर न तो मौजूद विधि डिफ़ॉल्ट repr का उपयोग किया जाएगा), और आपको इसे प्रारूपित करने के लिए s प्रारूप विनिर्देशक का उपयोग करने की आवश्यकता होगी। Python3 के साथ, अपने कस्टम वर्ग को format फ़ंक्शन में पास करने के लिए, आपको अपने कस्टम वर्ग पर __format__ विधि को परिभाषित करने की आवश्यकता होगी।

नेस्टेड स्वरूपण

कुछ प्रारूप अतिरिक्त पैरामीटर ले सकते हैं, जैसे कि स्वरूपित स्ट्रिंग की चौड़ाई, या संरेखण:

>>> '{:.>10}'.format('foo')
'.......foo'

उन लोगों को भी करने के लिए पैरामीटर के रूप में प्रदान की जा सकती format अधिक घोंसले बनाने के {} के अंदर {} :

>>> '{:.>{}}'.format('foo', 10)
'.......foo'
'{:{}{}{}}'.format('foo', '*', '^', 15)
'******foo******'

बाद के उदाहरण में, प्रारूप स्ट्रिंग '{:{}{}{}}' को संशोधित करने से पहले '{:*^15}' (अर्थात "केंद्र और पैड के साथ * कुल 15 की लंबाई तक") संशोधित किया जाता है। वास्तविक स्ट्रिंग 'foo' को इस तरह से स्वरूपित किया जाना है।

यह उन मामलों में उपयोगी हो सकता है जब पैरामीटर पहले से ज्ञात नहीं होते हैं, उदाहरण के लिए जब सारणीबद्ध डेटा संरेखित करते हैं:

>>> data = ["a", "bbbbbbb", "ccc"]
>>> m = max(map(len, data))
>>> for d in data:
...     print('{:>{}}'.format(d, m))
      a
bbbbbbb
    ccc

पैडिंग और ट्रंकिंग स्ट्रिंग्स, संयुक्त

मान लें कि आप वर्ण को 3 वर्ण कॉलम में प्रिंट करना चाहते हैं।

नोट: { और } दोहरीकरण से बच जाता है।

s = """

pad
{{:3}}             :{a:3}:

truncate
{{:.3}}            :{e:.3}:

combined
{{:>3.3}}          :{a:>3.3}:
{{:3.3}}           :{a:3.3}:
{{:3.3}}           :{c:3.3}:
{{:3.3}}           :{e:3.3}:
"""

print (s.format(a="1"*1, c="3"*3, e="5"*5))

आउटपुट:

pad
{:3}             :1  :

truncate
{:.3}            :555:

combined
{:>3.3}          :  1:
{:3.3}           :1  :
{:3.3}           :333:
{:3.3}           :555:

नामांकित प्लेसहोल्डर

फ़ॉर्मेट स्ट्रिंग में प्लेसहोल्डर्स नाम हो सकते हैं, जिन्हें कीवर्ड तर्क के format उपयोग करके प्रक्षेपित किया जाता format ।

शब्दकोश का उपयोग करना (पायथन 2.x)

>>> data = {'first': 'Hodor', 'last': 'Hodor!'}
>>> '{first} {last}'.format(**data)
'Hodor Hodor!'

शब्दकोश का उपयोग करना (पायथन 3.2+)

>>> '{first} {last}'.format_map(data)
'Hodor Hodor!'

str.format_map पहले उन्हें अनपैक किए बिना शब्दकोशों का उपयोग करने की अनुमति देता है। इसके अलावा data की श्रेणी (जो एक कस्टम प्रकार हो सकती है) का उपयोग नव भरे हुए dict बजाय किया जाता है।

एक शब्दकोश के बिना:

>>> '{first} {last}'.format(first='Hodor', last='Hodor!')
'Hodor Hodor!'