Python တွင် ဖော်မတ်ပြောင်းခြင်း၊ ဖော်မတ် (သုညဖြည့်ခြင်း၊ ကိန်းဂဏန်းအမှတ်အသား၊ ဆဋ္ဌမကိန်းဂဏန်း စသည်ဖြင့်)

Python တွင် အမျိုးမျိုးသော ဖော်မတ်များ (ဖော်မက်) သို့မဟုတ် နံပါတ်တစ်ခုသို့ ပြောင်းရန်၊ တပ်ဆင်ထားသော လုပ်ဆောင်ချက်ဖော်မတ်() သို့မဟုတ် string method str.format() ကို အသုံးပြုပါ။

ဤကဏ္ဍတွင်၊ အောက်ပါလုပ်ဆောင်ချက်များကို အသုံးပြုပုံကို ရှင်းပြပါမည်။

• built-in လုပ်ဆောင်ချက် (ဥပမာ ပရိုဂရမ်းမင်း ဘာသာစကား)format()
• string methodstr.format()

ထို့အပြင်၊ အောက်ပါဖော်မတ်သို့ပြောင်းခြင်းအတွက် ဖော်မတ်သတ်မှတ်ချက်စာကြောင်းကို နမူနာကုဒ်ဖြင့် ရှင်းပြထားသည်။

• ဘယ်-တရားမျှတ၊ အလယ်တည့်တည့်၊ ညာ-တရားမျှတမှု
• သုညဖြည့်စွက်
• ဆိုင်းဘုတ် (အပေါင်း သို့မဟုတ် အနုတ်)
• ဂဏန်းခြားခြင်း (ကော်မာ၊ အမှတ်အသား)
• Binary၊ octal နှင့် hexadecimal ဂဏန်းများ
• ဒဿမအမှတ်ပြီးနောက် ဂဏန်းအရေအတွက်ကို သတ်မှတ်ပါ။
• ထင်ရှားသော ကိန်းဂဏာန်းများ (ထင်ရှားသော ဂဏန်းများ)
• exponential notation
• ရာခိုင်နှုန်းပြသခြင်း။

Python 3.6 ကတည်းက၊ f-strings (f-strings) များကို ပိုမိုတိကျစေရန် string method str.format() တွင် ထည့်သွင်းထားကြောင်း သတိပြုပါ။

Built-in လုပ်ဆောင်ချက်- ဖော်မတ်()

format() ကို စံ Python built-in လုပ်ဆောင်ချက်အဖြစ် ပံ့ပိုးထားသည်။

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

အကြမ်းဖျင်းမှာ အောက်ပါအတိုင်းဖြစ်သည်။

• format(value, format_spec)
  • ပထမအငြင်းအခုံvalue
    မူရင်းတန်ဖိုး။ စာကြောင်း str၊ နံပါတ် int၊ float စသည်ဖြင့်။
  • ဒုတိယအငြင်းအခုံformat_spec
    ဖော်မတ်သတ်မှတ်ချက် စာကြောင်း။ စာတန်း str
  • ပြန်ပို့တန်ဖိုး- ဖော်မတ်လုပ်ထားသည့် စာကြောင်း str

နမူနာများကို အောက်တွင် ပြထားသည်။ ဖော်မတ်စာတန်းအမျိုးအစားများနှင့် ၎င်းတို့ကို မည်သို့ရေးရမည်ကို နောက်ပိုင်းတွင် ဖော်ပြထားပါသည်။

ဤဥပမာတွင်၊ ကျွန်ုပ်တို့သည် ပထမအငြင်းအခုံအဖြစ် numeric literals နှင့် string literals ကိုအသုံးပြုထားသော်လည်း၊ ဤတန်ဖိုးများပါရှိသော variable များကို သင်အသုံးပြုနိုင်ပါသည်။

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

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

စာကြောင်းနည်းလမ်း str.format()

string str အမျိုးအစားအတွက် format() method တစ်ခုလည်း ရှိပါသည်။

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

format() method ကိုခေါ်သော string str ရှိ {} ကို အစားထိုးအကွက်ဟုခေါ်ပြီး format() method ၏ argument ဖြင့် အစားထိုးပါသည်။

ဖော်မတ်သတ်မှတ်ချက်စာကြောင်းကို အစားထိုးအကွက် {} တွင် “ :” ဖြင့် ရေးသားသင့်သည်။

ပြန်ပေးသည့်တန်ဖိုးသည် ဖော်မတ်ချထားသည့် စာကြောင်း str ဖြစ်သည်။

အထက်တွင်ဖော်ပြထားသော built-in function format() နှင့်ညီမျှသောလုပ်ငန်းစဉ်သည်အောက်ပါအတိုင်းဖြစ်သည်။

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} ကဲ့သို့ ကိန်းပြည့်တန်ဖိုးကို {} တွင် သတ်မှတ်ထားပါက၊ အထွက်နှုန်းသည် အကြောင်းပြချက်များ၏ အစီအစဥ်ပေါ်တွင် မူတည်ပါသည်။ တူညီသောနံပါတ်ကို ထပ်ခါတလဲလဲသုံးနိုင်သည်။ string တစ်ခုတွင် တူညီသောတန်ဖိုးကို ထည့်သွင်းလိုသောအခါ ၎င်းသည် အသုံးဝင်သည်။

print('{0}-{1}-{0}'.format('foo', 'bar'))
# foo-bar-foo

မတရားသောအမည်များ (စာကြောင်းများ) အတွက် အဓိကစကားလုံးအငြင်းပွားမှုများကို သတ်မှတ်ပါ

သင်သည် {} တွင် မည်သည့်အမည်ကိုမဆို သတ်မှတ်နိုင်ပြီး ၎င်းကို သော့ချက်စကားလုံး အငြင်းအခုံအဖြစ် ထည့်သွင်းနိုင်သည်။

print('{day}/{month}/{year}/'.format(day=11, month=1, year=2018))
# 11/1/2018

စာရင်း သို့မဟုတ် အဘိဓာန်ကို အငြင်းအခုံတစ်ခုအဖြစ် သတ်မှတ်ပါ။

စာရင်းများနှင့် အဘိဓာန်များကို အကြောင်းပြချက်များအဖြစ် သတ်မှတ်နိုင်သည်။

စာရင်းတစ်ခု၏အညွှန်း သို့မဟုတ် အစားထိုးအကွက်တစ်ခုရှိ အဘိဓာန်၏သော့ကို သတ်မှတ်ရန် [] ကိုသုံးပါ။ အဘိဓာန်သော့များကို သတ်မှတ်ရန် quotation marks “ ‘” နှင့် “ ” ကို အသုံးမပြုကြောင်း သတိပြုပါ။

တူညီသော အကြောင်းပြချက်ကို ထပ်ခါတလဲလဲ အသုံးပြုလိုပါက၊ အထက်တွင် ဖော်ပြထားသည့်အတိုင်း ကိန်းပြည့်တန်ဖိုး သို့မဟုတ် စာကြောင်း (အမည်) ကို သတ်မှတ်ရန် လိုအပ်သည်။

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.

curly brackets ၏ ရှင်းလင်းချက် {}

အကောက်ကောက်ကွင်းများ {,} ကို ဖော်မတ်() နည်းလမ်းဖြင့် ရေးသားလိုပါက၊ ၎င်းကို {{,}} ကဲ့သို့ နှစ်ခါပြန်လုပ်ပါ။ backslashes များကို မလွတ်နိုင်သည်ကို သတိပြုပါ။

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 method str.format() ကို အသုံးပြုသော်လည်း တူညီသော ဖော်မတ်စာတန်းကို built-in function format() ဖြင့် အသုံးပြုနိုင်ပါသည်။ Built-in function format() တွင် ဖော်မတ်သတ်မှတ်ချက် string ကို ဒုတိယအငြင်းအခုံအဖြစ် သတ်မှတ်ထားသည်။

ဘယ်-တရားမျှတ၊ အလယ်တည့်တည့်၊ ညာ-တရားမျှတမှု

အောက်တွင် ဘယ်ဘက်-မျှတအောင်၊ ဗဟို-မျှတအောင်၊ ညာဘက်-မျှတအောင် စသည်တို့ကို ချိန်ညှိနိုင်သည်။ စုစုပေါင်း စာလုံးအရေအတွက်ကို နံပါတ်တစ်ခုအဖြစ် သတ်မှတ်ပါ။

• <
• ^
• >

print('left  : {:<10}'.format(100))
print('center: {:^10}'.format(100))
print('right : {:>10}'.format(100))
# left  : 100       
# center:    100    
# right :        100

ဖြည့်သွင်းရမည့် စာလုံးကိုလည်း သင် သတ်မှတ်နိုင်သည်။ အထက်ဖော်ပြပါ ဥပမာတွင် ချန်လှပ်ထားလျှင် ၎င်းသည် space တစ်ခုဖြစ်သည်။

စာလုံးတစ်လုံးတည်းရှိသရွေ့ သင်သည် double-byte စာလုံးများကို သုံးနိုင်သည်။

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

<၊ ^၊ နှင့် > strings များအတွက်သတ်မှတ်ထားနိုင်သည်၊ သို့သော် = ValueError သည် error ဖြစ်ပေါ်လိမ့်မည်။ = စာကြောင်းတစ်ခုအတွက် အသုံးပြုလိုပါက၊ ၎င်းကို int() ကို အသုံးပြု၍ နံပါတ်တစ်ခုသို့ ပြောင်းလဲရန် လိုအပ်သည်။

# print('sign: {:0=10}'.format('-100'))
# ValueError: '=' alignment not allowed in string format specifier

print('sign: {:0=10}'.format(int('-100')))
# sign: -000000100

Floating Point နံပါတ်များနှင့် အလားတူသည်။ ဒဿမအမှတ်များကို ဇာတ်ကောင်အဖြစ်လည်း ရေတွက်သည်။

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 စသည်တို့သည် သတ်မှတ်ထားသော as-is ဖြစ်နေပါက အမှားအယွင်းဖြစ်စေပြီး 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 သို့ ဖြည့်ရန် သတ်မှတ်ပြီး ၎င်းကို ညာဘက်သို့ ချိန်ညှိပါ။

သုညဖြည့်ခြင်းကိစ္စတွင်၊ ချိန်ညှိမှုသင်္ကေတကို ချန်လှပ်ထားပါက၊ ၎င်းကို if = သတ်မှတ်ထားသည့်အတိုင်း လုပ်ဆောင်သည်။

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

zero-filling အတွက် zfill() ဟုခေါ်သော သီးခြား string method တစ်ခုလည်း ရှိပါသည်။

ဆိုင်းဘုတ် (အပေါင်း သို့မဟုတ် အနုတ်)

ပုံမှန်အားဖြင့်၊ အနုတ်နံပါတ်များကိုသာ သင်္ကေတ (အနှုတ်-) ဖြင့် အမှတ်အသားပြုပါသည်။

ဖော်မတ်သတ်မှတ်ခြင်းသတ်မှတ်ချက်စာကြောင်းသို့ + ကိုပေါင်းထည့်သောအခါ၊ သင်္ကေတ (အပေါင်း +) ကို အပြုသဘောဆောင်သော နံပါတ်များအတွက်လည်း ပြသပါသည်။ နေရာလွတ်တစ်ခုကို ပေါင်းထည့်ပါက အပေါင်းကိန်းဂဏန်းများ၏အစတွင် နေရာလွတ်တစ်ခုကို ပြသမည်ဖြစ်ပြီး ဂဏန်းများ၏ အရေအတွက်သည် အနုတ်နံပါတ်နှင့် ချိန်ညှိထားသည်။

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

Float-point နံပါတ် float အမျိုးအစားများတွင်၊ ကိန်းပြည့်အပိုင်းကိုသာ ကန့်သတ်ထားသည်။

print('{:,}'.format(1234.56789))
# 1,234.56789

Binary၊ octal နှင့် hexadecimal ဂဏန်းများ

ကိန်းဂဏာန်းတန်ဖိုးများကို အထွက်အတွက် ဒွိ၊ အဋ္ဌမ၊ နှင့် ဆဋ္ဌမဂဏန်းများအဖြစ်သို့ ပြောင်းသည်။

• b: ဒွိ
• o: Octal
• d: ဒဿမ
• x၊X: Hexadecimal (စာလုံးအကြီးများကို စာလုံးကြီးဖြင့် ရေးထားသည်)

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-fill နှင့်လည်း ပေါင်းစပ်နိုင်ပြီး binary နှင့် hexadecimal သင်္ကေတများတွင် ဂဏန်းများကို ချိန်ညှိရန် မကြာခဏ အသုံးပြုလေ့ရှိသည်။

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

binary နှင့် hexadecimal ဂဏန်းများအတွက်၊ underscore _ digit ခြားနားခြင်းကိုသာ ထည့်သွင်းနိုင်သည် (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 မှသာလျှင် ဖော်မတ်ကို ဒွိ (သို့) ဆဋ္ဌမဂဏန်းအဖြစ် ပြောင်းလဲနိုင်သည်။ ၎င်းကို နံပါတ်တစ်ခုအဖြစ်သို့ ပြောင်းရန် 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() နည်းလမ်းကို အသုံးပြုနိုင်သည်။

exponential notation

floating-point float နံပါတ်ကို string str သို့ပြောင်းသောအခါ၊ ဂဏန်းအရေအတွက်ပေါ်မူတည်၍ exponential notation ဖြင့် အလိုအလျောက်ရေးသားမည်ဖြစ်ပါသည်။ 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 ကို သတ်မှတ်ပါက၊ သင်သည် အညွှန်းကိန်းအဖြစ် အမြဲတမ်းပြောင်းနိုင်သည်။ output တွင်အသုံးပြုသောစာလုံးများသည် 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 သည် ကိစ္စအများစုတွင် တူညီသော်လည်း output သည် integer ဖြစ်သည့်ကိစ္စများတွင်သာဖြစ်သည်။

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

ရာခိုင်နှုန်းပြသခြင်း။

% ကို ဖော်မတ်သတ်မှတ်ခြင်း သတ်မှတ်ချက် string တွင် သတ်မှတ်ထားပါက၊ ကိန်းဂဏာန်း မျှော့ သို့မဟုတ် 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%