For AI agents: use /llms.txt for the Nakafa content index.
String formatting controls data display in Python programs. Imagine arranging data in a neat table where each column has consistent width. Python provides format() method and f-strings to control output display.
The basic replacement field syntax is {name : width}, where name determines the argument and width sets the minimum output width. When width is smaller than the original string length, Python still displays the complete string.
| Format Type | Symbol | Example Input | Output | Usage |
|---|---|---|---|---|
| Decimal | d | 45 | 45 | Default for integer |
| Binary | b | 45 | 101101 | Bit representation |
| Octal | o | 45 | 55 | Unix systems |
| Hexadecimal | x/X | 45 | 2d/2D | Low-level programming |
# 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 | String, objects |
> | Right | Text on right, padding on left | Numbers |
^ | Center | Text in center, even padding | - |
Fill character determines the character to fill empty space. Default uses space, but can be replaced with any character except { and }.
# 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+02Python provides three ways to reference arguments in replacement fields, each with different rules.
| Method | Syntax | Advantages | Limitations |
|---|---|---|---|
| Numbered | {0}, {1} | Explicit control, can repeat | Must match argument count |
| 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 controls the number of decimal places or significant digits in number display.
| 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+ and provide the simplest syntax with direct expression evaluation. Faster and more readable compared to format().
Format templates can use variables for specification, useful when format is determined dynamically.
# 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²Format specification follows the pattern {name:fill align sign width .prec type} where each component is optional and has a specific function to control output display.