“రౌండ్” మరియు “Decimal.quantize తో పైథాన్‌లో దశాంశాలు మరియు పూర్ణాంకాలు పూర్తి చేయడం

పైథాన్‌లో సంఖ్యలను రౌండ్ చేయడం లేదా సరి సంఖ్యకు చుట్టడం ద్వారా ఎలా రౌండ్ చేయాలో క్రింది వివరిస్తుంది. సంఖ్యలు ఫ్లోటింగ్ పాయింట్ ఫ్లోట్ లేదా పూర్ణాంకం పూర్ణాంక రకంగా భావించబడతాయి.

• అంతర్నిర్మిత ఫంక్షన్ (ఉదా. ప్రోగ్రామింగ్ భాషలో):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

రౌండ్() రౌండ్లు సరి సంఖ్యకు, సాధారణ రౌండింగ్‌కి కాదు

పైథాన్ 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

క్వాంటైజ్() పద్ధతి యొక్క ఆర్గ్యుమెంట్ రౌండింగ్ కోసం సెట్ విలువలు వరుసగా క్రింది అర్థాలను కలిగి ఉంటాయి.

• 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

మీరు ఫ్లోట్ రకానికి బదులుగా స్ట్రింగ్ రకాన్ని str నిర్దేశిస్తే, అది ఖచ్చితమైన విలువ యొక్క దశాంశ రకంగా పరిగణించబడుతుంది.

print(Decimal('0.05'))
# 0.05

దశాంశాలను సంఖ్యల సంఖ్యకు పూరించండి మరియు సరి సంఖ్యలకు పూరించండి

విలువను పూర్తి చేయడానికి దశాంశ రకం వస్తువు నుండి క్వాంటైజ్()ని కాల్ చేయండి.

క్వాంటైజ్() యొక్క మొదటి ఆర్గ్యుమెంట్ అనేది మీరు కనుగొనాలనుకుంటున్న ‘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కి సెట్ చేయబడితే, అంతర్నిర్మిత ఫంక్షన్ రౌండ్()లో వలె సరి సంఖ్యలకు రౌండ్ చేయడం జరుగుతుంది.

పైన పేర్కొన్న విధంగా, ఫ్లోటింగ్-పాయింట్ ఫ్లోట్ రకాన్ని డెసిమల్() యొక్క ఆర్గ్యుమెంట్‌గా పేర్కొన్నట్లయితే, అది ఫ్లోట్ రకం యొక్క వాస్తవ విలువకు సమానమైన విలువతో డెసిమల్ ఆబ్జెక్ట్‌గా పరిగణించబడుతుంది, కాబట్టి క్వాంటైజ్()ని ఉపయోగించడం వల్ల ఫలితం అంతర్నిర్మిత ఫంక్షన్ రౌండ్() లాగానే పద్ధతి ఊహించిన దానికంటే భిన్నంగా ఉంటుంది.

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

దశాంశ() యొక్క ఆర్గ్యుమెంట్ 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 సరిగ్గా నిర్వహించబడుతుంది కాబట్టి, పూర్ణాంకానికి చుట్టుముట్టేటప్పుడు ఫ్లోట్ రకాన్ని డెసిమల్() యొక్క ఆర్గ్యుమెంట్‌గా పేర్కొనడంలో సమస్య లేదు, కానీ దశాంశ స్థానానికి రౌండ్ చేస్తున్నప్పుడు స్ట్రింగ్ 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

క్వాంటైజ్() పద్ధతి దశాంశ రకం సంఖ్యను అందిస్తుంది, కాబట్టి మీరు ఫ్లోట్ టైప్ నంబర్‌పై ఆపరేట్ చేయాలనుకుంటే, మీరు దానిని ఫ్లోట్ () ఉపయోగించి ఫ్లోట్ రకానికి మార్చాలి, లేకుంటే లోపం సంభవిస్తుంది.

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

ఎందుకంటే క్వాంటైజ్() అనేది డెసిమల్ ఆబ్జెక్ట్ యొక్క ఘాతాంకం ప్రకారం గుండ్రంగా ఉంటుంది, అయితే డెసిమల్ (’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