Python Tutorial: String Interpolation in Python


String interpolation is a technique used to embed variables directly into string literals. It is a common operation in any programming language and Python provides several ways to perform string interpolation.

In this tutorial, we will explore different methods of string interpolation in Python and their advantages and disadvantages. We will also discuss the best practices when it comes to string formatting and interpolation.

Table of Contents

What is String Interpolation?

String interpolation is a feature in computer programming that allows values to be inserted into a string literal. It is a way to create a new string by embedding values, such as variables or expressions, within a string literal. String interpolation is also sometimes referred to as string substitution or variable substitution.

In programming languages that support string interpolation, the syntax for inserting values into a string is usually a special character or sequence of characters that represents the value being inserted.

The Old Way: String Concatenation

Let’s discuss a few of the older methods used in Python for string interpolation, all of these still work just fine, but they are not the new f-string literal methods that we suggest you use. We’ll still cover them here so you can understand how they work in case you see them again.

String Formatting with % Operator

The % operator is one of the oldest methods of string formatting in Python. It works by using a format string that contains placeholders for variables, followed by a tuple of values that are mapped to those placeholders.

Let’s look at an example:

name = "John"
age = 25
print("My name is %s and I am %d years old." % (name, age))


My name is John and I am 25 years old.

In the above example, we have used %s as a placeholder for the name variable, which is a string, and %d as a placeholder for the age variable, which is an integer. The values are passed as a tuple inside the print statement.

This method of string formatting has some drawbacks. Firstly, it can be difficult to read and maintain format strings that contain multiple placeholders. Secondly, it doesn’t support named arguments or keyword arguments.

String Formatting with str.format()

The str.format() method was introduced in Python 2.6 as an improvement over the % operator. It provides a more flexible and readable way of formatting strings.

Here’s an example:

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

In Python, there are multiple ways to combine strings and variables. The old way of doing this is by using string concatenation. This involves using the “+” operator to concatenate a string and a variable.

For example, let’s say we have a variable called “name” that contains a string:

name = "John"

We want to create a new string that includes the value of the “name” variable. We can do this using string concatenation like so:

greeting = "Hello, " + name + "!"

The output of this code will be:

Hello, John!

As you can see, we combined the string “Hello, ” with the value of the “name” variable and the exclamation point using the “+” operator.

While this method works, it can quickly become cumbersome when dealing with multiple variables or long strings. In addition, it can also lead to errors if we forget to include spaces or other punctuation.

Thankfully, Python offers a more efficient and readable way to combine strings and variables using string interpolation.

The New Way: f-strings

In Python, string interpolation is the process of substituting values of variables or expressions within a string. It allows us to create dynamic strings that can change based on the values of variables at runtime.

Before Python 3.6, there were multiple ways to achieve string interpolation such as using the % operator or the format() method. However, with the introduction of f-strings in Python 3.6, there is now a more concise and readable way to perform string interpolation.

F-strings are prefixed with the letter ‘f’ and use curly braces {} to enclose expressions that will be replaced with their values at runtime. Let’s take a look at a simple example:

name = "John"
age = 25
print(f"My name is {name} and I am {age} years old.")

In this example, we have defined two variables `name` and `age`. We then use an f-string to interpolate these variables into a string that will be printed to the console. The curly braces `{}` are used to enclose the variable names and they will be replaced with their corresponding values at runtime.

F-strings also support expressions inside the curly braces, allowing us to perform computations or call functions before substituting their values into the string. Here’s an example:

num1 = 10
num2 = 5
print(f"The sum of {num1} and {num2} is {num1 + num2}.")

In this example, we have used an expression inside the curly braces to compute the sum of `num1` and `num2` before it is substituted into the final string.

F-strings also allow for formatting options such as specifying precision for floating-point numbers or padding integers with zeros. Here’s an example:

pi = 3.14159265359
print(f"Pi is approximately {pi:.2f}.")

In this example, we have used a colon `:` followed by `.2f` inside the curly braces to specify that we want the value of `pi` to be formatted as a floating-point number with 2 decimal places.

Overall, f-strings provide a more concise and readable way to perform string interpolation in Python. They allow for expressions and formatting options inside the curly braces, making them a powerful tool for creating dynamic strings.

Using Variables in f-strings

One of the main benefits of using f-strings in Python is the ability to easily include variables within a string.

To include a variable in an f-string, simply enclose the variable name in curly braces within the string. Let’s take a look at an example:

name = "John"
age = 30
print(f"My name is {name} and I am {age} years old.")

In this example, we have defined two variables, `name` and `age`, and included them within the f-string using curly braces. When we run this code, the output will be:

My name is John and I am 30 years old.

We can also perform operations on variables within an f-string. For example:

num1 = 10
num2 = 5
print(f"The sum of {num1} and {num2} is {num1+num2}.")

In this example, we have included both `num1` and `num2` within the f-string, as well as their sum which is calculated within the curly braces. The output of this code will be:

The sum of 10 and 5 is 15.

It’s important to note that when including variables within an f-string, their values will be converted to a string automatically. Therefore, it’s not necessary to use functions like `str()` to convert them beforehand.

With just a few curly braces and variable names, we can easily create personalized messages or perform calculations within our strings.

Performing Operations in f-strings

In addition to inserting variables into strings, f-strings also allow us to perform operations on those variables within the string itself. This can be very useful when we want to display a specific calculation or formatted output.

Let’s take a look at an example:

num1 = 10
num2 = 5

result = f"The sum of {num1} and {num2} is {num1 + num2}."

In this example, we have two variables `num1` and `num2`. We use an f-string to insert the values of these variables into the string, but we also perform an operation on them by adding them together. The result of this operation is then displayed within the string using curly braces `{}`.


The sum of 10 and 5 is 15.

We can also format numbers within an f-string using various formatting options. Let’s take a look at another example:

price = 24.99

result = f"The price of the item is ${price:.2f}."

In this example, we have a variable `price` that contains a float value. We use an f-string to insert this value into the string, but we also format it using the `.2f` option. This tells Python to display the value with two decimal places. We also include a dollar sign before the value to indicate that it is a price.


The price of the item is $24.99.

As you can see, f-strings allow us to easily combine variables with strings and perform operations on those variables within the string itself. This makes our code more concise and easier to read.

Formatting with f-strings

F-strings also support formatting options, which allow you to control how the values are displayed inside the string. For example:

pi = 3.14159265359
print(f"The value of pi is approximately {pi:.2f}.")

In this example, we’re using a formatting option `:.2f` to display the value of `pi` with only two decimal places. The output will be:

The value of pi is approximately 3.14.

There are many other formatting options available for f-strings, which you can learn more about in the official Python documentation.

Overall, f-strings provide a powerful and easy-to-use way to perform string interpolation in Python. They’re particularly useful when you need to embed expressions inside string literals, and can help make your code more concise and readable.


In conclusion, string interpolation is a powerful tool in Python that allows us to embed values within strings easily. We can use the `%` operator or the `format()` method to achieve this, depending on our preference and the situation.

It’s important to keep in mind that when using the `%` operator, we need to make sure that we provide the right number and type of arguments for the placeholders in the string. Otherwise, we will encounter errors.

On the other hand, with `format()`, we have more flexibility in terms of specifying the order of arguments and formatting them. We can also reuse arguments or reference them by name.

In Python 3.6 and above, we have another option for string interpolation called f-strings. F-strings are even more concise and readable than using `%` or `format()`. They allow us to directly embed variables and expressions within curly braces `{}` inside a string prefixed with an `f`.

Overall, understanding string interpolation is an essential skill for any Python programmer who needs to work with strings and data formatting. By mastering this technique, we can write more elegant, efficient, and maintainable code.
Interested in learning more? Check out our Introduction to Python course!

How to Become a Data Scientist PDF

Your FREE Guide to Become a Data Scientist

Discover the path to becoming a data scientist with our comprehensive FREE guide! Unlock your potential in this in-demand field and access valuable resources to kickstart your journey.

Don’t wait, download now and transform your career!

Pierian Training
Pierian Training
Pierian Training is a leading provider of high-quality technology training, with a focus on data science and cloud computing. Pierian Training offers live instructor-led training, self-paced online video courses, and private group and cohort training programs to support enterprises looking to upskill their employees.

You May Also Like

Data Science, Tutorials

Guide to NLTK – Natural Language Toolkit for Python

Introduction Natural Language Processing (NLP) lies at the heart of countless applications we use every day, from voice assistants to spam filters and machine translation. It allows machines to understand, interpret, and generate human language, bridging the gap between humans and computers. Within the vast landscape of NLP tools and techniques, the Natural Language Toolkit […]

Machine Learning, Tutorials

GridSearchCV with Scikit-Learn and Python

Introduction In the world of machine learning, finding the optimal set of hyperparameters for a model can significantly impact its performance and accuracy. However, searching through all possible combinations manually can be an incredibly time-consuming and error-prone process. This is where GridSearchCV, a powerful tool provided by Scikit-Learn library in Python, comes to the rescue. […]

Python Basics, Tutorials

Plotting Time Series in Python: A Complete Guide

Introduction Time series data is a type of data that is collected over time at regular intervals. It can be used to analyze trends, patterns, and behaviors over time. In order to effectively analyze time series data, it is important to visualize it in a way that is easy to understand. This is where plotting […]