String Formatting

Format Fields and Width

String formatting controls $how values appear as text$ . It can align table columns, choose a numeric notation, control precision, and insert values into readable messages. Python provides the str.format() method and f-strings for this work.

The basic replacement field has the form {field_name:format_spec}. A width inside the format specification sets the $minimum amount of space$ . Python keeps the complete value when it needs more room.

Format Types for Number Systems

A format specifier can present one integer in a $different number system$ . The table lists the type characters and the output each one produces for the same value.

Format Type	Symbol	Example Input	Output	Usage
Decimal	`d`	`45`	`45`	Decimal integer
Binary	`b`	`45`	`101101`	Bit representation
Octal	`o`	`45`	`55`	Base-eight representation
Hexadecimal	`x/X`	`45`	`2d/2D`	Lowercase or uppercase base sixteen

width_and_types.py

# Width control with various formats
print('|{0:15}|'.format('xxx'))     # Output: |xxx            |
print('a = {0:6d}'.format(45))      # Output: a =     45
print('a = {0:10b}'.format(45))     # Output: a =     101101
print('a = {0:6x}'.format(45))      # Output: a =     2d

# Width smaller than string - not truncated
print('|{0:1}|'.format('xxx'))      # Output: |xxx|

Position Settings and Fill Characters

A field of fixed width needs a rule for $where the text sits$ and what fills the rest. The alignment character places the value against the left edge, the right edge, or the middle of that width, and a fill character decides which symbol pads the remaining space. Together they keep columns of numbers and labels aligned.

Alignment Options

The diagram compares the same text placed $left, right, and centre$ inside one fixed width, so the alignment character becomes easy to read.

How Width Places Text

Symbol	Name	Behavior	Default for
`<`	Left	Text on left, padding on right	Strings
`>`	Right	Text on right, padding on left	Numbers
`^`	Center	Text in center, even padding	-

Fill Characters and Advanced Formatting

The fill character occupies unused space in the field. It defaults to a space and $appears immediately before an alignment symbol$ . In str.format() and f-strings, a literal { or } cannot be used as the fill character.

alignment_fill.py

# Basic alignment
print('|{0:<15}|'.format('xxx'))    # Output: |xxx            |
print('|{0:>15}|'.format('xxx'))    # Output: |            xxx|
print('|{0:^15}|'.format('xxx'))    # Output: |      xxx      |

# Custom fill characters
print('|{0:-<15}|'.format('xxx'))   # Output: |xxx------------|
print('|{0:*>15}|'.format('xxx'))   # Output: |************xxx|
print('|{0:^^15}|'.format('xxx'))   # Output: |^^^^^^xxx^^^^^^|

# Decimal formatting
x = 123.98
print('x = {0:12f}'.format(x))      # Output: x =   123.980000
print('x = {0:12e}'.format(x))      # Output: x = 1.239800e+02

Argument Reference Methods

A replacement field selects $the value to insert into the text$ . Use an index for a positional argument, a name for a keyword argument, or automatic numbering to take positional arguments in order.

How Placeholders Pick Values

Reference Method Comparison

A format string can name its arguments in $three ways$ . The table compares them by what each one needs and where each one stops.

Method	Syntax	Advantages	Limitations
Numbered	`{0}, {1}`	Explicit control, can repeat	Every referenced index must exist
Keyword	`{name}, {age}`	Each name identifies its value and can repeat	Names must match
Automatic	`{}, {}`	Simple syntax	Cannot mix with numbered

argument_methods.py

# Numbered fields - explicit control
print('{2} - {0} - {1}'.format('first', 'second', 'third'))
# Output: third - first - second

# Keyword fields - using names
print('{name} is {age} years old'.format(name='Alice', age=25))
# Output: Alice is 25 years old

# Automatic numbering - sequential order
print('{} + {} = {}'.format(5, 3, 8))
# Output: 5 + 3 = 8

# Error handling
try:
  print('{a} - {b}'.format(a='xxx'))  # Will error
except KeyError as e:
  print(f"KeyError: {e}")  # Output: KeyError: 'b'

try:
  print('{0} - {1}'.format('xxx'))    # Will error
except IndexError as e:
  print(f"IndexError: {e}")  # Output: IndexError: Replacement index 1 out of range for positional args tuple

Precision Control and Sign Specification

Precision controls the $digits in the formatted text$ , while the sign option controls a plus, minus, or space. For example, format(12.3, "+.2f") produces +12.30: the + sign and the two decimal places come from separate options.

Precision for Decimal Numbers

Precision has a different meaning for each presentation type. For f and e, it sets digits after the decimal point. For g, it sets $significant digits$ . Every table row uses the input 123.98765, so you can compare different displays of the same value.

Format Type	Precision Behavior	Example
`f/F`	Decimal places	`{:.2f}` → `123.99`
`e/E`	Decimal places in exponential	`{:.2e}` → `1.24e+02`
`g/G`	Significant digits	`{:.3g}` → `124`

Sign Options

How Signs Appear in Numbers

In the space row, the symbol is $one blank character$ inside the format specifier, as in {: d}. Because that character is invisible, the table names it as a literal space.

Symbol	Behavior	Example
`+`	Always show sign	`+100`, `-200`
`-`	Only negative sign (default)	`100`, `-200`
literal space	Leaves one space before a positive number	`' 100'`, `'-200'`

precision_sign.py

# Precision control
print('x = {0:.3f}'.format(123.98765))     # Output: x = 123.988
print('x = {0:12.2e}'.format(1.987e-10))   # Output: x =     1.99e-10
print('x = {0:.3g}'.format(1.123456))      # Output: x = 1.12

# Sign specification
numbers = [-100, 200, -300]
print('Default:', ['{:d}'.format(n) for n in numbers])
# Output: Default: ['-100', '200', '-300']
print('Always sign:', ['{:+d}'.format(n) for n in numbers])
# Output: Always sign: ['-100', '+200', '-300']
print('Space positive:', ['{: d}'.format(n) for n in numbers])
# Output: Space positive: ['-100', ' 200', '-300']

# Rounding behavior
print('Tiny number f: {0:12f}'.format(1.1e-10))  # Output: Tiny number f:     0.000000
print('Tiny number g: {0:12g}'.format(1.1e-10))  # Output: Tiny number g:      1.1e-10

F Strings and Dynamic Templates

F-strings have been available since Python 3.6. They evaluate $expressions inside replacement fields$ when the line runs. In f"Age next year: {age + 1}", Python first calculates age + 1, then inserts the sum into the text.

Dynamic Format Templates

$Nested replacement fields$ can set width, fill, or alignment from another value. Use this form when those format values are known only at runtime.

fstrings_dynamic.py

# F-strings - simple syntax
name, age = 'Alice', 25
print(f'{name} is {age} years old')           # Output: Alice is 25 years old
print(f'Next year: {name} will be {age + 1}') # Output: Next year: Alice will be 26

# Dynamic format templates
value, width, fill, align = 'data', 12, '-', '^'
template = '|{val:{f}{a}{w}}|'
result = template.format(val=value, w=width, f=fill, a=align)
print(result)                                 # Output: |----data----|

# Comparison - same output, different methods
x = 123.456
print('Old style: %8.2f' % x)                # Output: Old style:   123.46
print('Format method: {0:8.2f}'.format(x))   # Output: Format method:   123.46
print(f'F-string: {x:8.2f}')                 # Output: F-string:   123.46

# Complex f-string with format spec
import math
radius = 5.7
print(f'Area: {math.pi * radius**2:.2f} cm²') # Output: Area: 102.07 cm²

Reading a Format Specification

Order Inside a Format Specifier

Try "{value:*^+10.2f}".format(value=12.3). The output is **+12.30**. Type f with precision 2 produces 12.30, the + sign adds one character, and four fill characters complete the $minimum width of ten$ . Alignment ^ divides those four fill characters into two on the left and two on the right.

Formatting produces a new string object. The number 12.3 stays unchanged, so you can still use it in another calculation.