Python 3 rounding behavior in Python 2

Python 3 round in Python 2

The function can look like this:

def py3round(f):
    if abs(round(f)-f) == 0.5:
        return 2.0*round(f/2.0);
    return round(f)

# Python 3            apply round to ... -.1 -.75 -.5 -.25 0 .25 .5 .75 ...
>>> ' '.join(map(str, map(int, [round(i * 0.25) for i in range(-20, 20)])))
'-5 -5 -4 -4 -4 -4 -4 -3 -3 -3 -2 -2 -2 -2 -2 -1 -1 -1 0 0 0 0 0 1 1 1 2 2 2 2 2 3 3 3 4 4 4 4 4 5'
# Python 2            apply round to ... -.1 -.75 -.5 -.25 0 .25 .5 .75 ...
>>> ' '.join(map(str, map(int, [py3round(i * 0.25) for i in range(-20, 20)])))
'-5 -5 -4 -4 -4 -4 -4 -3 -3 -3 -2 -2 -2 -2 -2 -1 -1 -1 0 0 0 0 0 1 1 1 2 2 2 2 2 3 3 3 4 4 4 4 4 5'

Let me clarify what round does in bltinmodule.c

if hasattr(args[0], '__round__'):
    return args[0].__round__(*args[1:])
else: 
    raise TypeError("type %.100s doesn't define __round__ method")

So round actually does almost nothing. It depends on the objects passed to it. That leads to floatobject.c function static PyObject *double_round(double x, int ndigits)

z = round(y);
if (fabs(y-z) == 0.5)
    /* halfway between two integers; use round-half-even */
    z = 2.0*round(y/2.0);

I used the knowledge of these lines in my function above.

Python 2 round in Python 3

I think you need to write a new function.

def python2round(f):
    if round(f + 1) - round(f) != 1:
        return f + abs(f) / f * 0.5
    return round(f)

The if statement handles the case that i + 0.5 and i + 1.5 are rounded into different directions = to even numbers and halves. In this case the rounding is done away from zero.

# in Python 2          apply round to ... -.1 -.75 -.5 -.25 0 .25 .5 .75 ...
>>> ' '.join(map(str, map(int, [round(i * 0.25) for i in range(-20, 20)])))
'-5 -5 -5 -4 -4 -4 -4 -3 -3 -3 -3 -2 -2 -2 -2 -1 -1 -1 -1 0 0 0 1 1 1 1 2 2 2 2 3 3 3 3 4 4 4 4 5 5'
# in Python 3          apply round to ... -.1 -.75 -.5 -.25 0 .25 .5 .75 ...
>>> ' '.join(map(str, map(int, [python2round(i * 0.25) for i in range(-20, 20)])))
'-5 -5 -5 -4 -4 -4 -4 -3 -3 -3 -3 -2 -2 -2 -2 -1 -1 -1 -1 0 0 0 1 1 1 1 2 2 2 2 3 3 3 3 4 4 4 4 5 5'

Do you need a solution with the second argument to round, ndigits?

Unless you mind a numpy dependency, numpy.around may do the thing:

>>> from numpy import around
>>> around(0.5)
0
>>> around(-0.5)
-0
>>> around(1.5)
2.0

If you're super-paranoid about floating point rounding issues, you can look into the decimal library where you can configure the rounding mode (defaults to ROUND_HALF_EVEN).

>>> import decimal
>>> from decimal import Decimal
>>> Decimal(0.5).quantize(Decimal('1'))
Decimal('0')
>>> Decimal(1.5).quantize(Decimal('1'))
Decimal('2')

>>> decimal.getcontext().rounding = decimal.ROUND_HALF_UP
>>> Decimal(0.5).quantize(Decimal('1'))
Decimal('1')

Otherwise, I think it's more explicit and more maintainable if you just write your own function or use numpy, rather than wish that you could use a py3 function in py2.

This response has read the original question, and the answer is "Nope, I can't come up with something that uses the Py3 original code."

But for anyone who is wondering what the code would be that would replicate Py3 behavior in Py2 (including the int vs. float behavior), here's an adaptation of the User code above that includes ndigits and the int vs. float distinction for ndigits = None vs 0.

import sys

def py3round(number, ndigits=None):
    '''
    Simulates Python3 rounding behavior in Python 2

    >>> py3round(2.3)
    2
    >>> py3round(2.7)
    3
    >>> py3round(2.7, 0)
    3.0
    >>> py3round(1.5, 0)
    2.0
    >>> py3round(2.5, 0)
    2.0
    >>> py3round(-1.5)
    -2
    >>> py3round(-2.5)
    -2
    '''
    if sys.version_info[0] >= 3:
        if ndigits is not None:
            return round(number, ndigits)
        else:
            return round(number)        

    intIt = True if ndigits is None else False
    ndigits = ndigits if ndigits is not None else 0

    f = number
    if abs(round(f) - f) == 0.5:
        retAmount = 2.0 * round(f / 2.0, ndigits);
    else:
        retAmount = round(f, ndigits)

    if intIt:
        return int(retAmount)
    else:
        return retAmount

Use decimal.Decimal.to_integral_value

For example:

float(decimal.Decimal(1.5).to_integral_value(decimal.ROUND_HALF_EVEN))

The rounding options are documented here. The two options we are concerned with are:

ROUND_HALF_EVEN (to nearest with ties going to nearest even integer),
ROUND_HALF_UP (to nearest with ties going away from zero),

def round_to_even(x):
    if x < 0:
        return -round_to_even(-x)
    ipart, fpart = divmod(x, 1)
    ipart = int(ipart)
    fpartx2 = fpart * 2
    if fpartx2 > 1:
        return ipart + 1
    elif fpartx2 == 1:
        return ipart + (ipart & 1)
    else:
        return ipart

You can use the following pseudocode:

if number is_factor_of_0.5:
      res =  round_down(n,d) --> Returns math.foot() of a number
else:
      res =  round()     # Python's own round
        
return float(res)

I had a similar problem but mine was to use python2 round functionality in python3 , following code worked for me

import math


def round_up(n, decimals = 0):
    multiplier = 10 ** decimals
    return math.ceil(n * multiplier) / multiplier

def python2round(n, d=0):
    if n % 0.5 ==0:
        res = round_up(n,d)  
    else:
        res = round(n,d)
    return float(res)

It's easy to use math.ceil function:

Python 2

import math

math.ceil(100.5)
> 101.0

Python 3

import math

mail.ceil(100.5)
> 101