ការបំប្លែងទម្រង់ជា Python ទ្រង់ទ្រាយ (សូន្យបំពេញ សញ្ញានិទស្សន្ត លេខគោលដប់ប្រាំមួយ ។ល។)

ដើម្បីបំប្លែង (ទម្រង់) លេខ ឬខ្សែអក្សរទៅជាទម្រង់ផ្សេងៗក្នុង Python សូមប្រើទម្រង់មុខងារដែលភ្ជាប់មកជាមួយ() ឬវិធីសាស្ត្រខ្សែអក្សរ str.format()។

នៅក្នុងផ្នែកនេះ យើងនឹងពន្យល់ពីរបៀបប្រើប្រាស់មុខងារខាងក្រោម។

• មុខងារដែលភ្ជាប់មកជាមួយ (ឧ. ជាភាសាសរសេរកម្មវិធី)format()
• វិធីសាស្រ្តខ្សែអក្សរstr.format()

លើសពីនេះ ខ្សែអក្សរបញ្ជាក់ទម្រង់សម្រាប់ការបំប្លែងទៅជាទម្រង់ខាងក្រោមត្រូវបានពន្យល់ជាមួយកូដគំរូ។

• ឆ្វេង-យុត្តិកម្ម, មជ្ឈិម-យុត្តិកម្ម, សម្មាទិដ្ឋិ
• សូន្យបំពេញ
• សញ្ញា (បូកឬដក)
• សញ្ញាបំបែកខ្ទង់ (សញ្ញាក្បៀស សញ្ញាគូសក្រោម)
• លេខគោលពីរ លេខគោលប្រាំបី និងលេខគោលដប់ប្រាំមួយ។
• បញ្ជាក់ចំនួនខ្ទង់បន្ទាប់ពីខ្ទង់ទសភាគ
• តួលេខសំខាន់ៗ (ចំនួនខ្ទង់សំខាន់ៗ)
• សញ្ញាណអិចស្ប៉ូណង់ស្យែល
• ការបង្ហាញភាគរយ

ចំណាំថាចាប់តាំងពី Python 3.6 មក f-strings (f-strings) ត្រូវបានបន្ថែមទៅ string method str.format() ដើម្បីធ្វើឱ្យវាកាន់តែសង្ខេប។

មុខងារភ្ជាប់មកជាមួយ៖ format()

format() ត្រូវ​បាន​ផ្ដល់​ជា​មុខងារ​ភ្ជាប់​មក​ជាមួយ Python ស្តង់ដារ។

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

គ្រោងមានដូចខាងក្រោម។

• format(value, format_spec)
  • អាគុយម៉ង់ដំបូង: នេះ។value
    តម្លៃដើម។ ខ្សែអក្សរ str, លេខ int, អណ្តែតជាដើម។
  • អាគុយម៉ង់ទីពីរformat_spec
    ទម្រង់​ខ្សែអក្សរ​បញ្ជាក់។ ខ្សែអក្សរ str
  • តម្លៃត្រឡប់៖ ខ្សែអក្សរដែលបានធ្វើទ្រង់ទ្រាយ str

ឧទាហរណ៍ត្រូវបានបង្ហាញខាងក្រោម។ ប្រភេទនៃទម្រង់ខ្សែអក្សរ និងរបៀបសរសេរពួកវាត្រូវបានពិពណ៌នានៅពេលក្រោយ។

ក្នុងឧទាហរណ៍នេះ យើងបានប្រើព្យញ្ជនៈលេខ និងព្យញ្ជនៈខ្សែអក្សរជាអាគុយម៉ង់ដំបូង ប៉ុន្តែជាការពិតណាស់ អ្នកអាចប្រើអថេរដែលមានតម្លៃទាំងនេះ។

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

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

វិធីសាស្ត្រខ្សែអក្សរ str.format()

វាក៏មានវិធីសាស្រ្ត format() សម្រាប់ប្រភេទ str str ផងដែរ។

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

{} ក្នុង string str ដែលហៅ method format() ត្រូវបានគេហៅថា substitution field ហើយត្រូវបានជំនួសដោយ argument នៃ format() method។

ខ្សែអក្សរបញ្ជាក់ទម្រង់គួរតែត្រូវបានសរសេរនៅក្នុងវាលជំនួស {} បន្តដោយ “:” ។

តម្លៃ​ត្រឡប់​គឺ​ជា​ខ្សែ​អក្សរ​ដែល​បាន​ធ្វើ​ទ្រង់ទ្រាយ 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.

ការពិពណ៌នាអំពីតង្កៀបអង្កាញ់ {}

បើ​អ្នក​ចង់​សរសេរ​តង្កៀប​អង្កាញ់ {,} ក្នុង​ទម្រង់ format() method ធ្វើ​វា​ម្ដង​ទៀត​ដូច​ជា {{,}}។ ចំណាំថា backslash មិនអាចគេចផុតបានទេ។

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

ខាងក្រោមនេះ យើងនឹងពន្យល់ពីរបៀបបញ្ជាក់ទម្រង់ដោយប្រើខ្សែអក្សរទ្រង់ទ្រាយ។ កូដគំរូប្រើវិធីសាស្ត្រខ្សែអក្សរ 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

Lists, 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() កណ្តាល() និង rjust() ផងដែរ។

0 បំពេញ

ប្រសិនបើអ្នកចង់កែតម្រូវចំនួនខ្ទង់ដោយការបំពេញសូន្យ សូមកំណត់តួអក្សរដែលត្រូវបំពេញទៅ 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

សម្រាប់ការបំពេញសូន្យ ក៏មានវិធីសាស្ត្រខ្សែអក្សរដែលឧទ្ទេសនាមហៅថា 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៖ Octal
• 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 ប៉ុណ្ណោះដែលអាចបំប្លែងទម្រង់ទៅជាគោលពីរ ឬលេខគោលដប់ប្រាំមួយ។ អ្នកអាចប្រើ 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() នៃ​គោលដប់​បណ្ណាល័យ​ស្ដង់ដារ។

សញ្ញាណអិចស្ប៉ូណង់ស្យែល

នៅពេលដែលលេខអណ្តែតចំណុចអណ្តែតត្រូវបានបំប្លែងទៅជាខ្សែអក្សរ 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

ចំណាំថាប្រសិនបើអ្នកបញ្ជាក់ខាងឆ្វេង យុត្តិកម្មកណ្តាល យុត្តិកម្មស្តាំ ឬសូន្យ អ៊ី- អ៊ី+ ជាដើម ក៏នឹងត្រូវបានរាប់ជាខ្ទង់ (តួអក្សរ) ផងដែរ។

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-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 ហើយ​បំប្លែង​ទៅ​ជា​ខ្សែអក្សរ​ជាមួយ % ។

វាក៏អាចធ្វើទៅបានដើម្បីបញ្ជាក់ចំនួនខ្ទង់បន្ទាប់ពីចំនុចទសភាគ។ លំនាំដើមគឺប្រាំមួយខ្ទង់បន្ទាប់ពីចំនុចទសភាគ។ Left-justify, center-justify, right-justify, និង zero-fill ក៏មានផងដែរ។ % ក៏ត្រូវបានរាប់ជាតួអក្សរផងដែរ។

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%