Python, ආකෘතියෙන් ආකෘති පරිවර්තනය (ශුන්‍ය පිරවීම, ඝාතීය අංකනය, ෂඩ් දශම, ආදිය)

Python හි අංකයක් හෝ තන්තුවක් විවිධ හැඩතලවලට පරිවර්තනය කිරීමට (ආකෘතිය) ගොඩනඟන ලද ශ්‍රිත ආකෘතිය() හෝ string ක්‍රමය str.format() භාවිතා කරන්න.

මෙම කොටසේදී, පහත සඳහන් කාර්යයන් භාවිතා කරන්නේ කෙසේදැයි අපි විස්තර කරමු.

• බිල්ට්-ඉන් ශ්‍රිතය (උදා. ක්‍රමලේඛන භාෂාවෙන්)format()
• නූල් ක්රමයstr.format()

ඊට අමතරව, පහත ආකෘතියට පරිවර්තනය කිරීම සඳහා ආකෘති පිරිවිතර තන්තුව නියැදි කේතය සමඟ පැහැදිලි කර ඇත.

• වම-සාධාරණ, මධ්‍ය-සාධාරණ, දකුණ-සාධාරණ
• ශුන්ය පිරවීම
• ලකුණ (වැඩි හෝ අඩු)
• ඉලක්කම් බෙදුම්කරු (කොමාව, යටි ඉරි)
• ද්විමය, අෂ්ටක සහ ෂඩ් දශම සංඛ්‍යා
• දශම ලක්ෂයට පසුව ඉලක්කම් ගණන සඳහන් කරන්න
• සැලකිය යුතු සංඛ්‍යා (සැලකිය යුතු ඉලක්කම් ගණන)
• ඝාතීය අංකනය
• ප්‍රතිශත සංදර්ශකය

Python 3.6 සිට, f-strings (f-strings) වඩාත් සංක්ෂිප්ත කිරීම සඳහා str.format() ක්‍රමයට එකතු කර ඇති බව සලකන්න.

ගොඩනඟන ලද කාර්යය: ආකෘතිය ()

ආකෘතිය() සම්මත Python බිල්ට්-ඉන් ශ්‍රිතයක් ලෙස සපයා ඇත.

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

දළ සටහන පහත පරිදි වේ.

• format(value, format_spec)
  • පළමු තර්කය:value
    මුල් වටිනාකම. String str, number int, float, ආදිය.
  • දෙවන තර්කයformat_spec
    ආකෘති පිරිවිතර පෙළ. String str
  • ප්‍රතිලාභ අගය: හැඩතල ගැන්වූ string එකක්

උදාහරණ පහත දැක්වේ. ආකෘති නූල් වර්ග සහ ඒවා ලියන ආකාරය පසුව විස්තර කෙරේ.

මෙම උදාහරණයේදී, අපි පළමු තර්කය ලෙස සංඛ්‍යාත්මක වචන සහ තන්තු වචන භාවිතා කර ඇත, නමුත් ඇත්ත වශයෙන්ම ඔබට මෙම අගයන් අඩංගු විචල්‍යයන් භාවිතා කළ හැකිය.

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

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

String ක්‍රමය str.format()

string str වර්ගය සඳහා ආකෘතිය() ක්‍රමයක් ද ඇත.

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

ආකෘතිය() ක්‍රමය හඳුන්වන string string හි {} ආදේශන ක්ෂේත්‍රය ලෙස හඳුන්වනු ලබන අතර, එය ආකෘතිය() ක්‍රමයේ තර්කය මගින් ප්‍රතිස්ථාපනය වේ.

ආකෘති පිරිවිතර තන්තුව ආදේශන ක්ෂේත්‍රයේ {} පසුව “:” ලිවිය යුතුය.

ප්‍රතිලාභ අගය සංයුති කළ string string වේ.

ඉහත විස්තර කර ඇති බිල්ට්-ඉන් ක්‍රියාකාරී ආකෘතිය() ට සමාන ක්‍රියාවලිය පහත පරිදි වේ.

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

පහත දැක්වෙන පරිදි, අපි ආකෘති තන්තුවක් භාවිතයෙන් ආකෘතිය නියම කරන ආකාරය පැහැදිලි කරන්නෙමු. නියැදි කේතය 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

ලැයිස්තු, ටියුපල් යනාදිය සඳහන් කළහොත් දෝෂයක් ඇති වන අතර, 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() නමින් කැපවූ තන්තු ක්‍රමයක් ද ඇත.

ලකුණ (වැඩි හෝ අඩු)

පෙරනිමියෙන්, සෘණ සංඛ්‍යා පමණක් ලකුණකින් සලකුණු කර ඇත (අඩු-).

හැඩතල ගැන්වීමේ පිරිවිතර පෙළට + එකතු කළ විට, ධනාත්මක සංඛ්‍යා සඳහා ලකුණක් (plus +) ද දර්ශනය වේ. ඉඩක් එකතු කළහොත්, ධන අංකයේ ආරම්භයේ ඉඩක් දිස්වන අතර, ඉලක්කම් ගණන සෘණ අංකයට සමපාත වේ.

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

ද්විමය සහ ෂඩ් දශම සංඛ්‍යා සඳහා, ඇතුළත් කළ හැක්කේ යටි ඉරි _ ඉලක්කම් බෙදුම්කරු පමණි (Python 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

ඔබට සාමාන්‍ය වටකුරු භාවිතා කිරීමට අවශ්‍ය නම්, ඔබට සම්මත පුස්තකාල දශමයේ quantize() ක්‍රමය භාවිතා කළ හැක.

ඝාතීය අංකනය

පාවෙන ලක්ෂ්‍ය පාවෙන අංකයක් string str එකක් බවට පරිවර්තනය කළ විට, එය සංඛ්‍යා ගණන අනුව ඝාතීය අංකනයකින් ස්වයංක්‍රීයව ලියා ඇත. integer type 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

ප්‍රතිශත සංදර්ශකය

හැඩතල ගැන්වීමේ පිරිවිතර තන්තුවෙහි % සඳහන් කර ඇත්නම්, සංඛ්‍යාත්මක float හෝ 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%