# How to round to 2 decimals with Python?

## Question:

I am getting a lot of decimals in the output of this code (Fahrenheit to Celsius converter).

My code currently looks like this:

```
def main():
printC(formeln(typeHere()))
def typeHere():
global Fahrenheit
try:
Fahrenheit = int(raw_input("Hi! Enter Fahrenheit value, and get it in Celsius!n"))
except ValueError:
print "nYour insertion was not a digit!"
print "We've put your Fahrenheit value to 50!"
Fahrenheit = 50
return Fahrenheit
def formeln(c):
Celsius = (Fahrenheit - 32.00) * 5.00/9.00
return Celsius
def printC(answer):
answer = str(answer)
print "nYour Celsius value is " + answer + " C.n"
main()
```

So my question is, how do I make the program round every answer to the 2nd decimal place?

## Answers:

You can use the string formatting operator of python “%”.

“%.2f” means 2 digits after the decimal point.

```
def typeHere():
try:
Fahrenheit = int(raw_input("Hi! Enter Fahrenheit value, and get it in Celsius!n"))
except ValueError:
print "nYour insertion was not a digit!"
print "We've put your Fahrenheit value to 50!"
Fahrenheit = 50
return Fahrenheit
def formeln(Fahrenheit):
Celsius = (Fahrenheit - 32.0) * 5.0/9.0
return Celsius
def printC(answer):
print "nYour Celsius value is %.2f C.n" % answer
def main():
printC(formeln(typeHere()))
main()
```

http://docs.python.org/2/library/stdtypes.html#string-formatting

Just use the formatting with %.2f which gives you rounding down to 2 decimals.

```
def printC(answer):
print "nYour Celsius value is %.2f C.n" % answer
```

You can use the `round`

function, which takes as its first argument the number and the second argument is the precision after the decimal point.

In your case, it would be:

```
answer = str(round(answer, 2))
```

Using `str.format()`

‘s syntax to *display* `answer`

with two decimal places (without altering the underlying value of `answer`

):

```
def printC(answer):
print("nYour Celsius value is {:0.2f}ÂșC.n".format(answer))
```

Where:

`:`

introduces the format spec`0`

enables sign-aware zero-padding for numeric types`.2`

sets the precision to`2`

`f`

displays the number as a fixed-point number

As you want your answer in decimal number so you dont need to typecast your **answer** variable to str in printC() function.

and then use printf-style String Formatting

You can use the round function.

```
round(80.23456, 3)
```

will give you an answer of 80.234

In your case, use

```
answer = str(round(answer, 2))
```

You want to round your answer.

`round(value,significantDigit)`

is the ordinary solution to do this, however this ** sometimes** does not operate as one would expect from a math perspective when the digit immediately inferior (to the left of) the digit you’re rounding to has a

`5`

.Here’s some examples of this unpredictable behavior:

```
>>> 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
```

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*6),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 really small value to the string to force it to round up properly on the unpredictable instances where it doesn’t ordinarily with the `round`

function when you expect it to. A convenient value to add is `1e-X`

where `X`

is the length of the number string you’re trying to use `round`

on plus `1`

.

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.

So the finished code will be something like:

```
def main():
printC(formeln(typeHere()))
def roundTraditional(val,digits):
return round(val+10**(-len(str(val))-1))
def typeHere():
global Fahrenheit
try:
Fahrenheit = int(raw_input("Hi! Enter Fahrenheit value, and get it in Celsius!n"))
except ValueError:
print "nYour insertion was not a digit!"
print "We've put your Fahrenheit value to 50!"
Fahrenheit = 50
return Fahrenheit
def formeln(c):
Celsius = (Fahrenheit - 32.00) * 5.00/9.00
return Celsius
def printC(answer):
answer = str(roundTraditional(answer,2))
print "nYour Celsius value is " + answer + " C.n"
main()
```

…should give you the results you expect.

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 here.

```
float(str(round(answer, 2)))
float(str(round(0.0556781255, 2)))
```

Most answers suggested `round`

or `format`

. `round`

sometimes rounds up, and in my case I needed the *value* of my variable to be rounded down and not just displayed as such.

```
round(2.357, 2) # -> 2.36
```

I found the answer here: How do I round a floating point number up to a certain decimal place?

```
import math
v = 2.357
print(math.ceil(v*100)/100) # -> 2.36
print(math.floor(v*100)/100) # -> 2.35
```

or:

```
from math import floor, ceil
def roundDown(n, d=8):
d = int('1' + ('0' * d))
return floor(n * d) / d
def roundUp(n, d=8):
d = int('1' + ('0' * d))
return ceil(n * d) / d
```

Here is an example that I used:

```
def volume(self):
return round(pi * self.radius ** 2 * self.height, 2)
def surface_area(self):
return round((2 * pi * self.radius * self.height) + (2 * pi * self.radius ** 2), 2)
```

Not sure why, but ‘{:0.2f}’.format(0.5357706) gives me ‘0.54’.

The only solution that works for me (python 3.6) is the following:

```
def ceil_floor(x):
import math
return math.ceil(x) if x < 0 else math.floor(x)
def round_n_digits(x, n):
import math
return ceil_floor(x * math.pow(10, n)) / math.pow(10, n)
round_n_digits(-0.5357706, 2) -> -0.53
round_n_digits(0.5357706, 2) -> 0.53
```

```
round(12.3956 - 0.005, 2) # minus 0.005, then round.
```

The answer is from: https://stackoverflow.com/a/29651462/8025086

You can use **round** operator for up to 2 decimal

```
num = round(343.5544, 2)
print(num) // output is 343.55
```

If you need **avoid floating point problem** on rounding numbers for accounting, you can use numpy round.

You need install numpy :

```
pip install numpy
```

and the code :

```
import numpy as np
print(round(2.675, 2))
print(float(np.round(2.675, 2)))
```

prints

```
2.67
2.68
```

You should use that if you manage money with legal rounding.

If you need not only round result but elso do math operations with round result, then you can use `decimal.Decimal`

https://docs.python.org/2/library/decimal.html

```
from decimal import Decimal, ROUND_DOWN
Decimal('7.325').quantize(Decimal('.01'), rounding=ROUND_DOWN)
Decimal('7.32')
```

If you just want to print the rounded result out, you can use the f-strings introduced since Python 3.6. The syntax is the same as `str.format()`

‘s format string syntax, except you put a `f`

in front of the literal string, and you put the variables directly in the string, within the curly braces.

`.2f`

indicates rounding to two decimal places:

```
number = 3.1415926
print(f"The number rounded to two decimal places is {number:.2f}")
```

Output:

```
The number rounded to two decimal places is 3.14
```

To avoid surprising value from round() this is my approche:

```
Round = lambda x, n: eval('"%.'+str(int(n))+'f" % '+repr(int(x)+round(float('.'+str(float(x)).split('.')[1]),n)))
print(Round(2, 2)) # 2.00
print(Round(2.675, 2)) # 2.68
```

```
from decimal import Decimal, ROUND_HALF_UP
# Here are all your options for rounding:
# This one offers the most out of the box control
# ROUND_05UP ROUND_DOWN ROUND_HALF_DOWN ROUND_HALF_UP
# ROUND_CEILING ROUND_FLOOR ROUND_HALF_EVEN ROUND_UP
our_value = Decimal(16.0/7)
output = Decimal(our_value.quantize(Decimal('.01'),
rounding=ROUND_HALF_UP))
print output
```

Truncating to 2 digitis:

```
somefloat = 2.23134133
truncated = int( somefloat * 100 ) / 100 # 2.23
```

The easiest solution I found so far, dunno why people ain’t using it.

```
# Make sure the number is a float
a = 2324.55555
# Round it according to your needs
# dPoints is the decimals after the point
dPoints = 2
# this will round the float to 2 digits
a = a.__round__(dPoints)
if len(str(a).split(".")[1]) < dPoints:
# But it will only keep one 0 if there is nothing,
# So we add the extra 0s we need
print(str(a)+("0"*(dPoints-1)))
else:
print(a)
```