Skip to main content

How to Format Floats with Trailing Zeros in Python

This guide explains how to format floating-point numbers in Python to include a specific number of trailing zeros after the decimal point. This is primarily a formatting operation (creating a string representation), as Python floats do not inherently maintain trailing zeros. We'll cover using f-strings (formatted string literals), str.format(), and the built-in format() function.

f-strings (formatted string literals) provide the most concise and readable way to format floats with trailing zeros:

my_float = 3.0
result = f'{my_float:.3f}'    # 3 digits after the decimal
print(result)                 # Output: '3.000'
print(type(result))           # Output: <class 'str'>

result = f'{my_float:.5f}'    # 5 digits after the decimal
print(result)                 # Output: '3.00000'
  • f'{my_float:.3f}': This f-string uses the format specification mini-language.
    • my_float: The variable holding the float.
    • :: Introduces the format specifier.
    • .3f: Specifies a fixed-point number (f) with 3 digits after the decimal point (.3).
    • The result will always be a str type.
  • You can change the number after the . to control the number of trailing zeros.

Dynamic Width with f-strings​

You can use a variable to specify the number of decimal places:

my_float = 3.2
width_after_decimal = 4
result = f'{my_float:.{width_after_decimal}f}'
print(result)  # Output: '3.2000'
  • The {width_after_decimal} inside the format specification {:.{width_after_decimal}f} is evaluated as a number and replaces the placeholder, which allows a dynamic construction of string formatting.

Formatting Floats with Trailing Zeros Using str.format()​

The str.format() method offers a similar way to format floats:

my_float = 3.0
result = '{:.3f}'.format(my_float)  # 3 digits after the decimal
print(result)                       # Output: '3.000'

result = '{:.4f}'.format(my_float)
print(result)                       # Output: '3.0000'
  • The syntax is similar to the f-string format, with {:.3f} indicating the format specifier.

Formatting Floats with Trailing Zeros Using format()​

The built-in format() function provides another way to achieve the same formatting:

my_float = 3.0
result = format(my_float, '.3f')  # 3 digits after the decimal
print(result)                     # Output: '3.000'
print(type(result))               # Output: <class 'str'>

width_after_decimal = 4
result_dynamic = format(my_float, f'.{width_after_decimal}f') # Dynamic width
print(result_dynamic)             # Output: 3.0000
  • format(my_float, '.3f') formats my_float as a fixed-point number with 3 decimal places.
  • format() can also accept dynamic width formats when combined with f-strings.

Key Point: Floats Don't Store Trailing Zeros Internally​

It's crucial to understand that Python's float type does not inherently store trailing zeros after the decimal point. The trailing zeros are added only during formatting for display:

my_float = 3.00000000
print(my_float)  # Output: 3.0  (The trailing zeros are NOT stored)
  • The float 3.00000000 is represented internally as simply 3.0. The extra zeros are formatting, not part of the float's value.
  • The methods above all return strings.

Table of Contents