पायथन में प्रारूप रूपांतरण, प्रारूप (शून्य-भरना, घातीय संकेतन, हेक्साडेसिमल, आदि)

पायथन में किसी संख्या या स्ट्रिंग को विभिन्न स्वरूपों में बदलने के लिए, अंतर्निहित फ़ंक्शन प्रारूप () या स्ट्रिंग विधि str.format () का उपयोग करें।

इस खंड में, हम बताएंगे कि निम्नलिखित कार्यों का उपयोग कैसे करें।

• अंतर्निहित फ़ंक्शन (जैसे प्रोग्रामिंग भाषा में)format()
• स्ट्रिंग विधिstr.format()

इसके अलावा, निम्नलिखित प्रारूप में कनवर्ट करने के लिए प्रारूप विनिर्देश स्ट्रिंग को नमूना कोड के साथ समझाया गया है।

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

ध्यान दें कि पायथन 3.6 के बाद से, f-strings (f-strings) को स्ट्रिंग विधि str.format() में और अधिक संक्षिप्त बनाने के लिए जोड़ा गया है।

अंतर्निहित फ़ंक्शन: प्रारूप ()

format() एक मानक पायथन बिल्ट-इन फ़ंक्शन के रूप में प्रदान किया जाता है।

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

रूपरेखा इस प्रकार है।

• format(value, format_spec)
  • पहला तर्क:value
    मूल मूल्य। स्ट्रिंग स्ट्र, नंबर इंट, फ्लोट, आदि।
  • दूसरा तर्कformat_spec
    प्रारूप विनिर्देश स्ट्रिंग। स्ट्रिंग str
  • वापसी मूल्य: एक स्वरूपित स्ट्रिंग str

उदाहरण नीचे दिखाए गए हैं। प्रारूप स्ट्रिंग्स के प्रकार और उन्हें कैसे लिखना है, इसका वर्णन बाद में किया गया है।

इस उदाहरण में, हमने पहले तर्क के रूप में संख्यात्मक शाब्दिक और स्ट्रिंग अक्षर का उपयोग किया है, लेकिन निश्चित रूप से आप उन चरों का उपयोग कर सकते हैं जिनमें ये मान शामिल हैं।

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

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

स्ट्रिंग विधि str.format ()

स्ट्रिंग प्रकार के लिए एक प्रारूप () विधि भी है।

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

स्ट्रिंग में {} जो फ़ॉर्मेट () विधि को कॉल करता है, उसे प्रतिस्थापन फ़ील्ड कहा जाता है, और इसे प्रारूप () विधि के तर्क द्वारा प्रतिस्थापित किया जाता है।

प्रारूप विनिर्देश स्ट्रिंग को प्रतिस्थापन क्षेत्र में लिखा जाना चाहिए {} उसके बाद “:”।

वापसी मान एक स्वरूपित स्ट्रिंग 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.

घुंघराले कोष्ठक का विवरण {}

अगर आप कर्ली ब्रैकेट्स {,} को फॉर्मेट () मेथड में लिखना चाहते हैं, तो इसे {{,}} की तरह दो बार दोहराएं। ध्यान दें कि बैकस्लैश से बचा नहीं जा सकता है।

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

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

दोनों ही मामलों में, प्रारूप निर्दिष्ट करने के लिए, {} में पूर्णांक मान या नाम स्ट्रिंग के बाद “:format string” लिखें।

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 (), केंद्र (), और 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

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

प्रत्येक तीन अंकों में अल्पविराम या अंडरस्कोर _ विभाजक जोड़ें। इससे बड़ी संख्या में पढ़ने में आसानी होती है। ध्यान दें कि अंडरस्कोर_ पायथन 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

यदि आप सामान्य गोलाई का उपयोग करना चाहते हैं, तो आप मानक पुस्तकालय दशमलव की मात्रा () विधि का उपयोग कर सकते हैं।

घातीय संकेतन

जब एक फ़्लोटिंग-पॉइंट फ्लोट नंबर को स्ट्रिंग स्ट्र में परिवर्तित किया जाता है, तो यह अंकों की संख्या के आधार पर स्वचालित रूप से घातीय नोटेशन में लिखा जाएगा। पूर्णांक प्रकार 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

यदि आप फ़ॉर्मेटिंग विनिर्देश स्ट्रिंग में ई या ई निर्दिष्ट करते हैं, तो आप हमेशा घातीय नोटेशन में कनवर्ट कर सकते हैं। आउटपुट में प्रयुक्त वर्ण क्रमशः ई और ई होंगे।

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 को छोड़ देते हैं, तो आउटपुट पूर्णांक नहीं होगा। जी ज्यादातर मामलों में समान है, लेकिन केवल उन मामलों में जहां आउटपुट एक पूर्णांक है।

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

जी के मामले में या यदि इसे छोड़ दिया जाता है, तो दशमलव बिंदु के बाद पिछला शून्य छोड़ दिया जाता है, इसलिए यदि आप समान संख्या में महत्वपूर्ण अंक (महत्वपूर्ण अंकों की संख्या) को आउटपुट करना चाहते हैं, तो ई या ई के घातीय संकेतन का उपयोग करें। पूर्णांक भाग हमेशा एक अंक होता है और दशमलव बिंदु अंकों की निर्दिष्ट संख्या होती है, इसलिए यदि आप 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%