# How can I format a decimal to always show 2 decimal places?

PythonString Formatting## Python Problem Overview

I want to display:

`49`

as `49.00`

and:

`54.9`

as `54.90`

Regardless of the length of the decimal or whether there are are any decimal places, I would like to display a `Decimal`

with 2 decimal places, and I'd like to do it in an efficient way. The purpose is to display money values.

eg, `4898489.00`

## Python Solutions

## Solution 1 - Python

You should use the [new format specifications][1] to define how your value should be represented:

```
>>> from math import pi # pi ~ 3.141592653589793
>>> '{0:.2f}'.format(pi)
'3.14'
```

The documentation can be a bit obtuse at times, so I recommend the following, easier readable references:

- the [Python String Format Cookbook][2]: shows examples of the new-style [
`.format()`

][3] string formatting - [pyformat.info][4]: compares the old-style
`%`

string formatting with the new-style [`.format()`

][3] string formatting

Python 3.6 introduced [literal string interpolation][5] (also known as f-strings) so now you can write the above even more succinct as:

```
>>> f'{pi:.2f}'
'3.14'
```

[1]: https://docs.python.org/3/library/string.html#format-specification-mini-language "Format Specification Mini-Language" [2]: https://mkaz.blog/code/python-string-format-cookbook/ "Python String Format Cookbook" [3]: https://docs.python.org/2/library/string.html#format-string-syntax [4]: https://pyformat.info/ [5]: https://www.python.org/dev/peps/pep-0498/

## Solution 2 - Python

The [String Formatting Operations][1] section of the Python documentation contains the answer you're looking for. In short:

```
"%0.2f" % (num,)
```

Some examples:

```
>>> "%0.2f" % 10
'10.00'
>>> "%0.2f" % 1000
'1000.00'
>>> "%0.2f" % 10.1
'10.10'
>>> "%0.2f" % 10.120
'10.12'
>>> "%0.2f" % 10.126
'10.13'
```

[1]: https://docs.python.org/2/library/stdtypes.html#string-formatting "String Formatting Operations"

## Solution 3 - Python

I suppose you're probably using the [`Decimal()`

][1] objects from the [`decimal`

][2] module? (If you need exactly two digits of precision beyond the decimal point with arbitrarily large numbers, you definitely should be, and that's what your question's title suggests...)

If so, the [*Decimal FAQ*][3] section of the docs has a question/answer pair which may be useful for you:

> Q. In a fixed-point application with two decimal places, some inputs have many places and need to be rounded. Others are not supposed to have excess digits and need to be validated. What methods should be used? > > A. The quantize() method rounds to a fixed number of decimal places. If the Inexact trap is set, it is also useful for validation:

```
>>> TWOPLACES = Decimal(10) ** -2 # same as Decimal('0.01')
>>> # Round to two places
>>> Decimal('3.214').quantize(TWOPLACES)
Decimal('3.21')
>>> # Validate that a number does not exceed two places
>>> Decimal('3.21').quantize(TWOPLACES, context=Context(traps=[Inexact]))
Decimal('3.21')
>>> Decimal('3.214').quantize(TWOPLACES, context=Context(traps=[Inexact]))
Traceback (most recent call last):
...
Inexact: None
```

The next question reads

> Q. Once I have valid two place inputs, how do I maintain that invariant throughout an application?

If you need the answer to that (along with lots of other useful information), see [*the aforementioned section of the docs*][1]. Also, if you keep your `Decimal`

s with two digits of precision beyond the decimal point (meaning as much precision as is necessary to keep all digits to the left of the decimal point and two to the right of it and no more...), then converting them to strings with `str`

will work fine:

```
str(Decimal('10'))
# -> '10'
str(Decimal('10.00'))
# -> '10.00'
str(Decimal('10.000'))
# -> '10.000'
```

[1]: https://docs.python.org/2/library/decimal.html#decimal-objects "Decimal objects" [2]: https://docs.python.org/2/library/decimal.html "decimal — Decimal fixed point and floating point arithmetic" [3]: https://docs.python.org/2/library/decimal.html#decimal-faq "Decimal FAQ"

## Solution 4 - Python

```
>>> print "{:.2f}".format(1.123456)
1.12
```

You can change `2`

in `2f`

to any number of decimal points you want to show.

##### EDIT:

From `Python3.6`

, this translates to:

```
>>> print(f"{1.1234:.2f}")
1.12
```

## Solution 5 - Python

You can use the [string formatting operator][1] as so:

```
num = 49
x = "%.2f" % num # x is now the string "49.00"
```

I'm not sure what you mean by "efficient" -- this is almost certainly *not* the bottleneck of your application. If your program is running slowly, profile it first to find the hot spots, and then optimize those.

[1]: https://docs.python.org/2/library/stdtypes.html#string-formatting "string formatting operator"

## Solution 6 - Python

.format is a more readable way to handle variable formatting:

```
'{:.{prec}f}'.format(26.034, prec=2)
```

## Solution 7 - Python

In python 3, a way of doing this would be

```
'{:.2f}'.format(number)
```

## Solution 8 - Python

if you have multiple parameters you can use

```
print('some string {0:.2f} & {1:.2f}'.format(1.1234,2.345))
>>> some string 1.12 & 2.35
```

## Solution 9 - Python

The OP **always** wants two decimal places **displayed**, so explicitly calling a formatting function, as all the other answers have done, is not good enough.

As others have already pointed out, `Decimal`

works well for currency. But `Decimal`

shows all the decimal places. So, override its display formatter:

```
class D(decimal.Decimal):
def __str__(self):
return f'{self:.2f}'
```

Usage:

```
>>> cash = D(300000.991)
>>> print(cash)
300000.99
```

Simple.

**EDIT:**

To display at least two decimal places but *without* truncating significant digits:

```
class D(decimal.Decimal):
def __str__(self):
"""Display at least two decimal places."""
result = str(self)
i = result.find('.')
if i == -1:
# No '.' in self. Pad with '.00'.
result += '.00'
elif len(result[i:]) == 2:
# One digit after the decimal place. Pad with a '0'.
result += '0'
return result
```

I hope that a future version of Python will improve the number formatting to allow minimum decimal places. Something like the `#`

sign in Excel's number formatting.

## Solution 10 - Python

If you're using this for currency, and also want the value to be seperated by `,`

's you can use

`$ {:,.f2}.format(currency_value)`

.

**e.g.:**

`currency_value = 1234.50`

`$ {:,.f2}.format(currency_value)`

`-->`

`$ 1,234.50`

Here is a bit of code I wrote some time ago:

`print("> At the end of year " + year_string + " total paid is \t$ {:,.2f}".format(total_paid))`

```
> At the end of year 1 total paid is $ 43,806.36
> At the end of year 2 total paid is $ 87,612.72
> At the end of year 3 total paid is $ 131,419.08
> At the end of year 4 total paid is $ 175,225.44
> At the end of year 5 total paid is $ 219,031.80 <-- Note .80 and not .8
> At the end of year 6 total paid is $ 262,838.16
> At the end of year 7 total paid is $ 306,644.52
> At the end of year 8 total paid is $ 350,450.88
> At the end of year 9 total paid is $ 394,257.24
> At the end of year 10 total paid is $ 438,063.60 <-- Note .60 and not .6
> At the end of year 11 total paid is $ 481,869.96
> At the end of year 12 total paid is $ 525,676.32
> At the end of year 13 total paid is $ 569,482.68
> At the end of year 14 total paid is $ 613,289.04
> At the end of year 15 total paid is $ 657,095.40 <-- Note .40 and not .4
> At the end of year 16 total paid is $ 700,901.76
> At the end of year 17 total paid is $ 744,708.12
> At the end of year 18 total paid is $ 788,514.48
> At the end of year 19 total paid is $ 832,320.84
> At the end of year 20 total paid is $ 876,127.20 <-- Note .20 and not .2
```

## Solution 11 - Python

This is the same solution as you have probably seen already, but by doing it this way it's more clearer:

`>>> num = 3.141592654`

`>>> print(f"Number: {num:.2f}")`

## Solution 12 - Python

The Easiest way example to show you how to do that is :

Code :

`>>> points = 19.5 `

`>>> total = 22 `

`>>>'Correct answers: {:.2%}'.format(points/total)`

`

Output : Correct answers: 88.64%

## Solution 13 - Python

what about

```
print round(20.2564567 , 2) >>>>>>> 20.25
print round(20.2564567 , 4) >>>>>>> 20.2564
```