Format Floats Within F-Strings

How to Format and Round a Float Within a Python F-String

an f-string is a literal string prefixed with a lowercase or uppercase letter f and contains zero or more replacement fields enclosed within a pair of curly braces {...}
each field contains an expression that produces a value
can calculate the field's content
can also use function calls or even variables

while most strings have a constant value, f-strings are evaluated at runtime
makes it possible to pass different data into the replacement fields of the same f-string and produce different output
the way to embed dynamic content neatly inside strings
f-strings do have their short-comings

how to embed the result of a calculation within an f-string

>>> f"One third, expressed as a float is: {1 / 3}"
'One third, expressed as a float is: 0.3333333333333333'

to format a float for neat display within a Python f-string, can use a format specifier.
allows defining the precision the float will be displayed with

>>> f"One third, rounded to two decimal places is: {1 / 3:.2f}"
'One third, rounded to two decimal places is: 0.33'

to round numbers to significant figures use the lowercase letter g in the format specifier
can also use an uppercase G which automatically switches the format to scientific notation for large numbers

>>> import math

>>> f"Area = {math.pi * 10.203**2}"
'Area = 327.0435934242156'

>>> f"Area = {math.pi * 10.203**2:,.5g}"
'Area = 327.04'

can use format specifiers to display numbers as percentages
to do this manually need to multiply the number by one hundred and append it with a percent sign (%) before displaying it with the required amount of decimal places
can do all of this automatically by using the % presentation type in place of the lowercase f or g

>>> f"{0.1256:.1%}"
'12.6%'
>>> f"{0.5:.2%}"
'50.00%'
>>> f"{3:.2%}"
'300.00%'

Customizing the Width of Your Formatted Strings

>>> sample = 12345.6789

>>> print(
...     f"(1) |{sample:.2f}|",
...     f"(2) |{sample:1.2f}|",
...     f"(3) |{sample:8.2f}|",
...     f"(4) |{sample:12.2f}|",
...     sep="\n",
... )
(1) |12345.68|
(2) |12345.68|
(3) |12345.68|
(4) |    12345.68|

in each of the results the precision is set to .2f
left-padded with blanks by default
newline character (\n) used as a value separator to print each output in its own line
each number is displayed between pipe characters (|) to emphasize the padding

in the first result no width was specified
the f-string sized the string to contain everything before the decimal point and the specified two digits after

in the second example the width is too small to accommodate the output
it's resized to allow the string to fit

in the third example the width is exactly the size required
no padding is necessary and again the same result occurs

the final example shows padding has been applied to the output
the width is four characters beyond that required, so four blank spaces have been inserted into the start of the string

by default string padding is done at the beginning of the string
can align to the left, right, and even center-align data within a specified width

>>> sample = 12345.6789

>>> print(
...     f"(1) |{sample:<12,.2f}|",
...     f"(2) |{sample:>12,.2f}|",
...     f"(3) |{sample:^12,.2f}|",
...     sep="\n",
... )
(1) |12,345.68   |
(2) |   12,345.68|
(3) | 12,345.68  |

in the second example the comma is included in the length of the value
it's padded with three spaces rather than four
can specify the padding character

>>> sample = 12345.6789

>>> print(
...     f"(1) |{sample:*<12,.2f}|",
...     f"(2) |{sample:*>12,.2f}|",
...     f"(3) |{sample:*^12,.2f}|",
...     sep="\n",
... )
(1) |12345.68****|
(2) |****12345.68|
(3) |**12345.68**|

Controlling the Placement of Number Signs

to force the display of a sign against all numbers add the plus sign (+)

>>> sample = -12345.68

>>> print(
...     f"(1) |{sample:12,.2f}|",
...     f"(2) |{sample:+12,.2f}|",
...     f"(3) |{-sample:+12,.2f}|",
...     sep="\n",
... )
(1) |  -12,345.68|
(2) |  -12,345.68|
(3) |  +12,345.68|

one problem is a sign will used when the number is zero

>>> result = (5 * 0) / (-4 + 2)

>>> print(
...     f"(1) {result:12.1g}",
...     f"(2) {result:+12.1f}",
...     sep="\n",
... )
(1)           -0
(2)         -0.0

>>> print(
...     f"(1) {result:z12.1g}",
...     f"(2) {result:z12.1f}",
...     sep="\n",
... )
(1)            0
(2)          0.0

Rounding Scientific Notation and Complex Numbers

Python uses E notation to display scientific notation

Number	Scientific Notation	Python Notation
23000	2.3 x 10⁴	2.3e⁴
0.00023	2.3 x 10^-4	2.3e^-4

using format specifiers

>>> f"{1234.56789:.2e}"
'1.23e+03'

>>> f"{0.00012345:.3e}"
'1.234e-04'

can also use format specifiers with complex numbers
a complex number is formed of both a real part and an imaginary part
the imaginary part being a multiple of the square root of negative one
normally written in the form a+bi
a is called the real part, and b is called the imaginary part
Python uses the letter j instead of i to denote the imaginary part

>>> value = 3.474 + 2.323j
>>> print(
...     f"The complex number {value} is formed",
...     f"from the real part {value.real:.2f},",
...     f"the imaginary part {value.imag:.1f},",
...     f"and is approximately {value:.0f}.",
...     sep="\n",
... )
The complex number (3.474+2.323j) is formed
from the real part 3.47,
the imaginary part 2.3,
and is approximately 3+2j.

Using decimal Objects to Mitigate Floating Point Inaccuracies

the float type is limited to 64 bits of storage for storing a number
if a number exceed this size, it can't be represented accurately

>>> f"{(10000000000000 / 3)}"
'3333333333333.3335'

precise answer is an infinite number of recurring threes
format specifiers only round their data for display

>>> f"{(10000000000000 / 3) + 0.6666}"
'3333333333334.0'

inaccuracy still exists
now inaccuracy is now in the integer part of the number

the error is .6 units

if accuracy assurance is needed, should consider using the built-in decimal module instead
Decimal objects provide more control over floating-point arithmetic than the built-in float type
decimals allow performing calculations to a consistent precision and set that precision centrally

>>> from decimal import Decimal as D
>>> from decimal import getcontext

>>> getcontext().prec = 4
>>> f"£{float("0.1") + float("0.1") + float("0.1")}"
'£0.30000000000000004'

>>> f"£{D("0.1") + D("0.1") + D("0.1")}"
'£0.3'

the decimal module is part of the standard library
to access the Decimal class must still import it
importing Decimal with the letter D as its alias, can use the alias when creating instances and write more concise code

also import the getcontext() function
when using the Decimal objects in code, many of their key properties are managed centrally by their context object
the getcontext() function obtains this
use its .prec attribute to set the precision of the Decimal objects
this defines the number of significant figures each Decimal will contain
Decimal instances are rounded to fit their precision
below the rounding takes place after the calculation

>>> getcontext().prec = 4
>>> f"£{D("0.10001") + D("0.20001"):.2f}"
'£0.30'

Formatting Strings in Other Ways

built-in format() function is another way to produce formatted strings
the function takes two arguments - the value to be formatted and any of the format specifiers

>>> format(-123.4567, "+9.2f")
'  -123.46'
>>> f"{-123.456:+9.2f}"
'  -123.46'

>>> format(0.125, ".2%")
'12.50%'
>>> f"{0.125:.2%}"
'12.50%'

the f-string version is more compact and generally more readable

to use the str.format() method need to insert replacement field placeholders into the string where the data should go
then add format specifiers into the placeholders to specify how the data should appear
finally pass the data to be inserted into the string as parameters to .format() in the same order as the placeholders

>>> opposite = 1.234
>>> adjacent = 5.678
>>> hypotenuse = (opposite**2 + adjacent**2) ** 0.5
>>> template = "Opposite = {:0.1f}, Adjacent = {:0.2f}, Hypotenuse = {:0.3f}"
>>> template.format(opposite, adjacent, hypotenuse)
'Opposite = 1.2, Adjacent = 5.68, Hypotenuse = 5.811'

the placeholders use each of the parameters passed to the .format() method in order
isn't quite as readable as the f-string alternative
still use the same mini-language to define the formatting

can also pass in values to .format() by keyword
when you add these keywords into the string's replacement fields, the corresponding values will be inserted into the string when it's displayed

>>> template = (
...     "Opposite = {opposite:0.1f}, "
...     "Adjacent = {adjacent:0.2f}, "
...     "Hypotenuse = {hypotenuse:0.3f}"
... )
>>> template.format(
...     hypotenuse=(1.234**2 + 5.678**2)**0.5,
...     adjacent=5.678,
...     opposite=1.234
... )
'Opposite = 1.2, Adjacent = 5.68, Hypotenuse = 5.811'

can pass a dictionary as well

>>> data = {
...     "opposite": 1.234,
...     "adjacent": 5.678,
...     "hypotenuse": (1.234**2 + 5.678**2) ** 0.5,
... }

>>> template = (
...     "Opposite = {opposite:0.1f}, "
...     "Adjacent = {adjacent:0.2f}, "
...     "Hypotenuse = {hypotenuse:0.3f}"
... )

>>> template.format(**data)
'Opposite = 1.2, Adjacent = 5.68, Hypotenuse = 5.811'

use the unpacking operator (**) to pass the dictionary data into .format()