Home / Questions / 317012
Accepted
fedorqui
Asked: 2020-12-19 06:29:44 +0800 CST 2020-12-19 06:29:44 +0800 CST

Why in Python 3 does round() round 3.5 to 4 but 2.5 to 2?

  • 772

It turns out that:

>>> round(3.5)
4

While:

>>> round(2.5)
2

That is, when a number ends in .5 it sometimes rounds up (as it should) and sometimes rounds down.

Why is this happening? How can I force Python to round in a certain way?

This is a fork of the question How to round "correctly" in python? , because a topic arises that I consider relevant but that is not essential for the author. In order not to spoil his question, I create a new one .

python

1 Answers

  1. Best Answer

    Python 3 uses bankers rounding , that is, the banker's rounding, which consists of rounding .5to the nearest even number:

    >>> round(0.5)
0
>>> round(1.5)
2
>>> round(2.5)
2
>>> round(3.5)
4
>>> round(4.5)
4

    This is new in Python 3, as seen in What's new in Python 3.0 :

    The round()function rounding strategy and return type have changed. Exact halfway cases are now rounded to the nearest even result instead of away from zero. (For example, round(2.5)now returns 2rather than 3.) round(x[, n])now delegates to x.__round__([n])instead of always returning a float. It generally returns an integer when called with a single argument and a value of the same type as xwhen called with two arguments.

    Namely:

    The function's rounding strategy and return type round()have changed. Halfway cases are now rounded to the nearest even result, instead of up. (For example, round(2.5)now returns 2instead of 3.) round(x[, n])now delegates x.__round__([n])to instead of always returning a float. It generally returns an integer when called with a single argument and a value of the same type as xwhen called with two arguments.

    If you wonder why, counterintuitively, then it happens that with decimals this rule doesn't hold...

    >>> round(2.235, 2)
2.23
>>> round(2.245, 2)
2.25

    The builtin page round()then reads:

    Note The behavior of round()for floats can be surprising: for example, round(2.675, 2)it gives 2.67instead 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.

    Namely:

    Note that the behavior of round()for numbers with decimals can be surprising: for example, it round(2.675, 2)returns 2.67instead of the 2.68expected one. This is not a bug: it is the result of the fact that most decimal fractions cannot be represented exactly as a float. Read Floating Point Arithmetic: Issues and Limitations for more information.

    The idea that rounding .5 up to the next integer is not correct per se . As you can read in this answer to Python 3.x rounding behavior :

    The simple "always round 0.5 up" technique results in a slight bias toward the higher number. With large numbers of calculations, this can be significant. The Python 3.0 approach eliminates this issue.

    And then it indicates that there are five possible types of rounding described in IEEE 754.

    If you want to control exactly what rounding you apply, use the module decimalwith its options ROUND_HALF_EVEN, ROUND_HALF_UPor ROUND_HALF_DOWN( there are more ):

    >>> decimal.Decimal('2.5').quantize(
         decimal.Decimal('1'), rounding=decimal.ROUND_HALF_EVEN
)
Decimal('2')

>>> decimal.Decimal('3.5').quantize(
         decimal.Decimal('1'), rounding=decimal.ROUND_HALF_EVEN
)
Decimal('4')

>>> decimal.Decimal('3.5').quantize(
         decimal.Decimal('1'), rounding=decimal.ROUND_HALF_DOWN
)
Decimal('3')

>>> decimal.Decimal('3.5').quantize(
         decimal.Decimal('1'), rounding=decimal.ROUND_HALF_UP
)
Decimal('4')
    • 10