“சுற்று” மற்றும் “Decimal.quantize உடன் பைத்தானில் உள்ள தசமங்கள் மற்றும் முழு எண்கள்

பைத்தானில் எண்களை எப்படி வட்டமிடுவது அல்லது இரட்டை எண்ணாக வட்டமிடுவது என்பதை பின்வரும் விளக்குகிறது. எண்கள் மிதக்கும் புள்ளி மிதவை அல்லது முழு எண்ணாக இருக்கும் என்று கருதப்படுகிறது.

• உள்ளமைக்கப்பட்ட செயல்பாடு (எ.கா. நிரலாக்க மொழியில்):round()
  • எந்த இலக்க எண்களுக்கும் சுற்று தசமங்கள்.
  • வட்ட முழு எண்கள் எத்தனை இலக்கங்கள்.
  • round() சுற்றுகள் இரட்டை எண்ணுக்கு, பொதுவான ரவுண்டிங்கிற்கு அல்ல
• நிலையான நூலகம்decimalquantize()
  • Decimalஒரு பொருளை உருவாக்குதல்
  • தசம எண்களை எத்தனை இலக்கங்களுக்குச் சுற்றியலும் மற்றும் இரட்டை எண்களுக்குச் சுற்றிலும்
  • முழு எண்களை எத்தனை இலக்கங்களுக்குச் சுற்றிலும் மற்றும் இரட்டை எண்களுக்கு வட்டமிடுதல்
• ஒரு புதிய செயல்பாட்டை வரையறுக்கவும்
  • தசமங்களை எந்த இலக்க எண்களுக்கும் முழுமைப்படுத்தவும்.
  • வட்ட முழு எண்கள் எத்தனை இலக்கங்கள்
  • குறிப்பு: எதிர்மறை மதிப்புகளுக்கு

மேலே குறிப்பிட்டுள்ளபடி, உள்ளமைக்கப்பட்ட செயல்பாடு சுற்று என்பது ஒரு பொதுவான ரவுண்டிங் அல்ல, மாறாக இரட்டை எண்ணுக்கு ஒரு ரவுண்டிங் ஆகும். விவரங்களுக்கு கீழே பார்க்கவும்.

உள்ளமைக்கப்பட்ட செயல்பாடு (எ.கா. நிரலாக்க மொழியில்):round()

சுற்று() ஒரு உள்ளமைக்கப்பட்ட செயல்பாடாக வழங்கப்படுகிறது. எந்த தொகுதிகளையும் இறக்குமதி செய்யாமல் இதைப் பயன்படுத்தலாம்.

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

முதல் வாதம் அசல் எண், மற்றும் இரண்டாவது வாதம் இலக்கங்களின் எண்ணிக்கை (எத்தனை இலக்கங்களைச் சுற்ற வேண்டும்).

எந்த இலக்க எண்களுக்கும் சுற்று தசமங்கள்.

ஃப்ளோட்டிங் பாயின்ட் ஃப்ளோட் வகையைச் செயலாக்குவதற்குப் பின்வருபவை ஒரு எடுத்துக்காட்டு.

இரண்டாவது வாதம் தவிர்க்கப்பட்டால், அது முழு எண்ணாக வட்டமிடப்படும். வகை ஒரு முழு எண்ணாக மாறும்.

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'>

வட்ட முழு எண்கள் எத்தனை இலக்கங்கள்.

பின்வருபவை முழு எண் வகைக்கான செயலாக்கத்திற்கான எடுத்துக்காட்டு.

இரண்டாவது வாதம் தவிர்க்கப்பட்டால் அல்லது 0 அல்லது நேர்மறை முழு எண் குறிப்பிடப்பட்டால், அசல் மதிப்பு அப்படியே வழங்கப்படும். எதிர்மறை முழு எண் குறிப்பிடப்பட்டால், அது தொடர்புடைய முழு எண் இலக்கத்துடன் வட்டமிடப்படும். இரண்டு சந்தர்ப்பங்களிலும், ஒரு முழு எண்ணாக வகை திரும்பும்.

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() சுற்றுகள் இரட்டை எண்ணுக்கு, பொதுவான ரவுண்டிங்கிற்கு அல்ல

பைதான் 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

நீங்கள் பொதுவான ரவுண்டிங் அல்லது தசமங்களின் துல்லியமான ரவுண்டிங்கைப் பெற விரும்பினால், நீங்கள் நிலையான லைப்ரரி தசம அளவைப் பயன்படுத்தலாம் (கீழே விவரிக்கப்பட்டுள்ளது) அல்லது ஒரு புதிய செயல்பாட்டை வரையறுக்கலாம்.

பைதான் 2 இல் உள்ள ரவுண்ட்() என்பது இரட்டை எண்ணாக அல்ல, ஆனால் ரவுண்டிங் ஆகும்.

நிலையான லைப்ரரி தசமத்தின் அளவு ()

நிலையான லைப்ரரியின் தசம தொகுதி சரியான தசம மிதக்கும் புள்ளி எண்களைக் கையாளப் பயன்படும்.

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

தசம தொகுதியின் அளவு() முறையைப் பயன்படுத்தி, ரவுண்டிங் பயன்முறையைக் குறிப்பிடுவதன் மூலம் எண்களை வட்டமிடலாம்.

• 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 ஆகக் கருதப்படவில்லை. மேலே விவரிக்கப்பட்ட உள்ளமைக்கப்பட்ட செயல்பாடு சுற்று() எடுத்துக்காட்டில் 0.05 உட்பட தசம மதிப்புகளுக்கு எதிர்பார்த்ததை விட வேறுபட்ட மதிப்பிற்கு வட்டமிடப்படுவதற்கு இதுவே காரணம்.

0.5 ஒரு பாதி (-1 சக்தி 2) என்பதால், அதை பைனரி குறியீட்டில் சரியாக வெளிப்படுத்தலாம்.

print(Decimal(0.5))
# 0.5

மிதவை வகைக்கு பதிலாக string வகை str ஐக் குறிப்பிட்டால், அது சரியான மதிப்பின் தசம வகையாகக் கருதப்படும்.

print(Decimal('0.05'))
# 0.05

தசம எண்களை எத்தனை இலக்கங்களுக்குச் சுற்றியலும் மற்றும் இரட்டை எண்களுக்குச் சுற்றிலும்

மதிப்பை முழுமைப்படுத்த, தசம வகைப் பொருளிலிருந்து quantize() ஐ அழைக்கவும்.

quantize() இன் முதல் வாதம், ‘0.1’ அல்லது ‘0.01’ போன்ற, நீங்கள் கண்டுபிடிக்க விரும்பும் இலக்கங்களின் எண்ணிக்கையின் அதே எண்ணிக்கையிலான இலக்கங்களைக் கொண்ட ஒரு சரமாகும்.

கூடுதலாக, ரவுண்டிங் என்ற வாதம் ரவுண்டிங் பயன்முறையைக் குறிப்பிடுகிறது; 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 ஐ ஃப்ளோட் வகையால் சரியாகக் கையாள முடியும் என்பதால், ஒரு முழு எண்ணுக்கு வட்டமிடும்போது ஃப்ளோட் வகையை டெசிமல்() இன் வாதமாகக் குறிப்பிடுவதில் எந்தப் பிரச்சனையும் இல்லை, ஆனால் தசம இடத்திற்குச் சுற்றும் போது 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’) அடுக்கு 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() ஐப் பயன்படுத்தவும்.

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