Formatted printing
C-Style String Formatting in Python
Python supports C-style string formatting using the % operator, which provides similar functionality to C’s printf() function. This method is sometimes called “old-style” string formatting but remains useful in many scenarios.
Basic Syntax
python
"format string" % (values)
Control Characters (Format Specifiers)
| Format Specifier | Description | Example | Output |
|---|---|---|---|
%s | String | "%s" % "hello" | hello |
%d | Signed decimal integer | "%d" % 42 | 42 |
%i | Signed decimal integer | "%i" % -10 | -10 |
%u | Unsigned decimal integer | "%u" % 15 | 15 |
%o | Octal integer | "%o" % 8 | 10 |
%x | Hexadecimal (lowercase) | "%x" % 255 | ff |
%X | Hexadecimal (uppercase) | "%X" % 255 | FF |
%f | Floating point decimal | "%f" % 3.14159 | 3.141590 |
%e | Exponential notation (lowercase) | "%e" % 1000 | 1.000000e+03 |
%E | Exponential notation (uppercase) | "%E" % 1000 | 1.000000E+03 |
%g | Shorter of %f or %e | "%g" % 0.00001234 | 1.234e-05 |
%G | Shorter of %f or %E | "%G" % 0.00001234 | 1.234E-05 |
%c | Single character | "%c" % 65 | A |
%r | String (repr() conversion) | "%r" % "hello" | 'hello' |
%% | Literal % character | "100%% complete" | 100% complete |
Formatting Options
You can add modifiers between the % and the format character:
python
%[flags][width][.precision]specifier
Flags
-: Left-justify+: Show sign0: Zero-padding- : Space for positive numbers
#: Alternate form (e.g.,0xfor hex)
Width & Precision
- Integer before dot: minimum field width
- Integer after dot: precision (decimal places for floats, max length for strings)
Examples
Basic Formatting
python
print("Name: %s, Age: %d" % ("Alice", 25))
# Output: Name: Alice, Age: 25
print("Hex: %x, Octal: %o" % (255, 8))
# Output: Hex: ff, Octal: 10
Number Formatting
python
print("Float: %f" % 3.14159) # 3.141590
print("Float: %.2f" % 3.14159) # 3.14
print("Padded: %05d" % 42) # 00042
print("Signed: %+d" % 10) # +10
print("Scientific: %.2e" % 1000) # 1.00e+03
Alignment and Padding
python
print("Left: %-10s!" % "text") # Left: text !
print("Right: %10s!" % "text") # Right: text!
print("Zero-pad: %06d" % 123) # 000123
Multiple Values
python
values = ("John", 30, 50000.50)
print("Name: %s, Age: %d, Salary: %.2f" % values)
# Output: Name: John, Age: 30, Salary: 50000.50
Special Cases
python
print("Percent: %%") # Percent: %
print("Char: %c" % 65) # Char: A
print("Repr: %r" % "hello\nworld") # Repr: 'hello\nworld'
While Python now has more modern formatting methods (.format() and f-strings), C-style formatting remains useful for:
- Legacy code maintenance
- Situations requiring precise numeric formatting
- Cases where you need compatibility with C-style format strings
Python str.format() Method
The str.format() method (introduced in Python 2.6) provides a powerful way to format strings with placeholders ({}). It’s more flexible than %-formatting and works in all Python versions (unlike f-strings).
Basic Syntax
python
"Text {} more text".format(value)
- Uses
{}as placeholders - Values are passed to
.format()in order - Supports indexing, naming, and formatting options
1. Basic Positional Formatting
python
print("{} loves {}".format("Alice", "Python"))
# Output: Alice loves Python
2. Index-Based Formatting
python
print("{0} vs {1} (rematch: {0} vs {1})".format("Python", "Java"))
# Output: Python vs Java (rematch: Python vs Java)
3. Named Placeholders
python
print("Name: {name}, Age: {age}".format(name="Bob", age=30))
# Output: Name: Bob, Age: 30
4. Number Formatting (Floats)
python
print("Pi: {:.2f}".format(3.14159))
# Output: Pi: 3.14
5. Padding and Alignment
python
print("{:<10}|{:^10}|{:>10}".format("Left", "Center", "Right"))
# Output: Left | Center | Right
6. Zero-Padding Numbers
python
print("ID: {:05d}".format(42))
# Output: ID: 00042
7. Dictionary Unpacking
python
data = {"name": "Charlie", "score": 95}
print("Name: {name}, Score: {score}".format(**data))
# Output: Name: Charlie, Score: 95
8. List/Tuple Indexing
python
values = [10, 20, 30]
print("{0[0]}, {0[1]}, {0[2]}".format(values))
# Output: 10, 20, 30
9. Dynamic Formatting
python
for i in range(1, 4):
print("{:{width}}".format(i*i, width=i))
# Output:
# 1
# 4
# 9
10. Combining Multiple Features
python
print("{name:*^20} scored {score:.1f}%".format(name="Alice", score=95.5))
# Output: *******Alice******** scored 95.5%
Key Formatting Specifiers
| Specifier | Meaning | Example | Output |
|---|---|---|---|
:d | Decimal integer | "{:d}".format(42) | 42 |
:f | Float | "{:.2f}".format(3.14159) | 3.14 |
:x | Hexadecimal (lowercase) | "{:x}".format(255) | ff |
:X | Hexadecimal (uppercase) | "{:X}".format(255) | FF |
:b | Binary | "{:b}".format(5) | 101 |
:o | Octal | "{:o}".format(8) | 10 |
:% | Percentage | "{:.0%}".format(0.95) | 95% |
Advantages of str.format()
✅ Works in all Python versions (unlike f-strings)
✅ More readable than %-formatting
✅ Supports complex formatting (alignment, number formats)
✅ Allows reusing values (by index/name)
When to Use str.format()?
- When you need backward compatibility (Python 2.7/3.0+)
- For complex formatting scenarios
- When you need reusable templates with named placeholders
Comparison with Other Methods
| Feature | %-formatting | str.format() | f-strings |
|---|---|---|---|
| Readability | Poor | Good | Excellent |
| Flexibility | Limited | High | High |
| Speed | Fast | Medium | Fastest |
| Python 2.x | Yes | Yes | No |
| Python 3.x | Yes | Yes | 3.6+ |
Conclusion
While f-strings are preferred in Python 3.6+, str.format() remains valuable for:
- Legacy code maintenance
- Complex string templating
- Cases requiring precise control over formatting
F-Strings in Python: T
F-strings (formatted string literals) were introduced in Python 3.6 (PEP 498) and provide a concise, readable way to embed expressions inside string literals using { }. They are faster than %-formatting and str.format().
Syntax of F-Strings
python
f"Text {expression} more text"
- Start with
forFbefore the string. - Enclose expressions inside
{ }. - Supports variables, operations, functions, and formatting.
1. Basic Variable Insertion
python
name = "Alice"
age = 25
print(f"My name is {name} and I am {age} years old.")
Output:My name is Alice and I am 25 years old.
2. Mathematical Expressions
python
a = 5
b = 10
print(f"The sum of {a} and {b} is {a + b}.")
Output:The sum of 5 and 10 is 15.
3. Function Calls Inside F-Strings
python
def greet(name):
return f"Hello, {name}!"
user = "Bob"
print(f"{greet(user)} How are you?")
Output:Hello, Bob! How are you?
4. Formatting Numbers (Floats, Decimals)
python
pi = 3.1415926535
print(f"Pi rounded to 2 decimals: {pi:.2f}")
Output:Pi rounded to 2 decimals: 3.14
5. Padding and Alignment
python
text = "Python"
print(f"Left: {text:<10}") # Left-align
print(f"Right: {text:>10}") # Right-align
print(f"Center: {text:^10}") # Center-align
Output:
text
Left: Python Right: Python Center: Python
6. Zero-Padding Numbers
python
num = 42
print(f"Padded with zeros: {num:05d}")
Output:Padded with zeros: 00042
7. Date Formatting
python
from datetime import datetime
today = datetime.now()
print(f"Today is {today:%B %d, %Y}")
Output:Today is July 29, 2023 (or current date)
8. Dictionary Access
python
user = {"name": "Alice", "age": 30}
print(f"Name: {user['name']}, Age: {user['age']}")
Output:Name: Alice, Age: 30
9. Conditional Expressions
python
age = 17
print(f"{'Adult' if age >= 18 else 'Minor'}")
Output:Minor
10. Multi-line F-Strings
python
name = "Charlie"
profession = "Engineer"
message = (
f"Name: {name}\n"
f"Job: {profession}\n"
f"Status: {'Active' if True else 'Inactive'}"
)
print(message)
Output:
text
Name: Charlie Job: Engineer Status: Active
Key Advantages of F-Strings
✅ Faster than %-formatting and .format()
✅ More readable with embedded expressions
✅ Supports complex operations (functions, conditionals, math)
✅ Better debugging (Python 3.8+ allows {variable=})
Example (Python 3.8+ Debugging)
python
x = 10
print(f"{x=}") # Output: x=10
When to Use F-Strings?
- Python 3.6+ projects.
- Fast string formatting with minimal syntax.
- Dynamic string generation (e.g., logs, reports, SQL queries).
Conclusion
F-strings are the best way to format strings in modern Python. They are clean, fast, and powerful, replacing older methods like % and .format() in most cases.
