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

पाइथनमा नम्बर वा स्ट्रिङलाई विभिन्न ढाँचाहरूमा रूपान्तरण (ढाँचा) गर्न, बिल्ट-इन प्रकार्य ढाँचा() वा स्ट्रिङ विधि str.format() प्रयोग गर्नुहोस्।

यस खण्डमा, हामी निम्न प्रकार्यहरू कसरी प्रयोग गर्ने भनेर वर्णन गर्नेछौं।

• बिल्ट-इन प्रकार्य (जस्तै प्रोग्रामिङ भाषामा)format()
• स्ट्रिङ विधिstr.format()

थप रूपमा, निम्न ढाँचामा रूपान्तरणको लागि ढाँचा विशिष्टता स्ट्रिङ नमूना कोडको साथ व्याख्या गरिएको छ।

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

ध्यान दिनुहोस् कि Python 3.6 देखि, f-strings (f-strings) string method 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()

स्ट्रिङ str प्रकारको लागि ढाँचा() विधि पनि छ।

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

स्ट्रिङ str मा {} जसले 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.

घुमाउरो कोष्ठकको विवरण {}

यदि तपाइँ ढाँचा () विधिमा घुमाउरो कोष्ठकहरू {,} लेख्न चाहनुहुन्छ भने, यसलाई {{,}} जस्तै दुई पटक दोहोर्याउनुहोस्। नोट गर्नुहोस् कि ब्याकस्ल्याशहरू भाग्न सकिँदैन।

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() भनिने समर्पित स्ट्रिङ विधिहरू पनि छन्।

० भर्नुहोस्

यदि तपाइँ शून्य-भरण द्वारा अंकहरूको संख्या समायोजन गर्न चाहनुहुन्छ भने, ० मा भरिने क्यारेक्टर सेट गर्नुहोस् र यसलाई दायाँ-औचित्य दिनुहोस्।

शून्य-भरणको अवस्थामा, यदि पङ्क्तिबद्ध चिन्ह मेटाइयो भने, यो = निर्दिष्ट गरिएको रूपमा प्रशोधन गरिन्छ।

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

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

प्रत्येक तीन अंकमा अल्पविराम वा अन्डरस्कोर _ विभाजक थप्नुहोस्। यसले ठूलो संख्यामा पढ्न सजिलो बनाउँछ। नोट गर्नुहोस् कि underscore_ पाइथन 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

यसलाई ०-फिलसँग पनि जोड्न सकिन्छ, र प्रायः बाइनरी र हेक्साडेसिमल नोटेशनमा अंकहरू पङ्क्तिबद्ध गर्न प्रयोग गरिन्छ।

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

यदि तपाईंले दशमलव बिन्दु पछि अंकहरूको मूल संख्या भन्दा कम अंकहरूको संख्या निर्दिष्ट गर्नुभयो भने, मान गोलाकार हुनेछ। ध्यान दिनुहोस् कि यो निकटतम पूर्ण संख्यामा राउन्डिङ होइन, तर सम संख्यामा, उदाहरणका लागि। ०.५ लाई ० मा राउन्ड गरिएको छ।

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

यदि तपाइँ सामान्य राउन्डिङ प्रयोग गर्न चाहनुहुन्छ भने, तपाइँ मानक पुस्तकालय दशमलव को quantize() विधि प्रयोग गर्न सक्नुहुन्छ।

घातांक अंकन

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

प्रतिशत प्रदर्शन

यदि % लाई ढाँचा विनिर्देश स्ट्रिङमा निर्दिष्ट गरिएको छ भने, संख्यात्मक फ्लोट वा int को मान 100 ले गुणन गरिन्छ र % को साथ स्ट्रिङमा रूपान्तरण गरिन्छ।

दशमलव बिन्दु पछि अंकहरूको संख्या निर्दिष्ट गर्न पनि सम्भव छ। पूर्वनिर्धारित दशमलव बिन्दु पछि छ अंक छ। Left-justify, center-justify, right-justify, र zero-fill पनि उपलब्ध छन्। % लाई पनि वर्णको रूपमा गणना गरिन्छ।

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%