पायथन, स्वरूप (शून्य-भरणे, घातांक नोटेशन, हेक्साडेसिमल इ.) मध्ये रूपांतरण

पायथनमध्ये संख्या किंवा स्ट्रिंगचे विविध स्वरूपांमध्ये रूपांतर (स्वरूप) करण्यासाठी, अंगभूत फंक्शन फॉरमॅट() किंवा स्ट्रिंग पद्धत str.format() वापरा.

या विभागात, आम्ही खालील फंक्शन्स कसे वापरायचे ते स्पष्ट करू.

• अंगभूत कार्य (उदा. प्रोग्रामिंग भाषेत)format()
• स्ट्रिंग पद्धतstr.format()

याव्यतिरिक्त, खालील फॉरमॅटमध्ये रूपांतरित करण्यासाठी फॉरमॅट स्पेसिफिकेशन स्ट्रिंग नमुना कोडसह स्पष्ट केले आहे.

• डावे-न्याय्य, केंद्र-न्याय्य, उजवे-न्याय्य
• शून्य भरणे
• चिन्ह (अधिक किंवा वजा)
• अंक विभाजक (स्वल्पविराम, अंडरस्कोर)
• बायनरी, ऑक्टल आणि हेक्साडेसिमल संख्या
• दशांश बिंदू नंतर अंकांची संख्या निर्दिष्ट करा
• महत्त्वपूर्ण आकडे (महत्त्वपूर्ण अंकांची संख्या)
• घातांक नोटेशन
• टक्केवारी प्रदर्शन

लक्षात घ्या की Python 3.6 पासून, f-strings (f-strings) str.format() या स्ट्रिंग पद्धतीमध्ये अधिक संक्षिप्त करण्यासाठी जोडले गेले आहे.

अंगभूत कार्य: स्वरूप()

format() मानक पायथन बिल्ट-इन फंक्शन म्हणून प्रदान केले आहे.

• Built-in Functions — format() — Python 3.10.0 Documentation

रुपरेषा खालीलप्रमाणे आहे.

• format(value, format_spec)
  • पहिला युक्तिवाद: दvalue
    मूळ मूल्य. String str, number int, float, इ.
  • दुसरा युक्तिवादformat_spec
    स्वरूप तपशील स्ट्रिंग. स्ट्रिंग str
  • रिटर्न व्हॅल्यू: फॉरमॅटेड स्ट्रिंग str

उदाहरणे खाली दर्शविली आहेत. फॉरमॅट स्ट्रिंगचे प्रकार आणि ते कसे लिहायचे ते नंतर वर्णन केले आहे.

या उदाहरणात, आम्ही प्रथम युक्तिवाद म्हणून अंकीय अक्षरे आणि स्ट्रिंग लिटरल्स वापरले आहेत, परंतु अर्थातच तुम्ही ही मूल्ये असलेली चल वापरू शकता.

s = format(255, '04x')
print(s)
print(type(s))
# 00ff
# <class 'str'>

print(format('center', '*^16'))
# *****center*****

स्ट्रिंग पद्धत str.format()

स्ट्रिंग प्रकारासाठी एक format() पद्धत देखील आहे.

• Built-in Types — str.format() — Python 3.10.0 Documentation

स्ट्रिंगमधील {} जी format() पद्धतीला कॉल करते त्याला प्रतिस्थापन फील्ड म्हणतात, आणि format() पद्धतीच्या वितर्काने बदलले जाते.

फॉरमॅट स्पेसिफिकेशन स्ट्रिंग प्रतिस्थापन फील्डमध्ये {} त्यानंतर “:” लिहिलेली असावी.

रिटर्न व्हॅल्यू हे फॉरमॅटेड स्ट्रिंग str आहे.

वर वर्णन केलेल्या बिल्ट-इन फंक्शन फॉरमॅट() ची समतुल्य प्रक्रिया खालीलप्रमाणे आहे.

s = '{:04x}'.format(255)
print(s)
print(type(s))
# 00ff
# <class 'str'>

print('{:*^16}'.format('center'))
# *****center*****

पुन्हा, आम्ही आर्ग्युमेंट म्हणून अंकीय अक्षरे आणि स्ट्रिंग लिटरल वापरत आहोत, परंतु अर्थातच व्हेरिएबल्स देखील स्वीकार्य आहेत.

प्रतिस्थापन फील्डसाठी युक्तिवाद निर्दिष्ट करणे

वितर्क क्रमाने निर्दिष्ट करा (डिफॉल्ट)

एकाधिक प्रतिस्थापन फील्ड असू शकतात {}, आणि डीफॉल्टनुसार, पद्धत वितर्क क्रमाने प्रक्रिया केली जातात. जर {} मधील फॉरमॅट स्पेसिफिकेशन स्ट्रिंग वगळली असेल, तर ती फक्त str() द्वारे स्ट्रिंगमध्ये रूपांतरित केली जाईल.

स्ट्रिंगमध्ये व्हेरिएबल व्हॅल्यू घालण्यासाठी आणि प्रिंट करण्यासाठी उपयुक्त.

print('{}-{}-{}'.format('100', '二百', 300))
# 100-二百-300

पूर्णांक मूल्यांसाठी स्थानात्मक युक्तिवाद निर्दिष्ट करा

पूर्णांक मूल्य {0} किंवा {1} सारखे {} मध्ये निर्दिष्ट केले असल्यास, आउटपुट वितर्कांच्या क्रमावर अवलंबून असेल. एकच नंबर वारंवार वापरता येतो. जेव्हा तुम्हाला स्ट्रिंगमध्ये समान मूल्य घालायचे असेल तेव्हा हे उपयुक्त आहे.

print('{0}-{1}-{0}'.format('foo', 'bar'))
# foo-bar-foo

अनियंत्रित नावांसाठी (स्ट्रिंग) कीवर्ड वितर्क निर्दिष्ट करा

तुम्ही {} मध्ये कोणतेही नाव निर्दिष्ट करू शकता आणि ते कीवर्ड युक्तिवाद म्हणून प्रविष्ट करू शकता.

print('{day}/{month}/{year}/'.format(day=11, month=1, year=2018))
# 11/1/2018

युक्तिवाद म्हणून सूची किंवा शब्दकोश निर्दिष्ट करा

याद्या आणि शब्दकोश वितर्क म्हणून निर्दिष्ट केले जाऊ शकतात.

प्रतिस्थापन फील्डमध्ये सूचीची अनुक्रमणिका किंवा शब्दकोशाची की निर्दिष्ट करण्यासाठी [] वापरा. लक्षात ठेवा की कोटेशन मार्क्स “‘” आणि “” शब्दकोष की निर्दिष्ट करण्यासाठी वापरले जात नाहीत.

तुम्हाला तोच युक्तिवाद वारंवार वापरायचा असल्यास, तुम्हाला वर वर्णन केल्याप्रमाणे पूर्णांक मूल्य किंवा स्ट्रिंग (नाव) निर्दिष्ट करणे आवश्यक आहे.

l = ['one', 'two', 'three']
print('{0[0]}-{0[1]}-{0[2]}'.format(l))
# one-two-three

d1 = {'name': 'Alice', 'age': 20}
d2 = {'name': 'Bob', 'age': 30}
print('{0[name]} is {0[age]} years old.\n{1[name]} is {1[age]} years old.'.format(d1, d2))
# Alice is 20 years old.
# Bob is 30 years old.

सूचीमध्ये * जोडून आणि वितर्क म्हणून निर्दिष्ट करून किंवा शब्दकोषात ** जोडून आणि युक्तिवाद म्हणून निर्दिष्ट करून कीवर्ड युक्तिवाद म्हणून त्याचा विस्तार केला जाऊ शकतो.

l = ['one', 'two', 'three']
print('{}-{}-{}'.format(*l))
# one-two-three

d = {'name': 'Alice', 'age': 20}
print('{name} is {age} years old.'.format(**d))
# Alice is 20 years old.

कुरळे कंसाचे वर्णन {}

जर तुम्हाला कुरळे कंस {,} format() पद्धतीने लिहायचे असतील, तर ते {{,}} प्रमाणे दोनदा रिपीट करा. लक्षात ठेवा की बॅकस्लॅश सुटू शकत नाहीत.

print('{{}}-{num}-{{{num}}}'.format(num=100))
# {}-100-{100}

स्वरूपित स्ट्रिंग

दोन्ही प्रकरणांमध्ये, स्वरूप निर्दिष्ट करण्यासाठी, पूर्णांक मूल्यानंतर “:स्वरूप स्ट्रिंग” लिहा किंवा {} मधील नाव स्ट्रिंग.

print('{num:x}'.format(num=255))
# ff

print('{day}/{month:02}/{year:02}/'.format(day=11, month=1, year=2018))
# 11/01/2018

फॉरमॅट स्ट्रिंग वापरून फॉरमॅट कसा निर्दिष्ट करायचा ते आम्ही पुढीलमध्ये स्पष्ट करू. नमुना कोड स्ट्रिंग पद्धत वापरतो str.format(), परंतु समान फॉरमॅट स्ट्रिंग अंगभूत फंक्शन फॉरमॅट() सह वापरली जाऊ शकते. बिल्ट-इन फंक्शन फॉरमॅटमध्ये(), फॉरमॅट स्पेसिफिकेशन स्ट्रिंग हा दुसरा वितर्क म्हणून निर्दिष्ट केला जातो.

डावे-न्याय्य, केंद्र-न्याय्य, उजवे-न्याय्य

तुम्ही खाली डावीकडे न्याय्य, मध्यभागी न्याय्य, उजवे-न्यायिक इत्यादी संरेखित करू शकता. संख्या म्हणून वर्णांची एकूण संख्या निर्दिष्ट करा.

• <
• ^
• >

print('left  : {:<10}'.format(100))
print('center: {:^10}'.format(100))
print('right : {:>10}'.format(100))
# left  : 100       
# center:    100    
# right :        100

तुम्ही भरण्यासाठी एखादे वर्ण देखील निर्दिष्ट करू शकता. वगळल्यास, वरील उदाहरणाप्रमाणे, ती एक जागा आहे.

जोपर्यंत एकल वर्ण आहे तोपर्यंत तुम्ही डबल-बाइट वर्ण वापरू शकता.

print('left  : {:*<10}'.format(100))
print('center: {:a^10}'.format(100))
print('right : {:鬼>10}'.format(100))
# left  : 100*******
# center: aaa100aaaa
# right : 鬼鬼鬼鬼鬼鬼鬼100

> सह योग्य-औचित्य (-,+) चिन्ह विचारात घेत नाही. जर तुम्ही = वापरत असाल, तर चिन्हाच्या नंतर निर्दिष्ट वर्ण येतो. तुम्हाला + निर्दिष्ट करायचे असल्यास, + नंतर = लिहा. साइन प्रोसेसिंगचे तपशील नंतर वर्णन केले आहेत.

print('sign: {:0>10}'.format(-100))
print('sign: {:0=10}'.format(-100))
print('sign: {:0=+10}'.format(100))
# sign: 000000-100
# sign: -000000100
# sign: +000000100

<, ^, आणि > स्ट्रिंग्ससाठी निर्दिष्ट केले जाऊ शकते, परंतु = एक त्रुटी ValueError होईल. जर तुम्हाला स्ट्रिंगसाठी = वापरायचे असेल, तर तुम्हाला ते int() वापरून एका संख्येत रूपांतरित करावे लागेल.

# print('sign: {:0=10}'.format('-100'))
# ValueError: '=' alignment not allowed in string format specifier

print('sign: {:0=10}'.format(int('-100')))
# sign: -000000100

हेच फ्लोटिंग-पॉइंट क्रमांकांना लागू होते. दशांश बिंदू देखील एक वर्ण म्हणून मोजले जातात.

print('left  : {:*<10}'.format(1.23))
print('center: {:a^10}'.format(1.23))
print('right : {:鬼>10}'.format(1.23))
# left  : 1.23******
# center: aaa1.23aaa
# right : 鬼鬼鬼鬼鬼鬼1.23

print('sign: {:0>10}'.format(-1.23))
print('sign: {:0=10}'.format(-1.23))
print('sign: {:0=+10}'.format(1.23))
# sign: 00000-1.23
# sign: -000001.23
# sign: +000001.23

याद्या, ट्युपल्स इ. मुळे जसे-तसे निर्दिष्ट केले असल्यास त्रुटी निर्माण होईल आणि str() वापरून स्ट्रिंगमध्ये रूपांतरित केले जाऊ शकते.

l = [0, 1]
print(type(l))
# <class 'list'>

# print('{:*^16}'.format(l))
# TypeError: unsupported format string passed to list.__format__

print(type(str(l)))
# <class 'str'>

print('{:*^16}'.format(str(l)))
# *****[0, 1]*****

लेफ्ट-जस्टिफाईड, सेंटर-जस्टिफाईड आणि राइट-जस्टिफाईडसाठी, ljust(), center(), आणि rjust() नावाच्या समर्पित स्ट्रिंग पद्धती देखील आहेत.

0 भरा

जर तुम्ही अंकांची संख्या शून्य-भरून समायोजित करू इच्छित असाल, तर वर्ण 0 वर भरण्यासाठी सेट करा आणि त्यास योग्य-न्याय करा.

शून्य-भरण्याच्या बाबतीत, संरेखन चिन्ह वगळल्यास, त्यावर प्रक्रिया केली जाते जसे की = निर्दिष्ट केले होते.

print('zero padding: {:0=10}'.format(100))
print('zero padding: {:010}'.format(100))
# zero padding: 0000000100
# zero padding: 0000000100

print('zero padding: {:0=10}'.format(-100))
print('zero padding: {:010}'.format(-100))
# zero padding: -000000100
# zero padding: -000000100

#त्रुटी!

# print('zero padding: {:010}'.format('-100'))
# ValueError: '=' alignment not allowed in string format specifier

झिरो-फिलिंगसाठी, zfill() नावाची एक समर्पित स्ट्रिंग पद्धत देखील आहे.

चिन्ह (अधिक किंवा वजा)

डीफॉल्टनुसार, फक्त ऋण संख्या चिन्हाने (वजा-) चिन्हांकित केली जातात.

जेव्हा फॉरमॅटिंग स्पेसिफिकेशन स्ट्रिंगमध्ये + जोडले जाते, तेव्हा सकारात्मक संख्यांसाठी एक चिन्ह (अधिक +) देखील प्रदर्शित केले जाते. जर स्पेस जोडली गेली असेल तर, धन संख्येच्या सुरूवातीस एक स्पेस प्रदर्शित केली जाईल आणि अंकांची संख्या नकारात्मक संख्येसह संरेखित केली जाईल.

print('sign: {}'.format(100))
print('sign: {}'.format(-100))
# sign: 100
# sign: -100

print('sign: {:+}'.format(100))
print('sign: {:+}'.format(-100))
# sign: +100
# sign: -100

print('sign: {: }'.format(100))
print('sign: {: }'.format(-100))
# sign:  100
# sign: -100

अनियंत्रित अक्षरे भरताना काळजी घ्या, जसे की वर नमूद केलेले शून्य-भरणे. डीफॉल्ट, कोणतेही + आणि रिक्त स्थान नसलेले, आणखी एका वर्णाने धन संख्या भरते.

print('sign: {:06}'.format(100))
print('sign: {:06}'.format(-100))
# sign: 000100
# sign: -00100

print('sign: {:+06}'.format(100))
print('sign: {:+06}'.format(-100))
# sign: +00100
# sign: -00100

print('sign: {: 06}'.format(100))
print('sign: {: 06}'.format(-100))
# sign:  00100
# sign: -00100

संरेखन चिन्ह वापरले असल्यास, चिन्ह पदनाम चिन्ह संरेखन चिन्हाच्या नंतर लिहिले पाहिजे.

print('sign: {:_>6}'.format(100))
print('sign: {:_>6}'.format(-100))
# sign: ___100
# sign: __-100

print('sign: {:_>+6}'.format(100))
print('sign: {:_>+6}'.format(-100))
# sign: __+100
# sign: __-100

print('sign: {:_> 6}'.format(100))
print('sign: {:_> 6}'.format(-100))
# sign: __ 100
# sign: __-100

अंक विभाजक (स्वल्पविराम, अंडरस्कोर)

प्रत्येक तीन अंकांनी स्वल्पविराम किंवा अंडरस्कोर _ विभाजक जोडा. हे मोठ्या संख्येने वाचणे सोपे करते. लक्षात घ्या की अंडरस्कोर_ हा Python 3.6 मध्ये जोडलेला पर्याय आहे, त्यामुळे तो पूर्वीच्या आवृत्त्यांमध्ये वापरला जाऊ शकत नाही.

print('{:,}'.format(100000000))
# 100,000,000

print('{:_}'.format(100000000))
# 100_000_000

फ्लोटिंग-पॉइंट नंबर फ्लोट प्रकारांच्या बाबतीत, फक्त पूर्णांक भाग मर्यादित केला जातो.

print('{:,}'.format(1234.56789))
# 1,234.56789

बायनरी, ऑक्टल आणि हेक्साडेसिमल संख्या

आउटपुटसाठी संख्यात्मक मूल्यांना बायनरी, ऑक्टल आणि हेक्साडेसिमल संख्यांमध्ये रूपांतरित करते.

• b: बायनरी
• o: अष्टक
• d: दशांश
• x,X: हेक्साडेसिमल (अपरकेस अक्षरे कॅपिटल केलेली आहेत)

print('bin: {:b}'.format(255))
print('oct: {:o}'.format(255))
print('dec: {:d}'.format(255))
print('hex: {:x}'.format(255))
print('HEX: {:X}'.format(255))
# bin: 11111111
# oct: 377
# dec: 255
# hex: ff
# HEX: FF

हे 0-फिलसह देखील एकत्र केले जाऊ शकते आणि बहुतेक वेळा बायनरी आणि हेक्साडेसिमल नोटेशनमधील अंक संरेखित करण्यासाठी वापरले जाते.

print('bin: {:08b}'.format(255))
print('oct: {:08o}'.format(255))
print('dec: {:08d}'.format(255))
print('hex: {:08x}'.format(255))
print('HEX: {:08X}'.format(255))
# bin: 11111111
# oct: 00000377
# dec: 00000255
# hex: 000000ff
# HEX: 000000FF

लक्षात घ्या की उपसर्ग लक्षात घेऊन शून्य-भरण वर्णांची संख्या निर्दिष्ट करणे आवश्यक आहे.

print('bin: {:#010b}'.format(255))
print('oct: {:#010o}'.format(255))
print('dec: {:#010d}'.format(255))
print('hex: {:#010x}'.format(255))
print('HEX: {:#010X}'.format(255))
# bin: 0b11111111
# oct: 0o00000377
# dec: 0000000255
# hex: 0x000000ff
# HEX: 0X000000FF

बायनरी आणि हेक्साडेसिमल संख्यांसाठी, फक्त अंडरस्कोर _ अंक विभाजक घातला जाऊ शकतो (पायथन 3.6 किंवा नंतरचा). 4-अंकी विभाजक वापरला जातो; शून्य-भरलेल्या वर्णांच्या संख्येने अंडरस्कोअरची संख्या देखील विचारात घेतली पाहिजे.

print('hex: {:08x}'.format(255))
print('hex: {:09_x}'.format(255))
print('hex: {:#011_x}'.format(255))
# hex: 000000ff
# hex: 0000_00ff
# hex: 0x0000_00ff

केवळ पूर्णांक प्रकार int हे स्वरूप बायनरी किंवा हेक्साडेसिमलमध्ये रूपांतरित करू शकते. तुम्ही int() चा नंबर मध्ये रूपांतरित करण्यासाठी वापरू शकता.

# print('hex: {:08x}'.format('255'))
# ValueError: Unknown format code 'X' for object of type 'str'

print('hex: {:08x}'.format(int('255')))
# hex: 000000ff

दशांश बिंदू नंतर अंकांची संख्या निर्दिष्ट करा

दशांश बिंदूनंतर अंकांची संख्या निर्दिष्ट करण्यासाठी, पुढील गोष्टी करा: n ही अंकांची संख्या आहे. दशांश बिंदूनंतरच्या अंकांची संख्या पूर्णांक भागातील अंकांची संख्या विचारात न घेता अंकांची निर्दिष्ट संख्या बनते.
.[n]f

print('{:.2f}'.format(123.456))
print('{:.5f}'.format(123.456))
print('{:.3f}'.format(0.0001234))
# 123.46
# 123.45600
# 0.000

दशांश बिंदूची डावी बाजू वर वर्णन केल्याप्रमाणे डावीकडे न्याय्य, मध्यवर्ती, उजवीकडे न्याय्य, किंवा शून्य-भरलेली म्हणून निर्दिष्ट केली जाऊ शकते. लक्ष्य मूल्याच्या अंकांची संख्या निर्दिष्ट संख्येपेक्षा जास्त असल्यास, काहीही केले जात नाही. लक्ष्य मूल्यातील अंकांची संख्या निर्दिष्ट अंकांच्या संख्येपेक्षा जास्त असल्यास, काहीही केले जात नाही.

print('{:>12.5f}'.format(123.456))
print('{:012.5f}'.format(123.456))
print('{:06.5f}'.format(123.456))
#    123.45600
# 000123.45600
# 123.45600

आपण दशांश बिंदूनंतर अंकांच्या मूळ संख्येपेक्षा कमी अंकांची संख्या निर्दिष्ट केल्यास, मूल्य गोलाकार केले जाईल. लक्षात घ्या की हे जवळच्या पूर्ण संख्येला पूर्णांक करत नाही, तर सम संख्येसाठी, उदा. 0.5 हे 0 वर पूर्ण केले आहे.

print('{:.0f}'.format(0.4))
print('{:.0f}'.format(0.5))
print('{:.0f}'.format(0.6))
# 0
# 0
# 1

जर तुम्हाला सामान्य राउंडिंग वापरायचे असेल, तर तुम्ही स्टँडर्ड लायब्ररी डेसिमलची quantize() पद्धत वापरू शकता.

घातांक नोटेशन

जेव्हा फ्लोटिंग-पॉइंट फ्लोट क्रमांक स्ट्रिंग स्ट्रमध्ये रूपांतरित केला जातो, तेव्हा अंकांच्या संख्येवर अवलंबून ते आपोआप घातांकात लिहिले जाईल. पूर्णांक प्रकार int नाही.

print('{}'.format(0.0001234))
print('{}'.format(0.00001234))
# 0.0001234
# 1.234e-05

print('{}'.format(1234000000000000.0))
print('{}'.format(12340000000000000.0))
print('{}'.format(12340000000000000000000000))
# 1234000000000000.0
# 1.234e+16
# 12340000000000000000000000

तुम्ही फॉरमॅटिंग स्पेसिफिकेशन स्ट्रिंगमध्ये e किंवा E नमूद केल्यास, तुम्ही नेहमी घातांक नोटेशनमध्ये रूपांतरित करू शकता. आउटपुटमध्ये वापरलेले वर्ण अनुक्रमे e आणि E असतील.

print('{:e}'.format(0.0001234))
print('{:E}'.format(0.0001234))
# 1.234000e-04
# 1.234000E-04

दशांश बिंदू नंतर अंकांची संख्या निर्दिष्ट करणे देखील शक्य आहे. पूर्णांक भाग नेहमी एक अंकी असेल आणि दशांश बिंदू हा अंकांची निर्दिष्ट संख्या असेल.

print('{:.5e}'.format(0.0001234))
print('{:.2E}'.format(0.0001234))
# 1.23400e-04
# 1.23E-04

print('{:.5e}'.format(987.65))
print('{:.2E}'.format(987.65))
# 9.87650e+02
# 9.88E+02

लक्षात ठेवा की जर तुम्ही डावे-न्यायिक, मध्य-न्यायिक, उजवे-उचित, किंवा शून्य-भरलेले, e-, E+, इ. देखील अंक (वर्ण) म्हणून गणले जातील.

print('{:>12.5e}'.format(987.65))
print('{:012.2E}'.format(987.65))
#  9.87650e+02
# 00009.88E+02

महत्त्वपूर्ण आकडे (महत्त्वपूर्ण अंकांची संख्या)

तुम्ही खालील गोष्टी करून अंकांची एकूण संख्या निर्दिष्ट करू शकता निकालावर अवलंबून, घातांक अंकन स्वयंचलितपणे वापरले जाईल. लक्षात घ्या की दशांश बिंदू नंतरचे शून्य वगळले जातील.
.[n]g

print('{:.2g}'.format(123.456))
print('{:.3g}'.format(123.456))
print('{:.8g}'.format(123.456))
print('{:.3g}'.format(0.0001234))
# 1.2e+02
# 123
# 123.456
# 0.000123

तुम्ही g वगळल्यास, आउटपुट पूर्णांक होणार नाही. g बहुतेक प्रकरणांमध्ये समान आहे, परंतु केवळ आउटपुट पूर्णांक असलेल्या प्रकरणांमध्ये.

print('{:.2}'.format(123.456))
print('{:.3}'.format(123.456))
print('{:.8}'.format(123.456))
print('{:.3}'.format(0.0001234))
# 1.2e+02
# 1.23e+02
# 123.456
# 0.000123

जर आपण समान मूल्यावर प्रक्रिया केली तर आपल्याला अनुक्रमे खालील गोष्टी मिळतील.

print('{:.3f}'.format(123.456))
print('{:.3e}'.format(123.456))
print('{:.3g}'.format(123.456))
print('{:.3}'.format(123.456))
# 123.456
# 1.235e+02
# 123
# 1.23e+02

print('{:.8f}'.format(123.456))
print('{:.8e}'.format(123.456))
print('{:.8g}'.format(123.456))
print('{:.8}'.format(123.456))
# 123.45600000
# 1.23456000e+02
# 123.456
# 123.456

g च्या बाबतीत किंवा ते वगळले असल्यास, दशांश बिंदू नंतरचे शून्य वगळले जातात, म्हणून जर तुम्हाला समान संख्या (महत्त्वपूर्ण अंकांची संख्या) आउटपुट करायची असेल, तर e किंवा E चे घातांक वापरा. पूर्णांक भाग हा नेहमी एक अंक असतो आणि दशांश बिंदू हा अंकांची निर्दिष्ट संख्या असतो, त्यामुळे तुम्हाला n लक्षणीय अंक आउटपुट करायचे असल्यास, फक्त n-1 निर्दिष्ट करा.

print('{:.4e}'.format(123.456))
print('{:.4e}'.format(0.000012345))
print('{:.4e}'.format(12))
# 1.2346e+02
# 1.2345e-05
# 1.2000e+01

टक्केवारी प्रदर्शन

फॉरमॅटिंग स्पेसिफिकेशन स्ट्रिंगमध्ये % निर्दिष्ट केले असल्यास, अंकीय फ्लोट किंवा इंटचे मूल्य 100 ने गुणाकार केले जाते आणि % सह स्ट्रिंगमध्ये रूपांतरित केले जाते.

दशांश बिंदू नंतर अंकांची संख्या निर्दिष्ट करणे देखील शक्य आहे. डीफॉल्ट दशांश बिंदू नंतर सहा अंक आहे. लेफ्ट-जस्टिफाय, सेंटर-जस्टिफाय, राइट-जस्टिफाय आणि झिरो-फिल देखील उपलब्ध आहेत. % देखील वर्ण म्हणून गणले जाते.

print('{:%}'.format(0.12345))
print('{:.2%}'.format(0.12345))
# 12.345000%
# 12.35%

print('{:%}'.format(10))
print('{:.2%}'.format(10))
# 1000.000000%
# 1000.00%

print('{:>7.2%}'.format(0.12345))
print('{:07.2%}'.format(0.12345))
#  12.35%
# 012.35%