Round number to nearest integer

Use round(x, y). It will round up your number up to your desired decimal place.

For example:

>>> round(32.268907563, 3)
32.269

round(value,significantDigit) is the ordinary solution, however this does not operate as one would expect from a math perspective when round values ending in 5. If the 5 is in the digit just after the one you’re rounded to, these values are only sometimes rounded up as expected (i.e. 8.005 rounding to two decimal digits gives 8.01). For certain values due to the quirks of floating point math, they are rounded down instead!

i.e.

>>> round(1.0005,3)
1.0
>>> round(2.0005,3)
2.001
>>> round(3.0005,3)
3.001
>>> round(4.0005,3)
4.0
>>> round(1.005,2)
1.0
>>> round(5.005,2)
5.0
>>> round(6.005,2)
6.0
>>> round(7.005,2)
7.0
>>> round(3.005,2)
3.0
>>> round(8.005,2)
8.01

Weird.

Assuming your intent is to do the traditional rounding for statistics in the sciences, this is a handy wrapper to get the round function working as expected needing to import extra stuff like Decimal.

>>> round(0.075,2)

0.07

>>> round(0.075+10**(-2*5),2)

0.08

Aha! So based on this we can make a function…

def roundTraditional(val,digits):
   return round(val+10**(-len(str(val))-1), digits)

Basically this adds a value guaranteed to be smaller than the least given digit of the string you’re trying to use round on. By adding that small quantity it preserve’s round‘s behavior in most cases, while now ensuring if the digit inferior to the one being rounded to is 5 it rounds up, and if it is 4 it rounds down.

The approach of using 10**(-len(val)-1) was deliberate, as it the largest small number you can add to force the shift, while also ensuring that the value you add never changes the rounding even if the decimal . is missing. I could use just 10**(-len(val)) with a condiditional if (val>1) to subtract 1 more… but it’s simpler to just always subtract the 1 as that won’t change much the applicable range of decimal numbers this workaround can properly handle. This approach will fail if your values reaches the limits of the type, this will fail, but for nearly the entire range of valid decimal values it should work.

You can also use the decimal library to accomplish this, but the wrapper I propose is simpler and may be preferred in some cases.

Edit: Thanks Blckknght for pointing out that the 5 fringe case occurs only for certain values. Also an earlier version of this answer wasn’t explicit enough that the odd rounding behavior occurs only when the digit immediately inferior to the digit you’re rounding to has a 5.

Isn’t just Python doing round half to even, as prescribed by IEEE 754?

Be careful redefining, or using “non-standard” rounding…

(See also https://stackoverflow.com/a/33019948/109839)

For positives, try

int(x + 0.5)

To make it work for negatives too, try

int(x + (0.5 if x > 0 else -0.5))

int() works like a floor function and hence you can exploit this property. This is definitely the fastest way.

If you need (for example) a two digit approximation for A, then
int(A*100+0.5)/100.0 will do what you are looking for.

If you need three digit approximation multiply and divide by 1000 and so on.

You can also use numpy assuming if you are using python3.x here is an example

import numpy as np
x = 2.3
print(np.rint(x))
>>> 2.0

For this purpose I would suggest just do the following thing –

int(round(x))

This will give you nearest integer.

Hope this helps!!

Your solution is calling round without specifying the second argument (number of decimal places)

>>> round(0.44)
0
>>> round(0.64)
1

which is a much better result than

>>> int(round(0.44, 2))
0
>>> int(round(0.64, 2))
0

From the Python documentation at https://docs.python.org/3/library/functions.html#round

round(number[, ndigits])

Return number rounded to ndigits precision after the decimal point. If
ndigits is omitted or is None, it returns the nearest integer to its
input.

Note

The behavior of round() for floats can be surprising: for example,
round(2.675, 2) gives 2.67 instead of the expected 2.68. This is not a
bug: it’s a result of the fact that most decimal fractions can’t be
represented exactly as a float. See Floating Point Arithmetic: Issues
and Limitations for more information.

I use and may advise the following solution (python3.6):

y = int(x + (x % (1 if x >= 0 else -1)))

It works fine for half-numbers (positives and negatives) and works even faster than int(round(x)):

round_methods = [lambda x: int(round(x)), 
                 lambda x: int(x + (x % (1 if x >= 0 else -1))),
                 lambda x: np.rint(x).astype(int),
                 lambda x: int(proper_round(x))]

for rm in round_methods:
    %timeit rm(112.5)
Out:
201 ns ± 3.96 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)
159 ns ± 0.646 ns per loop (mean ± std. dev. of 7 runs, 10000000 loops each)
925 ns ± 7.66 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)
1.18 µs ± 8.66 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)

for rm in round_methods:
    print(rm(112.4), rm(112.5), rm(112.6))
    print(rm(-12.4), rm(-12.5), rm(-12.6))
    print('=' * 11)

Out:
112 112 113
-12 -12 -13
===========
112 113 113
-12 -13 -13
===========
112 112 113
-12 -12 -13
===========
112 113 113
-12 -13 -13
===========

Some thing like this should also work

import numpy as np    

def proper_round(a):
    '''
    given any real number 'a' returns an integer closest to 'a'
    '''
    a_ceil = np.ceil(a)
    a_floor = np.floor(a)
    if np.abs(a_ceil - a) < np.abs(a_floor - a):
        return int(a_ceil)
    else:
        return int(a_floor)

This one is tricky, to be honest. There are many simple ways to do this nevertheless. Using math.ceil(), round(), and math.floor(), you can get a integer by using for example:

n = int(round(n))

If before we used this function n = 5.23, we would get returned 5. If you wanted to round to different place values, you could use this function:

def Round(n,k):
  point = '%0.' + str(k) + 'f'
  if k == 0:
    return int(point % n)
  else:
    return float(point % n)

If we used n (5.23) again, round it to the nearest tenth, and print the answer to the console, our code would be:

Round(5.23,1)

Which would return 5.2. Finally, if you wanted to round something to the nearest, let’s say, 1.2, you can use the code:

def Round(n,k):
    return k * round(n/k)

If we wanted n to be rounded to 1.2, our code would be:

print(Round(n,1.2))

and our result:

4.8

Thank you! If you have any questions, please add a comment. 🙂 (Happy Holidays!)

Click the link for the explanation. The article linked in my post talks all about the code and how to use it.

https://kodify.net/python/math/truncate-decimals/

import math

def truncate(number, decimals=0):
    """
    Returns a value truncated to a specific number of decimal places.
    """
    if not isinstance(decimals, int):
        raise TypeError("decimal places must be an integer.")
    elif decimals < 0:
        raise ValueError("decimal places has to be 0 or more.")
    elif decimals == 0:
        return math.trunc(number)

    factor = 10.0 ** decimals
    return math.trunc(number * factor) / factor

The rationale for rounding a x500… to the even value in the ‘x’ digit is the correct method and has nothing to do with the binary represntation of the value. It is the ‘proper’ algorithm to employ. Advanced science classes and statistics classes teach this. But why is this the case?

Minimizing accumulated errors!

When you round a value, you introduce an error value on that term. If you are summing together masses of values and you always round an x500… value up [i.e. to x+1], then you will have an inherent bias to your error accumulation.

On a set of N numbers, where M of those numbers are of the form x500…, a round up methodology will introduce a +ve error term of magnitude M * 0.5 of the digit you are rounding to.

However, if you always round to even, then you have an expectation that half of those M error terms are +ve and half are -ve. Therefore, you have the expecatation that they will cancel leaving you with a net zero error from those M terms. Isn’t an error of 0 a whole lot better than an error of M * 0.5?

But, that net 0 error is only an expectation. When you consider flipping a "fair" coin (an analogous problem) such that "heads" = +1 and "tails" = -1, M times, and add up the sum of all flips, there is a statistical expectation of a 0 result, but the magnitude of the "wander" from 0 (could be +ve or -ve) is generally bound by sqrt(M) — or is it log(M)? haven’t cracked open a statistics book in quite some time. The actual answer (sqrt or log) is irrelevant to this question as both sqrt(M) and log(M) are smaller than M for all M>1].

So, as it pertains to our summation of numbers scenario, with M values of the form x500…, since M is finite, we have an expectation that the error term from those M values will be zero, but we also have an even stronger expectation that the magnitude of the error term ought to be bound by sqrt(M) * 0.5 of the digit you are rounding to.

0 is fantastic, but an expected sqrt(M) * 0.5 is still a whole lot better than guaranteed M * 0.5.

Yes, you can have a pathological case where you end up with M * 0.5, but such a scenario should be an outlier rather than the norm — and that rare outlier is no worse than the "always round up" approach.

In the correct answer mentioned in this does not work if I use 79.5. It gives an answer of 710, not 80.

def proper_round(num, dec=0):
num= int(num*pow(10,dec+1))
lastDigit = (str(num))[-1]
num = int(num/10)
if lastDigit >='5':
    num+=1
return float(num/pow(10,dec))

The above mentioned code gives better result

for rounding numbers to the nearest int number, use numpy:

p=np.array([     430.15,      57.868,      70.697,      198.13])
p=np.round(p)

and the p :

array([        430,          58,          71,         198])