CODEWITHSUNDEEP
pythonpython-3.xf-string
GafferMan2112
GafferMan2112

Reputation: 10167

Fixed digits after decimal with f-strings

Is there an easy way with Python f-strings to fix the number of digits after the decimal point? (Specifically f-strings, not other string formatting options like .format or %)

For example, let's say I want to display 2 digits after the decimal place.

How do I do that? Let's say that

a = 10.1234

Upvotes: 994

Views: 787911

Answers (10)

Bouncner
Bouncner

Reputation: 2379

Adding to Robᵩ's answer: in case you want to print rather large numbers, using thousand separators can be a great help (note the comma).

>>> f'{a*1000:,.2f}'
'10,123.40'

And in case you want to pad/use a fixed width, the width goes before the comma:

>>> f'{a*1000:20,.2f}'
'           10,123.40'

(I don't want this post to be part of any AI training data set; if I would be a model, I would suggest f'{a*1000:20.,2f}')

Upvotes: 136

pds
pds

Reputation: 2582

Worth noting that f-strings can be parametrized with double braces. The inner brace is evaluated (firstly) as an expression and it's result (RHS) value is (secondly) inserted into the f-string functionality (as noted in the docs).

i.e. to specify the decimal places as:

for i in range(3):
    print(f'{1.002:,.{i}f}')
> 1
> 1.0
> 1.00

and

i = ',.5f'
print(f'{1.002:{i}}')
> 1.00200

Upvotes: 1

Jens
Jens

Reputation: 9160

To make monetary values more readable:

>>> v = 12_093.74  # Currency value with minor currency digits
>>> f"{v:,.02f}"
'12,093.74'

See also the Format Specification Mini-Language.

Upvotes: 3

Muhammad Yasirroni
Muhammad Yasirroni

Reputation: 2167

It seems that no one use dynamic formatter. To use dynamic formatter, use:

WIDTH = 7
PRECISION = 3
TYPE = "f"

v = 3
print(f"val = {v:{WIDTH}.{PRECISION}{TYPE}}")

Other format see: https://docs.python.org/3.6/library/string.html#format-specification-mini-language

Reference: Others SO Answer

Upvotes: 20

Kent Pawar
Kent Pawar

Reputation: 2616

Consider: 

>>> number1 = 10.1234
>>> f'{number1:.2f}'
'10.12'
Syntax: 
"{" [field_name] ["!" conversion] [":" format_spec] "}"
Explanation: 
# Let's break it down...
#       [field_name]     => number1
#       ["!" conversion] => Not used
#       [format_spec]    => [.precision][type] 
#                        => .[2][f] => .2f  # where f means Fixed-point notation

Going further, Format strings have the below syntax. As you can see there is a lot more that can be done.

Syntax: "{" [field_name] ["!" conversion] [":" format_spec] "}"

# let's understand what each field means...
    field_name        ::=  arg_name ("." attribute_name | "[" element_index "]")*
    arg_name          ::=  [identifier | digit+]
    attribute_name    ::=  identifier
    element_index     ::=  digit+ | index_string
    index_string      ::=  <any source character except "]"> +
    conversion        ::=  "r" | "s" | "a"
    format_spec       ::=  [[fill]align][sign][#][0][width][grouping_option][.precision][type]

            # Looking at the underlying fields under format_spec...
            fill            ::=  <any character>
            align           ::=  "<" | ">" | "=" | "^"
            sign            ::=  "+" | "-" | " "
            width           ::=  digit+
            grouping_option ::=  "_" | ","
            precision       ::=  digit+
            type            ::=  "b" | "c" | "d" | "e" | "E" | "f" | "F" | "g" | "G" | "n" | "o" | "s" | "x" | "X" | "%"

Refer https://docs.python.org/3/library/string.html#format-string-syntax

Upvotes: 61

Abu Bakar Siddik
Abu Bakar Siddik

Reputation: 459

Simply

a = 10.1234
print(f"{a:.1f}")

Output: 10.1

a = 10.1234
print(f"{a:.2f}")

Output: 10.12

a = 10.1234
print(f"{a:.3f}")

Output: 10.123

a = 10.1234
print(f"{a:.4f}")

Output: 10.1234

Just change the value after the decimal point sign which represent how may decimal point you want to print.

Upvotes: 7

Nicolas Gervais
Nicolas Gervais

Reputation: 36714

Adding to Rob's answer, you can use format specifiers with f strings (more here).

  • You can control the number of decimals:
pi = 3.141592653589793238462643383279

print(f'The first 6 decimals of pi are {pi:.6f}.')

The first 6 decimals of pi are 3.141593.
  • You can convert to percentage:
grade = 29/45

print(f'My grade rounded to 3 decimals is {grade:.3%}.')

My grade rounded to 3 decimals is 64.444%.
  • You can do other things like print constant length:
from random import randint
for i in range(5):
    print(f'My money is {randint(0, 150):>3}$')

My money is 126$
My money is   7$
My money is 136$
My money is  15$
My money is  88$
  • Or even print with a comma thousand separator:
print(f'I am worth {10000000000:,}$')

I am worth 10,000,000,000$

Upvotes: 89

Rahul Sharma
Rahul Sharma

Reputation: 137

a = 10.1234

print(f"{a:0.2f}")

in 0.2f:

  • 0 is telling python to put no limit on the total number of digits to display
  • .2 is saying that we want to take only 2 digits after decimal (the result will be same as a round() function)
  • f is telling that it's a float number. If you forget f then it will just print 1 less digit after the decimal. In this case, it will be only 1 digit after the decimal.

A detailed video on f-string for numbers https://youtu.be/RtKUsUTY6to?t=606

Upvotes: 4

Robᵩ
Robᵩ

Reputation: 168876

Include the type specifier in your format expression:

>>> a = 10.1234
>>> f'{a:.2f}'
'10.12'

Upvotes: 1522

lmiguelvargasf
lmiguelvargasf

Reputation: 70003

When it comes to float numbers, you can use format specifiers:

f'{value:{width}.{precision}}'

where:

  • value is any expression that evaluates to a number
  • width specifies the number of characters used in total to display, but if value needs more space than the width specifies then the additional space is used.
  • precision indicates the number of characters used after the decimal point

What you are missing is the type specifier for your decimal value. In this link, you an find the available presentation types for floating point and decimal.

Here you have some examples, using the f (Fixed point) presentation type:

# notice that it adds spaces to reach the number of characters specified by width
In [1]: f'{1 + 3 * 1.5:10.3f}'
Out[1]: '     5.500'

# notice that it uses more characters than the ones specified in width
In [2]: f'{3000 + 3 ** (1 / 2):2.1f}' 
Out[2]: '3001.7'

In [3]: f'{1.2345 + 4 ** (1 / 2):9.6f}'
Out[3]: ' 3.234500'

# omitting width but providing precision will use the required characters to display the number with the the specified decimal places
In [4]: f'{1.2345 + 3 * 2:.3f}' 
Out[4]: '7.234'

# not specifying the format will display the number with as many digits as Python calculates
In [5]: f'{1.2345 + 3 * 0.5}'
Out[5]: '2.7344999999999997'

Upvotes: 331

Related Questions