పైథాన్, ఫార్మాట్‌లో ఫార్మాట్ మార్పిడి (జీరో-ఫిల్లింగ్, ఎక్స్‌పోనెన్షియల్ సంజ్ఞామానం, హెక్సాడెసిమల్, మొదలైనవి)

పైథాన్‌లో ఒక సంఖ్య లేదా స్ట్రింగ్‌ను వివిధ ఫార్మాట్‌లలోకి మార్చడానికి (ఫార్మాట్), అంతర్నిర్మిత ఫంక్షన్ ఫార్మాట్() లేదా స్ట్రింగ్ పద్ధతిని ఉపయోగించండి str.format().

ఈ విభాగంలో, కింది ఫంక్షన్లను ఎలా ఉపయోగించాలో మేము వివరిస్తాము.

• అంతర్నిర్మిత ఫంక్షన్ (ఉదా. ప్రోగ్రామింగ్ భాషలో)format()
• స్ట్రింగ్ పద్ధతిstr.format()

అదనంగా, కింది ఫార్మాట్‌కి మార్చడానికి ఫార్మాట్ స్పెసిఫికేషన్ స్ట్రింగ్ నమూనా కోడ్‌తో వివరించబడింది.

• లెఫ్ట్-జస్టిఫైడ్, సెంటర్-జస్టిఫైడ్, రైట్-జస్టిఫైడ్
• సున్నా పూరక
• గుర్తు (ప్లస్ లేదా మైనస్)
• డిజిట్ సెపరేటర్ (కామా, అండర్ స్కోర్)
• బైనరీ, అష్టాంశ మరియు హెక్సాడెసిమల్ సంఖ్యలు
• దశాంశ బిందువు తర్వాత అంకెల సంఖ్యను పేర్కొనండి
• ముఖ్యమైన సంఖ్యలు (ముఖ్యమైన అంకెల సంఖ్య)
• ఘాతాంక సంజ్ఞామానం
• శాతం ప్రదర్శన

పైథాన్ 3.6 నుండి, స్ట్రింగ్ మెథడ్ str.format()కి f-స్ట్రింగ్స్ (f-strings) జోడించబడిందని గమనించండి.

అంతర్నిర్మిత ఫంక్షన్: ఫార్మాట్()

ఫార్మాట్() అనేది ప్రామాణిక పైథాన్ అంతర్నిర్మిత ఫంక్షన్‌గా అందించబడింది.

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

రూపురేఖలు ఇలా ఉన్నాయి.

• format(value, format_spec)
  • మొదటి వాదన: దిvalue
    అసలు విలువ. స్ట్రింగ్ స్ట్రింగ్, నంబర్ పూర్ణాంక, ఫ్లోట్ మొదలైనవి.
  • రెండవ వాదనformat_spec
    ఫార్మాట్ స్పెసిఫికేషన్ స్ట్రింగ్. స్ట్రింగ్ స్ట్రింగ్
  • రిటర్న్ విలువ: ఫార్మాట్ చేయబడిన స్ట్రింగ్ స్ట్రింగ్

ఉదాహరణలు క్రింద చూపబడ్డాయి. ఫార్మాట్ స్ట్రింగ్‌ల రకాలు మరియు వాటిని ఎలా వ్రాయాలి అనేది తరువాత వివరించబడింది.

ఈ ఉదాహరణలో, మేము మొదటి ఆర్గ్యుమెంట్‌గా న్యూమరిక్ లిటరల్స్ మరియు స్ట్రింగ్ లిటరల్స్‌ని ఉపయోగించాము, అయితే మీరు ఈ విలువలను కలిగి ఉన్న వేరియబుల్స్‌ని ఉపయోగించవచ్చు.

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.

పైన వివరించిన అంతర్నిర్మిత ఫంక్షన్ ఫార్మాట్()కి సమానమైన ప్రక్రియ క్రింది విధంగా ఉంటుంది.

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

>తో కుడి-సమర్థన; (-,+) గుర్తును పరిగణనలోకి తీసుకోదు. మీరు = ఉపయోగిస్తే, గుర్తును పేర్కొన్న అక్షరం అనుసరించబడుతుంది. మీరు + పేర్కొనాలనుకుంటే, = తర్వాత + అని వ్రాయండి. సైన్ ప్రాసెసింగ్ వివరాలు తరువాత వివరించబడ్డాయి.

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(), centre(), మరియు 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

మీరు ఫార్మాటింగ్ స్పెసిఫికేషన్ స్ట్రింగ్‌లో 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

మీరు ఎడమ-జస్టిఫైడ్, సెంటర్-జస్టిఫైడ్, రైట్-జస్టిఫైడ్ లేదా జీరో-ఫిల్డ్ అని పేర్కొన్నట్లయితే, ఇ-, ఇ+, మొదలైనవి కూడా అంకెలు (అక్షరాలు)గా గణించబడతాయని గుర్తుంచుకోండి.

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%