ការបង្គត់ទសភាគ និងចំនួនគត់ក្នុង Python ជាមួយ “មូល” និង “Decimal.quantize

ខាងក្រោមនេះពន្យល់ពីរបៀបបង្គត់លេខនៅក្នុង Python ដោយបង្គត់ ឬបង្គត់ទៅជាលេខគូ។ លេខត្រូវបានសន្មត់ថាជាចំនុចអណ្តែតអណ្តែត ឬប្រភេទ integer int ។

• មុខងារដែលភ្ជាប់មកជាមួយ (ឧ. ជាភាសាសរសេរកម្មវិធី):round()
  • ខ្ទង់ទសភាគទៅចំនួនខ្ទង់ណាមួយ។
  • ចំនួនគត់បង្គត់ទៅចំនួនខ្ទង់ណាមួយ។
  • round() បង្គត់​ទៅ​ជា​លេខ​គូ មិនមែន​ទៅ​ជា​ការ​បង្គត់​ធម្មតា​ទេ។
• បណ្ណាល័យស្តង់ដារdecimalquantize()
  • Decimalការបង្កើតវត្ថុមួយ។
  • ការបង្គត់ទសភាគទៅចំនួនខ្ទង់ណាមួយ ហើយបង្គត់ទៅលេខគូ
  • ការបង្គត់ចំនួនគត់ទៅចំនួនខ្ទង់ណាមួយ ហើយបង្គត់ទៅលេខគូ
• កំណត់មុខងារថ្មី។
  • បង្គត់ទសភាគទៅចំនួនខ្ទង់ណាមួយ។
  • ចំនួនគត់បង្គត់ទៅចំនួនខ្ទង់ណាមួយ។
  • ចំណាំ៖ សម្រាប់តម្លៃអវិជ្ជមាន

សូមចំណាំថា ដូចដែលបានរៀបរាប់ខាងលើ ជុំមុខងារដែលភ្ជាប់មកជាមួយមិនមែនជាការបង្គត់ទូទៅទេ ប៉ុន្តែជាការបង្គត់ទៅជាលេខគូ។ សូមមើលខាងក្រោមសម្រាប់ព័ត៌មានលម្អិត។

មុខងារដែលភ្ជាប់មកជាមួយ (ឧ. ជាភាសាសរសេរកម្មវិធី):round()

Round() ត្រូវបានផ្តល់ជាមុខងារដែលភ្ជាប់មកជាមួយ។ វាអាចប្រើបានដោយមិនចាំបាច់នាំចូលម៉ូឌុលណាមួយឡើយ។

• round() — Built-in Functions — Python 3.10.2 Documentation

អាគុយម៉ង់ទីមួយគឺជាលេខដើម ហើយអាគុយម៉ង់ទីពីរគឺជាចំនួនខ្ទង់ (ចំនួនខ្ទង់ដែលត្រូវបង្គត់ទៅ)។

ខ្ទង់ទសភាគទៅចំនួនខ្ទង់ណាមួយ។

ខាង​ក្រោម​នេះ​គឺ​ជា​ឧទាហរណ៍​នៃ​ការ​ដំណើរ​ការ​សម្រាប់​ប្រភេទ​អណ្ដែត​អណ្ដែត។

ប្រសិនបើអាគុយម៉ង់ទីពីរត្រូវបានលុបចោល វាត្រូវបានបង្គត់ទៅជាចំនួនគត់។ ប្រភេទក៏ក្លាយជាប្រភេទ int ចំនួនគត់។

f = 123.456

print(round(f))
# 123

print(type(round(f)))
# <class 'int'>

ប្រសិនបើអាគុយម៉ង់ទីពីរត្រូវបានបញ្ជាក់ វាត្រឡប់ប្រភេទអណ្តែតចំណុចអណ្តែត។

ប្រសិនបើចំនួនគត់វិជ្ជមានត្រូវបានបញ្ជាក់ ខ្ទង់ទសភាគត្រូវបានបញ្ជាក់។ ប្រសិនបើចំនួនគត់អវិជ្ជមានត្រូវបានបញ្ជាក់ នោះចំនួនគត់ត្រូវបានបញ្ជាក់។ -1 ជុំទៅភាគដប់ជិតបំផុត -2 ជុំទៅជិតខ្ទង់រយ និង 0 ជុំទៅចំនួនគត់ (កន្លែងដំបូង) ប៉ុន្តែត្រឡប់ប្រភេទអណ្តែត មិនដូចពេលដែលលុប។

print(round(f, 1))
# 123.5

print(round(f, 2))
# 123.46

print(round(f, -1))
# 120.0

print(round(f, -2))
# 100.0

print(round(f, 0))
# 123.0

print(type(round(f, 0)))
# <class 'float'>

ចំនួនគត់បង្គត់ទៅចំនួនខ្ទង់ណាមួយ។

ខាង​ក្រោម​នេះ​គឺ​ជា​ឧទាហរណ៍​នៃ​ការ​ដំណើរ​ការ​សម្រាប់​ចំនួន​គត់​ប្រភេទ int ។

ប្រសិនបើអាគុយម៉ង់ទីពីរត្រូវបានលុបចោល ឬប្រសិនបើ 0 ឬចំនួនគត់វិជ្ជមានត្រូវបានបញ្ជាក់ តម្លៃដើមត្រូវបានត្រលប់មកវិញដូចបច្ចុប្បន្ន។ ប្រសិនបើចំនួនគត់អវិជ្ជមានត្រូវបានបញ្ជាក់ វាត្រូវបានបង្គត់ទៅខ្ទង់ចំនួនគត់ដែលត្រូវគ្នា។ ក្នុងករណីទាំងពីរ ប្រភេទ int ចំនួនគត់ត្រូវបានត្រឡប់។

i = 99518

print(round(i))
# 99518

print(round(i, 2))
# 99518

print(round(i, -1))
# 99520

print(round(i, -2))
# 99500

print(round(i, -3))
# 100000

round() បង្គត់​ទៅ​ជា​លេខ​គូ មិនមែន​ទៅ​ជា​ការ​បង្គត់​ធម្មតា​ទេ។

ចំណាំថាការបង្គត់ដោយអនុគមន៍ round() ដែលភ្ជាប់មកជាមួយនៅក្នុង Python 3 ជុំទៅជាលេខគូ មិនមែនទៅការបង្គត់ទូទៅទេ។

ដូចដែលបានសរសេរនៅក្នុងឯកសារផ្លូវការ 0.5 ត្រូវបានបង្គត់ទៅ 0, 5 ត្រូវបានបង្គត់ទៅ 0 ហើយដូច្នេះនៅលើ។

• round() — Built-in Functions — Python 3.10.2 Documentation

print('0.4 =>', round(0.4))
print('0.5 =>', round(0.5))
print('0.6 =>', round(0.6))
# 0.4 => 0
# 0.5 => 0
# 0.6 => 1

print('4 =>', round(4, -1))
print('5 =>', round(5, -1))
print('6 =>', round(6, -1))
# 4 => 0
# 5 => 0
# 6 => 10

និយមន័យនៃការបង្គត់ទៅជាលេខគូមានដូចខាងក្រោម។

ប្រសិនបើប្រភាគតិចជាង 0.5 សូមបង្គត់វាចុះ។ ប្រសិនបើប្រភាគធំជាង 0.5 ចូរបង្គត់វាឡើង; ប្រសិនបើប្រភាគគឺពិតប្រាកដ 0.5 សូមបង្គត់វារហូតដល់ចំនួនគូរវាងការបង្គត់ចុះក្រោម និងបង្គត់ឡើង។
Rounding – Wikipedia

0.5 មិនតែងតែត្រូវបានកាត់បន្ថយទេ។

print('0.5 =>', round(0.5))
print('1.5 =>', round(1.5))
print('2.5 =>', round(2.5))
print('3.5 =>', round(3.5))
print('4.5 =>', round(4.5))
# 0.5 => 0
# 1.5 => 2
# 2.5 => 2
# 3.5 => 4
# 4.5 => 4

ក្នុងករណីខ្លះ និយមន័យនៃការបង្គត់ទៅលេខគូ ក៏មិនអនុវត្តចំពោះដំណើរការបន្ទាប់ពីខ្ទង់ទសភាគពីរដែរ។

print('0.05 =>', round(0.05, 1))
print('0.15 =>', round(0.15, 1))
print('0.25 =>', round(0.25, 1))
print('0.35 =>', round(0.35, 1))
print('0.45 =>', round(0.45, 1))
# 0.05 => 0.1
# 0.15 => 0.1
# 0.25 => 0.2
# 0.35 => 0.3
# 0.45 => 0.5

នេះគឺដោយសារតែការពិតដែលថាទសភាគមិនអាចត្រូវបានតំណាងយ៉ាងពិតប្រាកដជាលេខចំណុចអណ្តែតទឹក ដូចដែលមានចែងក្នុងឯកសារផ្លូវការ។

ឥរិយាបថរបស់ round() សម្រាប់លេខអណ្តែតទឹកអាចធ្វើអោយអ្នកភ្ញាក់ផ្អើល:ឧទាហរណ៍ ជុំ(2.675, 2) នឹងផ្តល់ឱ្យអ្នកនូវ 2.67 ជំនួសឱ្យ 2.68 ដូចដែលបានរំពឹងទុក។ នេះមិនមែនជាកំហុសទេ។:នេះ​ជា​លទ្ធផល​នៃ​ការ​ពិត​ដែល​ទសភាគ​ភាគ​ច្រើន​មិន​អាច​ត្រូវ​បាន​តំណាង​យ៉ាង​ពិត​ប្រាកដ​ដោយ​លេខ​អណ្តែត​ទឹក​។
round() — Built-in Functions — Python 3.10.2 Documentation

ប្រសិនបើអ្នកចង់សម្រេចបានការបង្គត់ទូទៅ ឬការបង្គត់ខ្ទង់ទសភាគទៅលេខគូ អ្នកអាចប្រើបរិមាណទសភាគបណ្ណាល័យស្ដង់ដារ (ពិពណ៌នាខាងក្រោម) ឬកំណត់មុខងារថ្មី។

សូមចំណាំផងដែរថា round() នៅក្នុង Python 2 មិនបង្គត់ទៅជាលេខគូទេ ប៉ុន្តែបង្គត់។

quantize() នៃទសភាគបណ្ណាល័យស្ដង់ដារ

ម៉ូឌុលទសភាគនៃបណ្ណាល័យស្ដង់ដារអាចត្រូវបានប្រើដើម្បីដោះស្រាយលេខទសភាគអណ្តែតទឹកពិតប្រាកដ។

• decimal — Decimal fixed point and floating point arithmetic — Python 3.10.2 Documentation

ដោយប្រើវិធីសាស្រ្ត quantize() នៃម៉ូឌុលទសភាគ វាអាចធ្វើទៅបានក្នុងការបង្គត់លេខដោយបញ្ជាក់របៀបបង្គត់។

• decimal quantize() — Decimal fixed point and floating point arithmetic — Python 3.10.2 Documentation
• Rounding modes — Decimal fixed point and floating point arithmetic — Python 3.10.2 Documentation

តម្លៃកំណត់សម្រាប់ការបង្គត់អាគុយម៉ង់នៃវិធីសាស្ត្រ quantize() មានអត្ថន័យដូចខាងក្រោមរៀងៗខ្លួន។

• ROUND_HALF_UP:ការបង្គត់ទូទៅ
• ROUND_HALF_EVEN:ការបង្គត់ទៅលេខគូ

ម៉ូឌុលទសភាគគឺជាបណ្ណាល័យស្ដង់ដារ ដូច្នេះមិនតម្រូវឱ្យមានការដំឡើងបន្ថែមទេ ប៉ុន្តែការនាំចូលគឺចាំបាច់។

from decimal import Decimal, ROUND_HALF_UP, ROUND_HALF_EVEN

ការបង្កើតវត្ថុទសភាគ

ទសភាគ() អាចត្រូវបានប្រើដើម្បីបង្កើតវត្ថុនៃប្រភេទទសភាគ។

ប្រសិនបើអ្នកបញ្ជាក់ប្រភេទអណ្តែតជាអំណះអំណាង អ្នកអាចឃើញថាតើតម្លៃត្រូវបានចាត់ទុកជាអ្វី។

print(Decimal(0.05))
# 0.05000000000000000277555756156289135105907917022705078125

print(type(Decimal(0.05)))
# <class 'decimal.Decimal'>

ដូចដែលបានបង្ហាញក្នុងឧទាហរណ៍ 0.05 មិនត្រូវបានចាត់ទុកថាពិតប្រាកដ 0.05 ទេ។ នេះជាហេតុផលដែលមុខងារដែលភ្ជាប់មកជាមួយ round() ដែលបានពិពណ៌នាខាងលើបង្គត់ទៅតម្លៃខុសពីការរំពឹងទុកសម្រាប់តម្លៃទសភាគ រួមទាំង 0.05 ក្នុងឧទាហរណ៍។

ដោយសារ 0.5 គឺមួយពាក់កណ្តាល (-1 អំណាចនៃ 2) វាអាចត្រូវបានបញ្ជាក់យ៉ាងពិតប្រាកដនៅក្នុងសញ្ញាគោលពីរ។

print(Decimal(0.5))
# 0.5

ប្រសិនបើអ្នកបញ្ជាក់ប្រភេទខ្សែអក្សរ str ជំនួសឱ្យប្រភេទអណ្តែត វានឹងត្រូវបានចាត់ទុកជាប្រភេទទសភាគនៃតម្លៃពិតប្រាកដ។

print(Decimal('0.05'))
# 0.05

ការបង្គត់ទសភាគទៅចំនួនខ្ទង់ណាមួយ ហើយបង្គត់ទៅលេខគូ

ហៅ quantize() ពីវត្ថុនៃប្រភេទ Decimal ដើម្បីបង្គត់តម្លៃ។

អាគុយម៉ង់ដំបូងនៃ quantize() គឺជាខ្សែអក្សរដែលមានចំនួនខ្ទង់ដូចគ្នាទៅនឹងចំនួនខ្ទង់ដែលអ្នកចង់ស្វែងរក ដូចជា ‘0.1’ ឬ ‘0.01’។

លើសពីនេះ អាគុយម៉ង់ ROUNDING បញ្ជាក់របៀបបង្គត់។ ប្រសិនបើ ROUND_HALF_UP ត្រូវបានបញ្ជាក់ ការបង្គត់ទូទៅត្រូវបានប្រើ។

f = 123.456

print(Decimal(str(f)).quantize(Decimal('0'), rounding=ROUND_HALF_UP))
# 123

print(Decimal(str(f)).quantize(Decimal('0.1'), rounding=ROUND_HALF_UP))
# 123.5

print(Decimal(str(f)).quantize(Decimal('0.01'), rounding=ROUND_HALF_UP))
# 123.46

មិនដូចមុខងារដែលភ្ជាប់មកជាមួយ round(), 0.5 ត្រូវបានបង្គត់ទៅ 1។

print('0.4 =>', Decimal(str(0.4)).quantize(Decimal('0'), rounding=ROUND_HALF_UP))
print('0.5 =>', Decimal(str(0.5)).quantize(Decimal('0'), rounding=ROUND_HALF_UP))
print('0.6 =>', Decimal(str(0.6)).quantize(Decimal('0'), rounding=ROUND_HALF_UP))
# 0.4 => 0
# 0.5 => 1
# 0.6 => 1

ប្រសិនបើការបង្គត់អាគុយម៉ង់ត្រូវបានកំណត់ទៅ ROUND_HALF_EVEN ការបង្គត់ត្រូវបានអនុវត្តទៅជាលេខគូ ដូចនៅក្នុងមុខងារដែលភ្ជាប់មកជាមួយ round()។

ដូចដែលបានរៀបរាប់ខាងលើ ប្រសិនបើប្រភេទអណ្តែតចំណុចអណ្តែតត្រូវបានបញ្ជាក់ជាអាគុយម៉ង់នៃទសភាគ() វាត្រូវបានចាត់ទុកជាវត្ថុទសភាគដែលមានតម្លៃស្មើនឹងតម្លៃពិតនៃប្រភេទអណ្តែត ដូច្នេះលទ្ធផលនៃការប្រើប្រាស់ quantize() method នឹងខុសពីអ្វីដែលរំពឹងទុក ដូចជាមុខងារដែលភ្ជាប់មកជាមួយ round()។

print('0.05 =>', round(0.05, 1))
print('0.15 =>', round(0.15, 1))
print('0.25 =>', round(0.25, 1))
print('0.35 =>', round(0.35, 1))
print('0.45 =>', round(0.45, 1))
# 0.05 => 0.1
# 0.15 => 0.1
# 0.25 => 0.2
# 0.35 => 0.3
# 0.45 => 0.5

print('0.05 =>', Decimal(0.05).quantize(Decimal('0.1'), rounding=ROUND_HALF_EVEN))
print('0.15 =>', Decimal(0.15).quantize(Decimal('0.1'), rounding=ROUND_HALF_EVEN))
print('0.25 =>', Decimal(0.25).quantize(Decimal('0.1'), rounding=ROUND_HALF_EVEN))
print('0.35 =>', Decimal(0.35).quantize(Decimal('0.1'), rounding=ROUND_HALF_EVEN))
print('0.45 =>', Decimal(0.45).quantize(Decimal('0.1'), rounding=ROUND_HALF_EVEN))
# 0.05 => 0.1
# 0.15 => 0.1
# 0.25 => 0.2
# 0.35 => 0.3
# 0.45 => 0.5

ប្រសិនបើអាគុយម៉ង់នៃ Decimal() ត្រូវបានបញ្ជាក់ជាខ្សែអក្សរនៃប្រភេទ str វាត្រូវបានចាត់ទុកជាវត្ថុទសភាគនៃតម្លៃនោះពិតប្រាកដ ដូច្នេះលទ្ធផលគឺដូចការរំពឹងទុក។

print('0.05 =>', Decimal(str(0.05)).quantize(Decimal('0.1'), rounding=ROUND_HALF_EVEN))
print('0.15 =>', Decimal(str(0.15)).quantize(Decimal('0.1'), rounding=ROUND_HALF_EVEN))
print('0.25 =>', Decimal(str(0.25)).quantize(Decimal('0.1'), rounding=ROUND_HALF_EVEN))
print('0.35 =>', Decimal(str(0.35)).quantize(Decimal('0.1'), rounding=ROUND_HALF_EVEN))
print('0.45 =>', Decimal(str(0.45)).quantize(Decimal('0.1'), rounding=ROUND_HALF_EVEN))
# 0.05 => 0.0
# 0.15 => 0.2
# 0.25 => 0.2
# 0.35 => 0.4
# 0.45 => 0.4

ដោយសារ 0.5 អាច​ត្រូវ​បាន​គ្រប់គ្រង​ដោយ​ប្រភេទ​អណ្តែត​បាន​ត្រឹមត្រូវ វា​គ្មាន​បញ្ហា​ក្នុង​ការ​បញ្ជាក់​ប្រភេទ​អណ្តែត​ជា​អាគុយម៉ង់​នៃ Decimal() ពេល​បង្គត់​ទៅ​ចំនួន​គត់ ប៉ុន្តែ​វា​មាន​សុវត្ថិភាព​ជាង​ក្នុង​ការ​បញ្ជាក់​ប្រភេទ str str ពេល​បង្គត់​ទៅ​ខ្ទង់​ទសភាគ។

ឧទាហរណ៍ 2.675 គឺពិតជា 2.67499…. ក្នុងប្រភេទអណ្តែត។ ដូច្នេះហើយ ប្រសិនបើអ្នកចង់បង្គត់ទៅខ្ទង់ទសភាគពីរ អ្នកត្រូវតែបញ្ជាក់ខ្សែអក្សរទៅជា Decimal() បើមិនដូច្នេះទេលទ្ធផលនឹងខុសពីលទ្ធផលដែលរំពឹងទុក មិនថាអ្នកបង្គត់ទៅលេខទាំងមូលដែលនៅជិតបំផុត (ROUND_HALF_UP) ឬទៅលេខគូ (ROUND_HALF_EVEN )

print(Decimal(2.675))
# 2.67499999999999982236431605997495353221893310546875

print(Decimal(2.675).quantize(Decimal('0.01'), rounding=ROUND_HALF_UP))
# 2.67

print(Decimal(str(2.675)).quantize(Decimal('0.01'), rounding=ROUND_HALF_UP))
# 2.68

print(Decimal(2.675).quantize(Decimal('0.01'), rounding=ROUND_HALF_EVEN))
# 2.67

print(Decimal(str(2.675)).quantize(Decimal('0.01'), rounding=ROUND_HALF_EVEN))
# 2.68

ចំណាំថាវិធីសាស្ត្រ quantize() ត្រឡប់លេខប្រភេទទសភាគ ដូច្នេះប្រសិនបើអ្នកចង់ដំណើរការលើលេខប្រភេទអណ្តែត អ្នកត្រូវបំប្លែងវាទៅជាប្រភេទអណ្តែតដោយប្រើ float() បើមិនដូច្នេះទេ កំហុសនឹងកើតឡើង។

d = Decimal('123.456').quantize(Decimal('0.01'), rounding=ROUND_HALF_UP)

print(d)
# 123.46

print(type(d))
# <class 'decimal.Decimal'>

# print(1.2 + d)
# TypeError: unsupported operand type(s) for +: 'float' and 'decimal.Decimal'

print(1.2 + float(d))
# 124.66

ការបង្គត់ចំនួនគត់ទៅចំនួនខ្ទង់ណាមួយ ហើយបង្គត់ទៅលេខគូ

ប្រសិនបើអ្នកចង់បង្គត់ទៅជាចំនួនគត់ ការបញ្ជាក់អ្វីមួយដូចជា ’10’ ជាអាគុយម៉ង់ទីមួយនឹងមិនផ្តល់លទ្ធផលដែលអ្នកចង់បាននោះទេ។

i = 99518

print(Decimal(i).quantize(Decimal('10'), rounding=ROUND_HALF_UP))
# 99518

នេះគឺដោយសារតែ quantize() ធ្វើការបង្គត់យោងទៅតាមនិទស្សន្តនៃវត្ថុទសភាគ ប៉ុន្តែនិទស្សន្តនៃ Decimal(’10’) គឺ 0 មិនមែន 1 ទេ។

អ្នក​អាច​បញ្ជាក់​និទស្សន្ត​ដោយ​ប្រើ E ជា​ខ្សែ​និទស្សន្ត (ឧ. ‘1E1’)។ និទស្សន្តនិទស្សន្តអាចត្រូវបានពិនិត្យនៅក្នុងវិធី as_tuple ។

print(Decimal('10').as_tuple())
# DecimalTuple(sign=0, digits=(1, 0), exponent=0)

print(Decimal('1E1').as_tuple())
# DecimalTuple(sign=0, digits=(1,), exponent=1)

ដូចដែលវាគឺ លទ្ធផលនឹងស្ថិតនៅក្នុងសញ្ញាអិចស្ប៉ូណង់ស្យែលដោយប្រើ E. ប្រសិនបើអ្នកចង់ប្រើសញ្ញាណធម្មតា ឬប្រសិនបើអ្នកចង់ដំណើរការជាមួយចំនួនគត់ប្រភេទ int បន្ទាប់ពីបង្គត់ សូមប្រើ int() ដើម្បីបំប្លែងលទ្ធផល។

print(Decimal(i).quantize(Decimal('1E1'), rounding=ROUND_HALF_UP))
# 9.952E+4

print(int(Decimal(i).quantize(Decimal('1E1'), rounding=ROUND_HALF_UP)))
# 99520

print(int(Decimal(i).quantize(Decimal('1E2'), rounding=ROUND_HALF_UP)))
# 99500

print(int(Decimal(i).quantize(Decimal('1E3'), rounding=ROUND_HALF_UP)))
# 100000

ប្រសិនបើការបង្គត់អាគុយម៉ង់ត្រូវបានកំណត់ជា ROUND_HALF_UP ការបង្គត់ទូទៅនឹងកើតឡើង ឧ. 5 នឹងបង្គត់ទៅ 10។

print('4 =>', int(Decimal(4).quantize(Decimal('1E1'), rounding=ROUND_HALF_UP)))
print('5 =>', int(Decimal(5).quantize(Decimal('1E1'), rounding=ROUND_HALF_UP)))
print('6 =>', int(Decimal(6).quantize(Decimal('1E1'), rounding=ROUND_HALF_UP)))
# 4 => 0
# 5 => 10
# 6 => 10

ជា​ការ​ពិត​ណាស់ មិន​មាន​បញ្ហា​ទេ​ប្រសិន​បើ​អ្នក​បញ្ជាក់​វា​ជា​ខ្សែ​អក្សរ។

កំណត់មុខងារថ្មី។

វិធីសាស្រ្តនៃការប្រើប្រាស់ម៉ូឌុលទសភាគគឺត្រឹមត្រូវ និងសុវត្ថិភាព ប៉ុន្តែប្រសិនបើអ្នកមិនងាយស្រួលជាមួយការបំប្លែងប្រភេទ អ្នកអាចកំណត់មុខងារថ្មីដើម្បីសម្រេចបានការបង្គត់ទូទៅ។

មានវិធីជាច្រើនដែលអាចធ្វើដូចនេះបាន ឧទាហរណ៍ មុខងារខាងក្រោម។

def my_round(val, digit=0):
    p = 10 ** digit
    return (val * p * 2 + 1) // 2 / p

ប្រសិនបើអ្នកមិនចាំបាច់បញ្ជាក់ចំនួនខ្ទង់ ហើយតែងតែបង្គត់ទៅខ្ទង់ទសភាគទីមួយ អ្នកអាចប្រើទម្រង់សាមញ្ញជាង។

my_round_int = lambda x: int((x * 2 + 1) // 2)

ប្រសិនបើអ្នកត្រូវការឱ្យច្បាស់លាស់ វាមានសុវត្ថិភាពជាងក្នុងការប្រើទសភាគ។

ខាងក្រោម​នេះ​គឺ​សម្រាប់​តែ​ជា​ឯកសារ​យោង។

បង្គត់ទសភាគទៅចំនួនខ្ទង់ណាមួយ។

print(int(my_round(f)))
# 123

print(my_round_int(f))
# 123

print(my_round(f, 1))
# 123.5

print(my_round(f, 2))
# 123.46

មិនដូចជុំទេ 0.5 ក្លាយជា 1 ដូចការបង្គត់ទូទៅ។

print(int(my_round(0.4)))
print(int(my_round(0.5)))
print(int(my_round(0.6)))
# 0
# 1
# 1

ចំនួនគត់បង្គត់ទៅចំនួនខ្ទង់ណាមួយ។

i = 99518

print(int(my_round(i, -1)))
# 99520

print(int(my_round(i, -2)))
# 99500

print(int(my_round(i, -3)))
# 100000

មិនដូចជុំទេ 5 ក្លាយជា 10 តាមការបង្គត់ធម្មតា។

print(int(my_round(4, -1)))
print(int(my_round(5, -1)))
print(int(my_round(6, -1)))
# 0
# 10
# 10

ចំណាំ៖ សម្រាប់តម្លៃអវិជ្ជមាន

នៅក្នុងអនុគមន៍ឧទាហរណ៍ខាងលើ -0.5 ត្រូវបានបង្គត់ទៅ 0។

print(int(my_round(-0.4)))
print(int(my_round(-0.5)))
print(int(my_round(-0.6)))
# 0
# 0
# -1

មានវិធីជាច្រើននៃការគិតអំពីការបង្គត់សម្រាប់តម្លៃអវិជ្ជមាន ប៉ុន្តែប្រសិនបើអ្នកចង់ធ្វើឱ្យ -0.5 ទៅជា -1 អ្នកអាចកែប្រែវាដូចខាងក្រោមឧទាហរណ៍

import math

def my_round2(val, digit=0):
    p = 10 ** digit
    s = math.copysign(1, val)
    return (s * val * p * 2 + 1) // 2 / p * s

print(int(my_round2(-0.4)))
print(int(my_round2(-0.5)))
print(int(my_round2(-0.6)))
# 0
# -1
# -1