Python String `format()` Method

The Python string format() method inserts values into a string by replacing placeholders.

It is a useful way to build readable messages without joining many strings together by hand.

Quick example

name = "Maya"
age = 12

message = "My name is {} and I am {} years old.".format(name, age)
print(message)

Output:

My name is Maya and I am 12 years old.

Use {} as placeholders, then pass values to format() in the same order.

If you are new to strings, see Python strings explained: basics and examples.

What the `format()` method does

The format() method:

inserts values into a string
replaces placeholders like {} with given values
returns a new string
does not change the original string

Example:

text = "Hello, {}"
new_text = text.format("Sam")

print(new_text)
print(text)

Output:

Hello, Sam
Hello, {}

Notice that text stays the same. format() creates and returns a new string.

Basic syntax

The general form is:

"text {}".format(value)

Key idea:

each {} is a placeholder
values are inserted from left to right by default
the number of placeholders should match the values you pass

Example:

animal = "cat"
sound = "meow"

sentence = "The {} says {}.".format(animal, sound)
print(sentence)

Output:

The cat says meow.

You can print the result directly, or save it in a variable first.

Using positional placeholders

You can use empty braces {} for simple left-to-right replacement.

print("I like {} and {}.".format("pizza", "pasta"))

Output:

I like pizza and pasta.

You can also use numbered placeholders like {0} and {1}.

This is helpful when:

you want to reuse a value
you want to change the order

Example with reused values:

text = "{0} is learning Python. {0} likes coding.".format("Lina")
print(text)

Output:

Lina is learning Python. Lina likes coding.

Example with changed order:

text = "{1} comes after {0}.".format("one", "two")
print(text)

Output:

two comes after one.

Numbered placeholders work, but for beginners, plain {} is often easier to read unless you need to reuse values.

Using named placeholders

Named placeholders look like {name}.

You pass matching names into format():

text = "My name is {name} and I live in {city}.".format(name="Ana", city="Lima")
print(text)

Output:

My name is Ana and I live in Lima.

Named placeholders are useful because:

they make code easier to read
they help when a string has many values
they reduce confusion about the order

Example:

report = "Student: {student}, Score: {score}".format(student="Noah", score=95)
print(report)

Output:

Student: Noah, Score: 95

If you need to convert a value to text first, see Python str() function explained.

Formatting numbers

format() can also control how numbers look.

A common example is :.2f, which means:

show the value as a floating-point number
keep 2 digits after the decimal point

Example:

price = 3.5
text = "Price: ${:.2f}".format(price)
print(text)

Output:

Price: $3.50

Another example:

average = 91.236
print("Average: {:.2f}".format(average))

Output:

Average: 91.24

This is useful for:

prices
averages
percentages

You can print formatted text with the Python print() function.

Return value

format() returns a string.

That means you can:

save it in a variable
print it directly
use it anywhere a string is needed

Example:

message = "Hello, {}!".format("Chris")
print(message)
print(type(message))

Output:

Hello, Chris!
<class 'str'>

The original string is not changed.

`format()` vs f-strings

format() is a string method.

Python also has f-strings, which are another way to insert values into strings.

Example with format():

name = "Rita"
print("Hello, {}!".format(name))

Example with an f-string:

name = "Rita"
print(f"Hello, {name}!")

For many beginners, f-strings are shorter and easier to read.

This page focuses on how format() works. If you want the bigger picture, read how to format strings in Python.

Common mistakes

Here are some common problems beginners run into when using format().

Using more placeholders than values

This causes an error because Python cannot fill every placeholder.

text = "Hello, {} {}!".format("Sam")
print(text)

You need to pass enough values for all placeholders.

Fixed version:

text = "Hello, {} {}!".format("Sam", "Lee")
print(text)

Using the wrong placeholder name

The name inside the braces must match the name passed to format().

Problem:

text = "Hello, {name}!".format(username="Sam")
print(text)

Fixed version:

text = "Hello, {name}!".format(name="Sam")
print(text)

Expecting `format()` to change the original string

format() does not modify the original string.

Problem:

text = "Hello, {}"
text.format("Sam")
print(text)

Output:

Hello, {}

Fixed version:

text = "Hello, {}"
text = text.format("Sam")
print(text)

Forgetting that `format()` returns a new string

This is similar to the problem above. Always store the result if you need to use it later.

Mixing placeholder indexes in a confusing way

Numbered placeholders can be useful, but too much mixing can make the string harder to understand.

Use simple {} or named placeholders when possible.

If you are trying to join strings and numbers directly, you may also see TypeError: can only concatenate str not int to str.

Helpful checks while debugging

These simple lines can help you test what is happening:

print(text)
print(type(value))
print("Hello {}".format("Sam"))
help(str.format)

Use them to check:

what your string looks like before and after formatting
what type your value has
whether a small test example works
Python’s built-in help for str.format

FAQ

What does Python string `format()` return?

It returns a new string with the placeholders replaced.

Do I need to use numbers inside the braces?

No. You can use plain {} for simple cases, or numbered and named placeholders when needed.

Can I format numbers with `format()`?

Yes. A common example is "{:.2f}" to show 2 decimal places.

Is `format()` better than f-strings?

For many beginners, f-strings are easier to read, but format() is still useful and common.

Python String format() Method

Python String `format()` Method