પાયથોનમાં ફોર્મેટ કન્વર્ઝન, ફોર્મેટ (શૂન્ય-ફિલિંગ, ઘાતાંકીય સંકેત, હેક્સાડેસિમલ, વગેરે)

Python માં સંખ્યા અથવા સ્ટ્રિંગને વિવિધ ફોર્મેટમાં કન્વર્ટ (ફોર્મેટ) કરવા માટે, બિલ્ટ-ઇન ફંક્શન ફોર્મેટ() અથવા સ્ટ્રિંગ મેથડ str.format() નો ઉપયોગ કરો.

આ વિભાગમાં, અમે નીચેના કાર્યોનો ઉપયોગ કેવી રીતે કરવો તે સમજાવીશું.

બિલ્ટ-ઇન ફંક્શન (દા.ત. પ્રોગ્રામિંગ ભાષામાં)format()
શબ્દમાળા પદ્ધતિstr.format()

વધુમાં, નીચેના ફોર્મેટમાં કન્વર્ટ કરવા માટેની ફોર્મેટ સ્પષ્ટીકરણ સ્ટ્રિંગને નમૂના કોડ સાથે સમજાવવામાં આવી છે.

ડાબે-વાજબી, કેન્દ્ર-વાજબી, જમણે-વાજબી
શૂન્ય ભરો
ચિહ્ન (વત્તા અથવા ઓછા)
અંક વિભાજક (અલ્પવિરામ, અન્ડરસ્કોર)
દ્વિસંગી, અષ્ટાકાર અને હેક્સાડેસિમલ સંખ્યાઓ
દશાંશ બિંદુ પછી અંકોની સંખ્યા સ્પષ્ટ કરો
નોંધપાત્ર આંકડા (નોંધપાત્ર અંકોની સંખ્યા)
ઘાતાંકીય સંકેત
ટકાવારી પ્રદર્શન

નોંધ કરો કે Python 3.6 થી, f-strings (f-strings) ને વધુ સંક્ષિપ્ત બનાવવા માટે str.format() સ્ટ્રિંગ પદ્ધતિમાં ઉમેરવામાં આવ્યું છે.

Table of Contents

બિલ્ટ-ઇન ફંક્શન: ફોર્મેટ()
સ્ટ્રિંગ પદ્ધતિ str.format()
ડાબે-વાજબી, કેન્દ્ર-વાજબી, જમણે-વાજબી
0 ભરો
ચિહ્ન (વત્તા અથવા ઓછા)
અંક વિભાજક (અલ્પવિરામ, અન્ડરસ્કોર)
દ્વિસંગી, અષ્ટાકાર અને હેક્સાડેસિમલ સંખ્યાઓ
દશાંશ બિંદુ પછી અંકોની સંખ્યા સ્પષ્ટ કરો
ઘાતાંકીય સંકેત
નોંધપાત્ર આંકડા (નોંધપાત્ર અંકોની સંખ્યા)
ટકાવારી પ્રદર્શન

બિલ્ટ-ઇન ફંક્શન: ફોર્મેટ()

format() પ્રમાણભૂત Python બિલ્ટ-ઇન ફંક્શન તરીકે પ્રદાન કરવામાં આવે છે.

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

રૂપરેખા નીચે મુજબ છે.

format(value, format_spec)
- પ્રથમ દલીલ: ધvalue
  મૂળ મૂલ્ય. શબ્દમાળા str, સંખ્યા પૂર્ણાંક, ફ્લોટ, વગેરે.
- બીજી દલીલformat_spec
  ફોર્મેટ સ્પષ્ટીકરણ શબ્દમાળા. શબ્દમાળા str
- વળતર મૂલ્ય: ફોર્મેટ કરેલ સ્ટ્રિંગ str

ઉદાહરણો નીચે દર્શાવેલ છે. ફોર્મેટ સ્ટ્રીંગના પ્રકારો અને તેમને કેવી રીતે લખવા તે પછીથી વર્ણવેલ છે.

આ ઉદાહરણમાં, અમે પ્રથમ દલીલ તરીકે આંકડાકીય લિટરલ્સ અને સ્ટ્રિંગ લિટરલ્સનો ઉપયોગ કર્યો છે, પરંતુ અલબત્ત તમે આ મૂલ્યો ધરાવતા ચલોનો ઉપયોગ કરી શકો છો.

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

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

સ્ટ્રિંગ પદ્ધતિ str.format()

સ્ટ્રિંગ str પ્રકાર માટે એક 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.

સર્પાકાર કૌંસનું વર્ણન {}

જો તમે ફોર્મેટ() પદ્ધતિમાં કર્લી કૌંસ {,} લખવા માંગતા હો, તો તેને {{,}}ની જેમ બે વાર પુનરાવર્તન કરો. નોંધ કરો કે બેકસ્લેશથી બચી શકાતું નથી.

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

> ચિહ્ન (-,+) ધ્યાનમાં લેતા નથી. જો તમે = નો ઉપયોગ કરો છો, તો ચિહ્ન સ્પષ્ટ કરેલ અક્ષર દ્વારા અનુસરવામાં આવે છે. જો તમે + નો ઉલ્લેખ કરવા માંગતા હો, તો + after = લખો. સાઇન પ્રોસેસિંગની વિગતો પછીથી વર્ણવવામાં આવી છે.

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

અંક વિભાજક (અલ્પવિરામ, અન્ડરસ્કોર)

દરેક ત્રણ અંકોમાં અલ્પવિરામ અથવા અન્ડરસ્કોર _ વિભાજક ઉમેરો. આ મોટી સંખ્યામાં વાંચવામાં સરળ બનાવે છે. નોંધ કરો કે underscore_ એ 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

ટકાવારી પ્રદર્શન

જો ફોર્મેટિંગ સ્પેસિફિકેશન સ્ટ્રિંગમાં % નો ઉલ્લેખ કરવામાં આવ્યો હોય, તો ન્યુમેરિક ફ્લોટ અથવા int નું મૂલ્ય 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%