பைத்தானில் வடிவமைப்பு மாற்றம், வடிவத்தில் (பூஜ்ஜிய நிரப்புதல், அதிவேகக் குறியீடு, ஹெக்ஸாடெசிமல் போன்றவை)

பைத்தானில் ஒரு எண் அல்லது சரத்தை பல்வேறு வடிவங்களாக மாற்ற (வடிவமைக்க), உள்ளமைக்கப்பட்ட செயல்பாட்டு வடிவம்() அல்லது சரம் முறை str.format() ஐப் பயன்படுத்தவும்.

இந்த பிரிவில், பின்வரும் செயல்பாடுகளை எவ்வாறு பயன்படுத்துவது என்பதை விளக்குவோம்.

• உள்ளமைக்கப்பட்ட செயல்பாடு (எ.கா. நிரலாக்க மொழியில்)format()
• சரம் முறைstr.format()

கூடுதலாக, பின்வரும் வடிவமைப்பிற்கு மாற்றுவதற்கான வடிவமைப்பு விவரக்குறிப்பு சரம் மாதிரி குறியீட்டுடன் விளக்கப்பட்டுள்ளது.

• இடது-நியாயப்படுத்தப்பட்ட, மையம்-நியாயப்படுத்தப்பட்ட, வலது-நியாயப்படுத்தப்பட்ட
• பூஜ்யம் நிரப்புதல்
• அடையாளம் (கூடுதல் அல்லது கழித்தல்)
• இலக்கப் பிரிப்பான் (கமா, அடிக்கோடி)
• பைனரி, ஆக்டல் மற்றும் ஹெக்ஸாடெசிமல் எண்கள்
• தசம புள்ளிக்குப் பிறகு இலக்கங்களின் எண்ணிக்கையைக் குறிப்பிடவும்
• குறிப்பிடத்தக்க புள்ளிவிவரங்கள் (குறிப்பிடத்தக்க இலக்கங்களின் எண்ணிக்கை)
• அதிவேக குறியீடு
• சதவீத காட்சி

Python 3.6 முதல், f-strings (f-strings) string முறை str.format() க்கு மேலும் சுருக்கமாக சேர்க்கப்பட்டது என்பதை நினைவில் கொள்ளவும்.

உள்ளமைக்கப்பட்ட செயல்பாடு: வடிவம்()

வடிவம்() ஒரு நிலையான பைதான் உள்ளமைக்கப்பட்ட செயல்பாடாக வழங்கப்படுகிறது.

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

அவுட்லைன் பின்வருமாறு.

• format(value, format_spec)
  • முதல் வாதம்: திvalue
    அசல் மதிப்பு. string str, number int, float, etc.
  • இரண்டாவது வாதம்format_spec
    வடிவமைப்பு விவரக்குறிப்பு சரம். சரம் str
  • திரும்ப மதிப்பு: வடிவமைக்கப்பட்ட சரம் str

எடுத்துக்காட்டுகள் கீழே காட்டப்பட்டுள்ளன. வடிவமைப்பு சரங்களின் வகைகள் மற்றும் அவற்றை எவ்வாறு எழுதுவது என்பது பின்னர் விவரிக்கப்படும்.

இந்த எடுத்துக்காட்டில், நாங்கள் முதல் வாதமாக எண் எழுத்துக்கள் மற்றும் ஸ்ட்ரிங் லிட்டரல்களைப் பயன்படுத்தியுள்ளோம், ஆனால் நிச்சயமாக இந்த மதிப்புகளைக் கொண்ட மாறிகளைப் பயன்படுத்தலாம்.

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

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

சரம் முறை str.format()

string 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}

வடிவமைக்கப்பட்ட சரம்

இரண்டு சந்தர்ப்பங்களிலும், வடிவமைப்பைக் குறிப்பிட, {} இல் முழு எண் மதிப்பு அல்லது பெயர் சரத்திற்குப் பிறகு “: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

பின்வருவனவற்றில், வடிவமைப்பு சரத்தைப் பயன்படுத்தி வடிவமைப்பை எவ்வாறு குறிப்பிடுவது என்பதை விளக்குவோம். மாதிரிக் குறியீடு string முறை 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

பட்டியல்கள், tuples போன்றவை குறிப்பிடப்பட்டால் பிழையை ஏற்படுத்தும், மேலும் 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() ஐப் பயன்படுத்தலாம்.

# 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

நீங்கள் பொது ரவுண்டிங்கைப் பயன்படுத்த விரும்பினால், நிலையான நூலகத்தின் தசமத்தின் அளவு() முறையைப் பயன்படுத்தலாம்.

அதிவேக குறியீடு

ஒரு மிதக்கும்-புள்ளி மிதவை எண் ஒரு சரம் 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

சதவீத காட்சி

வடிவமைப்பு விவரக்குறிப்பு சரத்தில் % குறிப்பிடப்பட்டிருந்தால், எண் மிதவை அல்லது எண்ணின் மதிப்பு 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%