# Rounding to two decimal places in Python 2.7?

Each Answer to this Q is separated by one/two green lines.

Using Python 2.7 how do I round my numbers to two decimal places rather than the 10 or so it gives?

``````print "financial return of outcome 1 =","\$"+str(out1)
``````

Use the built-in function `round()`:

``````>>> round(1.2345,2)
1.23
>>> round(1.5145,2)
1.51
>>> round(1.679,2)
1.68
``````

Or built-in function `format()`:

``````>>> format(1.2345, '.2f')
'1.23'
>>> format(1.679, '.2f')
'1.68'
``````

Or new style string formatting:

``````>>> "{:.2f}".format(1.2345)
'1.23
>>> "{:.2f}".format(1.679)
'1.68'
``````

Or old style string formatting:

``````>>> "%.2f" % (1.679)
'1.68'
``````

help on `round`:

``````>>> print round.__doc__
round(number[, ndigits]) -> floating point number

Round a number to a given precision in decimal digits (default 0 digits).
This always returns a floating point number.  Precision may be negative.
``````

Since you’re talking about financial figures, you DO NOT WANT to use floating-point arithmetic. You’re better off using Decimal.

``````>>> from decimal import Decimal
>>> Decimal("33.505")
Decimal('33.505')
``````

Text output formatting with new-style `format()` (defaults to half-even rounding):

``````>>> print("financial return of outcome 1 = {:.2f}".format(Decimal("33.505")))
financial return of outcome 1 = 33.50
>>> print("financial return of outcome 1 = {:.2f}".format(Decimal("33.515")))
financial return of outcome 1 = 33.52
``````

See the differences in rounding due to floating-point imprecision:

``````>>> round(33.505, 2)
33.51
>>> round(Decimal("33.505"), 2)  # This converts back to float (wrong)
33.51
>>> Decimal(33.505)  # Don't init Decimal from floating-point
Decimal('33.50500000000000255795384873636066913604736328125')
``````

Proper way to round financial values:

``````>>> Decimal("33.505").quantize(Decimal("0.01"))  # Half-even rounding by default
Decimal('33.50')
``````

It is also common to have other types of rounding in different transactions:

``````>>> import decimal
>>> Decimal("33.505").quantize(Decimal("0.01"), decimal.ROUND_HALF_DOWN)
Decimal('33.50')
>>> Decimal("33.505").quantize(Decimal("0.01"), decimal.ROUND_HALF_UP)
Decimal('33.51')
``````

Remember that if you’re simulating return outcome, you possibly will have to round at each interest period, since you can’t pay/receive cent fractions, nor receive interest over cent fractions. For simulations it’s pretty common to just use floating-point due to inherent uncertainties, but if doing so, always remember that the error is there. As such, even fixed-interest investments might differ a bit in returns because of this.

You can use `str.format()`, too:

``````>>> print "financial return of outcome 1 = {:.2f}".format(1.23456)
financial return of outcome 1 = 1.23
``````

When working with pennies/integers. You will run into a problem with 115 (as in \$1.15) and other numbers.

I had a function that would convert an Integer to a Float.

``````...
return float(115 * 0.01)
``````

That worked most of the time but sometimes it would return something like `1.1500000000000001`.

So I changed my function to return like this…

``````...
return float(format(115 * 0.01, '.2f'))
``````

and that will return `1.15`. Not `'1.15'` or `1.1500000000000001` (returns a float, not a string)

I’m mostly posting this so I can remember what I did in this scenario since this is the first result in google.

The best, I think, is to use the format() function:

``````>>> print("financial return of outcome 1 = \$ " + format(str(out1), '.2f'))
// Should print: financial return of outcome 1 = \$ 752.60
``````

But I have to say: don’t use round or format when working with financial values.

When we use the round() function, it will not give correct values.

you can check it using,
round (2.735) and round(2.725)

``````import math
num = input('Enter a number')
print(math.ceil(num*100)/100)
``````

``````print "financial return of outcome 1 = \$%.2f" % (out1)
``````

A rather simple workaround is to convert the float into string first, the select the substring of the first four numbers, finally convert the substring back to float.
For example:

``````>>> out1 = 1.2345
>>> out1 = float(str(out1)[0:4])
>>> out1
``````

May not be super efficient but simple and works 🙂

Rounding up to the next 0.05, I would do this way:

``````def roundup(x):
return round(int(math.ceil(x / 0.05)) * 0.05,2)
``````

The answers/resolutions are collected from stackoverflow, are licensed under cc by-sa 2.5 , cc by-sa 3.0 and cc by-sa 4.0 .