Python .2f: Format Floats to Two Decimal Places

The call `'{:.2f}’.format(12.3456)` returns the string `’12.35’`. I find that pairing useful: the format string keeps the display rule beside its input.

You can understand the returned text by looking at the rule inside the format expression. You can also see why `.2f` changes the display, not the original value.

What .2f Means in Python

In Python, .2f formats a number as fixed-point text with two digits after the decimal point. The colon starts the format specification, 2 sets the precision, and f selects fixed-point presentation.

Formatting 12.3456 this way produces the text 12.35. The original numeric value stays unchanged, so the formatted result is for display rather than later arithmetic.

Where .2f Goes in a Format String

In an f-string, the value expression comes first inside braces, then a colon introduces the format specification described in Python’s format specification mini-language. The same replacement-field syntax appears in Python string formatting and str.format().

value = 12.3456
print(f"{value:.2f}")

The command prints 12.35, while %.2f uses percent-style interpolation instead of a replacement-field format specification.

Use .2f with f-Strings and format()

I ran 123.456789 through both forms and got 123.46 from each, so choose the API that fits the surrounding string.

Use an f-string for an embedded value

Assign formatted_value for a separate display string, while value keeps the original number.

value = 123.456789
formatted_value = f"{value:.2f}"
print(formatted_value)

The result is the string 123.46, and value still holds 123.456789.

Set a minimum field width

Add 10 before the precision when the output needs a minimum width of ten characters. Numeric values are right-aligned by default, so Python adds spaces on the left.

value = 123.456789
formatted_value = f"{value:10.2f}"
print(formatted_value)

Width 10 sets a minimum, so longer values print in full instead of being cut off.

Use str.format() with the same precision

str.format() keeps the template in a string and receives the value as an argument, with the same colon and .2f format specification.

value = 123.456789
formatted_value = "{:.2f}".format(value)
print(formatted_value)

The output matches the f-string because both use the same numeric format specification. Keep a template separate from its values with the format() method.

Set width with str.format()

For aligned output, a width of ten reserves ten characters even when the displayed number takes six.

value = 123.456789
formatted_value = "{:10.2f}".format(value)
print(formatted_value)

Those four padding spaces stay in the returned string, which lets numeric values line up in plain-text output.

Group thousands in the display

A comma before the precision groups thousands, while the dollar sign below remains literal text.

financial_value = 9876.54321
formatted_financial_value = f"${financial_value:,.2f}"
print(formatted_financial_value)

Comma grouping changes only the display, so select a numeric type and rounding rule separately for decimal calculations.

When .2f Shows a Different Result Than You Expect

Python’s floating-point tutorial explains why 2.675 has no exact binary float representation. Its stored value sits slightly below that decimal, so formatting it to two places yields 2.67.

Decimal constructed from the text 2.675 preserves that decimal input, and its default context formats it as 2.68. That difference comes from the numeric representation and rounding context, not from two different meanings of .2f.

from decimal import Decimal

value = 2.675
print(f"{value:.2f}")
print(format(Decimal("2.675"), ".2f"))
print(repr(value))

The two formatted results are 2.67 and 2.68. repr shows the shortest decimal text that round-trips to the same float, not its exact binary value.

Choose the decimal module’s rounding rule explicitly when an application needs a specific decimal result.

Formatting Changes the Display, Not the Float

Formatting produces text for a particular display. Keep the numeric value for calculations, then apply .2f where the output needs two decimal places.

python3 -c 'print(2.675, f"{2.675:.2f}")'

FAQs

The format specifier controls the text Python builds, while the numeric type and rounding context control arithmetic.