### Python
String Formatting: An Overview
String
formatting in Python allows you to **insert variables, values, or expressions**
into strings dynamically. This is useful for constructing output or displaying
information in a customized format.
There are
three main ways to format strings in Python:
1. **`%`
operator** (older method, similar to C-style formatting)
2.
**`str.format()` method** (introduced in Python 3)
3.
**f-strings** (formatted string literals, introduced in Python 3.6)
### 1. `%`
Operator (Old Method)
The `%`
operator allows you to insert variables into a string by using format specifiers
(e.g., `%s`, `%d`, `%f`).
#### Syntax:
```python
"string
with %specifier" % (values)
```
####
Example:
```python
name =
"Alice"
age = 25
print("My
name is %s and I am %d years old." % (name, age))
```
**Output:**
```
My name is
Alice and I am 25 years old.
```
#### Common
Format Specifiers:
- `%s` for
strings
- `%d` for
integers
- `%f` for
floating-point numbers
- `%.2f` for
floating-point numbers with two decimal places
#### Example
with Floating-Point Numbers:
```python
pi = 3.14159
print("The
value of pi is %.2f" % pi)
```
**Output:**
```
The value of
pi is 3.14
```
### 2. `str.format()`
Method (Newer Method)
The
`str.format()` method is more powerful and flexible than the `%` operator. It
allows you to insert variables by using curly braces `{}` as placeholders in a
string.
#### Syntax:
```python
"string
with {} placeholders".format(values)
```
#### Example:
```python
name =
"Bob"
age = 30
print("My
name is {} and I am {} years old.".format(name, age))
```
**Output:**
```
My name is
Bob and I am 30 years old.
```
#### Positional
and Keyword Arguments
You can
specify the position of arguments or use named placeholders for more control.
#####
Positional Arguments:
```python
print("My
name is {0} and I am {1} years old.".format("Charlie", 35))
```
**Output:**
```
My name is
Charlie and I am 35 years old.
```
#####
Keyword Arguments:
```python
print("My
name is {name} and I am {age} years old.".format(name="Dave",
age=40))
```
**Output:**
```
My name is
Dave and I am 40 years old.
```
#### Formatting
Numbers with `str.format()`
You can
control the formatting of numbers, such as specifying the number of decimal
places or adding commas for large numbers.
##### Example:
Floating-Point Precision
```python
pi = 3.14159
print("The
value of pi is {:.2f}".format(pi))
# 2 decimal places
```
**Output:**
```
The value of
pi is 3.14
```
#####
Example: Adding Commas to Large Numbers
```python
large_number
= 1000000
print("The
large number is {:,}".format(large_number))
```
**Output:**
```
The large
number is 1,000,000
```
### 3.
F-Strings (Formatted String Literals)
**F-strings**
(formatted string literals) are the most modern and concise way to format
strings in Python. Introduced in Python 3.6, they allow you to directly embed
expressions inside string literals by prefixing the string with an `f` or `F`.
#### Syntax:
```python
f"string
with {variable} inside"
```
####
Example:
```python
name =
"Eve"
age = 28
print(f"My
name is {name} and I am {age} years old.")
```
**Output:**
```
My name is
Eve and I am 28 years old.
```
F-strings
evaluate expressions inside the curly braces `{}`, making them more flexible.
#### Example:
Expressions in F-Strings
```python
num = 5
print(f"The
square of {num} is {num**2}.")
```
**Output:**
```
The square
of 5 is 25.
```
#### Formatting
Numbers with F-Strings
You can also
format numbers with F-strings, similar to `str.format()`.
##### Example:
Floating-Point Precision
```python
pi = 3.14159
print(f"The
value of pi is {pi:.2f}.") # 2
decimal places
```
**Output:**
```
The value of
pi is 3.14.
```
#####
Example: Adding Commas to Large Numbers
```python
large_number
= 1000000
print(f"The
large number is {large_number:,}.")
```
**Output:**
```
The large
number is 1,000,000.
```
### Advanced
Formatting Options
####
Aligning Text and Numbers
You can
control text alignment and padding with formatting options.
##### Left
Align:
```python
name =
"Alice"
print(f"|{name:<10}|") # Left-align the text with a width of 10
```
**Output:**
```
|Alice |
```
##### Right
Align:
```python
print(f"|{name:>10}|") # Right-align the text with a width of 10
```
**Output:**
```
| Alice|
```
##### Center
Align:
```python
print(f"|{name:^10}|") # Center-align the text with a width of 10
```
**Output:**
```
| Alice
|
```
#### Padding
Numbers with Zeros
You can pad
numbers with leading zeros using `:0` in the formatting options.
```python
number = 42
print(f"The
number is {number:04}.") # Pad with
zeros to make it 4 digits
```
**Output:**
```
The number
is 0042.
```
### Comparison
of Formatting Methods
- **`%`
operator**: Older and less flexible, but still works for simple tasks.
-
**`str.format()`**: More powerful and flexible, especially for complex
formatting.
-
**F-strings**: The most modern, concise, and readable method, allowing direct
embedding of expressions.
###
Conclusion
- Use
**F-strings** for simplicity, readability, and performance.
- Use
**`str.format()`** for more complex formatting needs.
- Use the
**`%` operator** only if you need compatibility with older Python code.
