For AI agents: use /llms.txt for the Nakafa content index.
String formatting turns values into deliberate text output. It lets you align table columns, choose a numeric notation, control precision, and build 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 a minimum field width, not a maximum. If the formatted value needs more room, Python keeps the complete value instead of truncating it.
| 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 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|| 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 | - |
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.
# 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+02Replacement fields can select positional arguments by index, keyword arguments by name, or positional arguments through automatic numbering.
| Method | Syntax | Advantages | Limitations |
|---|---|---|---|
| Numbered | {0}, {1} | Explicit control, can repeat | Every referenced index must exist |
| Keyword | {name}, {age} | Easy to read, flexible | Names must match |
| Automatic | {}, {} | Simple syntax | Cannot mix with numbered |
# 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 tuplePrecision 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.
| 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 |
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 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-10F-strings have been available since Python 3.6. They evaluate expressions directly inside replacement fields, which often makes local formatting easier to read than a separate format() argument list.
Nested replacement fields can supply parts of a format specification, such as width, fill, or alignment. This is useful when those choices are known only at runtime.
# 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²For the subset covered here, read {value:*^+10.2f} as field name value, fill *, center alignment ^, explicit sign +, minimum width 10, precision 2, and fixed-point type f. Python's full formatting mini-language also supports options such as grouping and alternate forms, so consult it when you need more than this core pattern.