Python හි “වටය” සහ “Decimal.quantize සමග වටකුරු දශම සහ පූර්ණ සංඛ්‍යා

පහත දැක්වෙන්නේ ඉරට්ටේ සංඛ්‍යාවකට රවුම් කිරීම හෝ වට කිරීම මගින් පයිතන් හි සංඛ්‍යා වට කරන ආකාරයයි. සංඛ්‍යා පාවෙන ලක්ෂ්‍ය float හෝ integer int ආකාරයේ යැයි උපකල්පනය කෙරේ.

• බිල්ට්-ඉන් ශ්‍රිතය (උදා. ක්‍රමලේඛන භාෂාවෙන්):round()
  • ඕනෑම ඉලක්කම් ගණනකට දශම වට කරන්න.
  • ඕනෑම ඉලක්කම් ගණනකට වට පූර්ණ සංඛ්‍යා.
  • රවුම්() රවුම් ඉරට්ටේ සංඛ්‍යාවකට මිස පොදු වටයකට නොවේ
• සම්මත පුස්තකාලයdecimalquantize()
  • Decimalවස්තුවක් නිර්මාණය කිරීම
  • දශම ගණන ඕනෑම ඉලක්කම් ගණනකට වට කිරීම සහ ඉරට්ටේ සංඛ්‍යා වෙත වට කිරීම
  • ඕනෑම ඉලක්කම් ගණනකට පූර්ණ සංඛ්‍යා වට කිරීම සහ ඉරට්ටේ සංඛ්‍යා වෙත වට කිරීම
• නව කාර්යයක් නිර්වචනය කරන්න
  • ඕනෑම ඉලක්කම් ගණනකට දශම වට කරන්න.
  • ඕනෑම ඉලක්කම් ගණනකට වට පූර්ණ සංඛ්‍යා
  • සටහන: සෘණ අගයන් සඳහා

ඉහත සඳහන් කළ පරිදි, ගොඩනඟන ලද ශ්‍රිත වටය සාමාන්‍ය වට කිරීමක් නොව, ඉරට්ටේ සංඛ්‍යාවකට වට කිරීමක් බව සලකන්න. විස්තර සඳහා පහත බලන්න.

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

Round() සපයනු ලබන්නේ බිල්ට්-ඉන් ශ්‍රිතයක් ලෙසය. එය කිසිදු මොඩියුලයක් ආනයනය නොකර භාවිතා කළ හැක.

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

පළමු තර්කය මුල් අංකය වන අතර, දෙවන තර්කය ඉලක්කම් ගණන (රවුම් කිරීමට ඉලක්කම් කීයක්) වේ.

ඕනෑම ඉලක්කම් ගණනකට දශම වට කරන්න.

පහත දැක්වෙන්නේ floating-point float වර්ගය සඳහා සැකසීමේ උදාහරණයකි.

දෙවන තර්කය ඉවත් කර ඇත්නම්, එය පූර්ණ සංඛ්‍යාවකට වට කර ඇත. වර්ගය නිඛිල 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'>

ඕනෑම ඉලක්කම් ගණනකට වට පූර්ණ සංඛ්‍යා.

පහත දැක්වෙන්නේ integer 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

රවුම්() රවුම් ඉරට්ටේ සංඛ්‍යාවකට මිස පොදු වටයකට නොවේ

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

මෙයට හේතුව නිල ලේඛනවල දක්වා ඇති පරිදි දශමයන් පාවෙන ලක්ෂ්‍ය සංඛ්‍යා ලෙස හරියටම නිරූපණය කළ නොහැකි වීමයි.

පාවෙන ලක්ෂ්‍ය සංඛ්‍යා සඳහා වටයේ () හැසිරීම ඔබව පුදුමයට පත් කළ හැකිය:උදාහරණයක් ලෙස, වටය (2.675, 2) ඔබට අපේක්ෂිත පරිදි 2.68 වෙනුවට 2.67 ලබා දෙනු ඇත. මෙය දෝෂයක් නොවේ.:මෙය බොහෝ දශම සංඛ්‍යා පාවෙන ලක්ෂ්‍ය සංඛ්‍යා මගින් හරියටම නිරූපණය කළ නොහැකි වීමේ ප්‍රතිඵලයකි.
round() — Built-in Functions — Python 3.10.2 Documentation

ඔබට සාමාන්‍ය වට කිරීම හෝ දශම සංඛ්‍යා ඉරට්ටේ නිවැරදිව වට කිරීම ලබා ගැනීමට අවශ්‍ය නම්, ඔබට සම්මත පුස්තකාල දශම ප්‍රමාණකරණය (පහත විස්තර කර ඇත) භාවිතා කළ හැක හෝ නව ශ්‍රිතයක් අර්ථ දැක්විය හැක.

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

දශම වස්තුවක් නිර්මාණය කිරීම

දශම () දශම ආකාරයේ වස්තු නිර්මාණය කිරීමට භාවිතා කළ හැක.

ඔබ float වර්ගයක් තර්කයක් ලෙස සඳහන් කරන්නේ නම්, එම අගය සැබවින්ම සලකනු ලබන්නේ කුමක් දැයි ඔබට දැක ගත හැක.

print(Decimal(0.05))
# 0.05000000000000000277555756156289135105907917022705078125

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

උදාහරණයේ පෙන්වා ඇති පරිදි, 0.05 හරියටම 0.05 ලෙස සලකන්නේ නැත. උදාහරණයේ 0.05 ඇතුළුව දශම අගයන් සඳහා බලාපොරොත්තු වූවාට වඩා වෙනස් අගයකට ඉහත විස්තර කර ඇති බිල්ට්-ඉන් ශ්‍රිත වටය () වට කිරීමට හේතුව මෙයයි.

0.5 යනු අඩක් (-1 බලය 2) බැවින් එය හරියටම ද්විමය අංකනයකින් ප්‍රකාශ කළ හැක.

print(Decimal(0.5))
# 0.5

ඔබ float වර්ගය වෙනුවට string වර්ගය සඳහන් කරන්නේ නම්, එය නියම අගයේ දශම වර්ගය ලෙස සලකනු ලැබේ.

print(Decimal('0.05'))
# 0.05

ඕනෑම ඉලක්කම් ගණනකට දශම වට කිරීම සහ ඉරට්ටේ සංඛ්‍යා වෙත වට කිරීම

අගය වට කිරීමට දශම වර්ගයේ වස්තුවකින් quantize() අමතන්න.

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

බිල්ට්-ඉන් ශ්‍රිත වටය () මෙන් නොව 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 ලෙස සකසා තිබේ නම්, වටකුරු ශ්‍රිතය වටය() හි මෙන් ඉරට්ටේ සංඛ්‍යා වෙත සිදු කෙරේ.

ඉහත සඳහන් කළ පරිදි, පාවෙන-ලක්ෂ්‍ය පාවෙන වර්ගයක් දශම() හි තර්කය ලෙස සඳහන් කරන්නේ නම්, එය පාවෙන ආකාරයේ සත්‍ය අගයට සමාන අගයක් සහිත දශම වස්තුවක් ලෙස සලකනු ලැබේ, එබැවින් quantize() භාවිතා කිරීමේ ප්‍රතිඵලය ක්‍රමය බලාපොරොත්තු වන දේට වඩා වෙනස් වනු ඇත, හරියට බිල්ට්-ඉන් ශ්‍රිත වටය().

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 නිවැරදිව float වර්ගයට හසුරුවිය හැකි බැවින්, නිඛිලයකට වට කිරීමේදී float වර්ගය Decimal() හි තර්කය ලෙස සඳහන් කිරීමේ ගැටලුවක් නැත, නමුත් දශම ස්ථානයකට වට කරන විට string str වර්ගය සඳහන් කිරීම වඩා ආරක්ෂිත වේ.

උදාහරණයක් ලෙස, 2.675 ඇත්ත වශයෙන්ම 2.67499…. පාවෙන ආකාරයේ. එබැවින්, ඔබට දශම ස්ථාන දෙකකට වට කිරීමට අවශ්‍ය නම්, ඔබ දශම() වෙත තන්තුවක් සඳහන් කළ යුතුය, එසේ නොමැතිනම් ඔබ ආසන්නතම සම්පූර්ණ සංඛ්‍යාවට (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() දශම වස්තුවේ ඝාතකයාට අනුව වට කිරීම සිදු කරයි, නමුත් දශමයේ (’10’) ඝාතකය 1 නොව 0 වේ.

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