Python format() Method

What You’ll Learn

The format() method builds dynamic strings by filling {} placeholders with values you pass in. It supports positional arguments, numbered indices, named keywords, and powerful format specifiers for numbers and alignment. It is one of Python’s core string-formatting tools—and the foundation behind reusable templates and format_map().

Definition and Usage

In Python, format() is called on a template string that contains replacement fields inside curly braces. You pass values as positional arguments, keyword arguments, or both. Python substitutes each field and returns a brand-new string.

For example, "Hello, {}!".format("World") produces "Hello, World!". Named fields like {name} are filled with keyword arguments: "Hello, {name}!".format(name="Alice").

📝 Syntax

The format() method accepts positional and keyword arguments:

string.format(*args, **kwargs)

Syntax Rules

• {} — auto-numbered positional placeholders (filled in order).
• {0}, {1} — explicit index; reuse an index to repeat a value.
• {name} — named placeholder; pass name=value as a keyword argument.
• {value:spec} — format specifier after colon (width, precision, alignment).
• Return value — a new str; the original template is unchanged.
• Literal braces — escape with doubling: "{{" and "}}".

Examples Gallery

Run these examples in any Python 3 interpreter. Each demonstrates a different way to use placeholders and format specifiers.

name = "Alice"
age = 30
template = "My name is {} and I am {} years old."

result = template.format(name, age)

print("Template:", template)
print("Result:  ", result)

Template: My name is {} and I am {} years old.
Result:   My name is Alice and I am 30 years old.

item1 = "apple"
item2 = "banana"

sentence = "I have {1} and {0}.".format(item1, item2)
print(sentence)

I have banana and apple.

sentence = "The {fruit} is {adjective}.".format(
    fruit="orange",
    adjective="delicious"
)
print(sentence)

The orange is delicious.

price = 19.956
tax_rate = 0.075

print("The price is ${:.2f}.".format(price))
print("Tax rate:     {:.1%}".format(tax_rate))
print("Large total:  {:,}".format(1_250_000))

The price is $19.96.
Tax rate:     7.5%
Large total:  1,250,000

name = "Bob"
age = 25

via_format = "Hello, my name is {} and I'm {} years old.".format(name, age)
via_fstring = f"Hello, my name is {name} and I'm {age} years old."

print("format():", via_format)
print("f-string:", via_fstring)
print("Equal?   ", via_format == via_fstring)

format(): Hello, my name is Bob and I'm 25 years old.
f-string: Hello, my name is Bob and I'm 25 years old.
Equal?    True

↩ Return Value

format() returns a new string with all placeholders replaced. It does not modify the original template, and it does not return None. Because strings are immutable, you must capture the result:

template = "Hello, {}!"
result = template.format("World")

print(result)      # Hello, World!
print(template)    # Hello, {}!  (unchanged)

🚀 Common Use Cases

• User messages — personalize greetings, confirmations, and error text.
• Reports and invoices — align columns and format currency with specifiers.
• Internationalization — store translated templates and fill them at runtime.
• Logging — build structured log lines from reusable format strings.
• Config templates — keep patterns in JSON/YAML and apply values with format() or format_map().

📝 Notes

• format() is more flexible and readable than the older % operator ("%s" % name).
• f-strings (Python 3.6+) are often the shortest choice for inline formatting; format() remains essential for stored templates.
• Mixing auto-numbered {} with explicit {0} in the same string raises ValueError.
• Every placeholder must receive a value—missing arguments raise IndexError or KeyError.
• For dictionary-only data, format_map(data) or format(**data) avoids repeating keyword names.

💡 Best Practices