Skip to Content

How To Print A String And A Variable In Python (3 Techniques)

There are times when you want to be able to print the contents of a variable along with a string to help provide some context around what has been output to the console. So how can you print both a string and a variable in Python?

The three methods of being able to print a string and a variable together in Python is by using: string concatenation (using +), or using the .format() string method, or using f-strings.

Let’s explore each of these approaches in a little more detail to see which approach best suits your requirements and needs.

How To Concatenate Strings

To print a string with a variable the first method most people come across is using the concatenation approach.

This is perhaps the easiest to understand as all it involves just remembering one thing: the + sign.

Here’s how this approach works:

>>> x = "Hello"
>>> phrase = x + " world!"
>>> print(phrase)
Hello world!

As you can see from the above example using the simple + operator in a string concatenates two elements into one string.

String concatenation works well with the + operator sign, however, this assumes that both types of what is being concatenated are of the same data type. In the example above both the x and the string " world!" are string data types.

If x were a different data type, such as an integer data type, you would get a TypeError when trying to perform this type of concatenation technique:

>>> x = 100
>>> phrase = x + " world!"

Traceback (most recent call last):
  File "<input>", line 1, in <module>
TypeError: unsupported operand type(s) for +: 'int' and 'str'

As you can see the REPL console is showing on that last line that for the operand + it is unsupported when one data type is int and the other is str.

To get around this problem, simply convert the int data type to a string by using the built-in str() method, like so:

>>> x = 100
>>> phrase = str(x) + " world!"
>>> print(phrase)
100 world!

While this method is easy, there’s an even easier way if you’re looking to append strings to an existing variable.

Append To End Of String

Another way of using the + operator with the concatenation strings in Python is the assignment operator +=. While this approach is more popular with incrementing in Python, it can easily be used with strings and is most helpful when the need for concatenating strings occurs on a variable, and the addition of the new string needs to be added to the end of the existing string.

Here’s an example demonstrating this technique:

>>> x = "Add"
>>> x += " strings"
>>> x += " together"
>>> print(x)
Add strings together

Notice how in the above example I concatenate two additional strings to the original string x which started with "Add".

While this approach is fantastic when appending strings to the end of an already existing string variable, what if your variable strings needs to be inserted inside another string?

Insert String Inside Another String

What if you need to insert a string into another string can you still use the assignment operator +=?

Using the += may not be the best technique as its best use case is when you want to add something to the end of a string, if you’re looking to insert a string inside another string you could the + operator provided the structure of what needs to be inserted is set up correctly.

For example, if you wanted to insert a value between <strong> HTML tags you could achieve the result by doing something like this:

>>> strong_value = "I am strong!"
>>> html_tags = "<strong>" + strong_value + "</strong>"
>>> print(html_tags)
<strong>I am strong!</strong>

As you can see from the above code you insert a string within other strings using the + operator. However, this type of use case is best when dealing with smaller strings. If you have to insert strings within larger strings, like you would with a mail merge client on a template form, then this process becomes quite tedious to do.

Thankfully, Python provides additional techniques to be able to insert strings into larger strings.

How To Use .format() String Method

A technique to help manage the insertion of strings into other strings without increasing the complexity of what is trying to be done is to use the .format() string method.

An example of using this string method can be demonstrated simply below:

>>> "I am {} years old".format(44)
'I am 44 years old'

As you can see from the above example the curly braces {} are used as the insertion point for the value placed within the parameter of the .format() method.

But what if you have to insert more than one variable into a string?

Insert More Than One Variable Into A String

You can use the .format() method to insert more than one variable into a string, but to accomplish this you need to insert additional parameters into your .format() method.

Here’s a demonstration of how this can be done:

>>> "My name is {} and I live in {}".format("Ryan", "Sydney")
'My name is Ryan and I live in Sydney'

As you can see from the above example I have inserted more placeholders {} into the original string and Python knows that each subsequent value inserted into the parameters related positionally to each placeholder in the original string.

Therefore, the first placeholder relates to the first parameter, the second placeholder pertains to the second parameter inserted into the .format() method and so on.

But what if I have multiple placeholders which contain all the same references?

If there are more placeholders than values inserted into the .format() string method you will get an IndexError if your code resembles something like this:

>>> "My name is {} and people call me {}".format("Ryan")
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
IndexError: Replacement index 1 out of range for positional args tuple

In the above example, I have 2 placeholders for text, but I have only 1 parameter inserted into the .format() string method. As a result Python returns an IndexError informing me that the index 1 is out of range – in other words it had no problems inserting Ryan into the first placeholder, but had great difficulty finding a value for the second placeholder as there is no second parameter into the arguments of .format().

So what can you do?

Typing "Ryan" multiple times into the .format() method would get very old very quickly. There has to be an easier way.

And there is!

To make your code work you need to insert the index reference according to the parameter being referenced.

Here’s how to make the above code work, see if you can spot the differences:

>>> "My name is {0} and people call me {0}".format("Ryan")
'My name is Ryan and people call me Ryan'

As you can see the index reference inserted inside the placeholders is the number 0 which relates to the one and only parameter inserted into the .format() string method.

This enables you to reference parameters inserted into the .format() method according to their index position.

For example, here is how you can use the .format() string method to insert multiple strings:

>>> "My name is {0}, I am {1} years old and people call me {0}. I live in {2}.".format("Ryan", 44, "Sydney")
'My name is Ryan, I am 44 years old and people call me Ryan. I live in Sydney.'

Notice how each reference needs its index position to be able to be inserted into the original string.

However, this does get quite cumbersome the more variables you want to insert and keeping track can get complicated. There is one more approach that you can use and is known as the f-strings.

How To Use f-Strings

Since Python 3.6 another way of being able to insert strings into another string is to use Python’s f-strings. The way f-strings work is similar to the .format() string method, but instead of appending the strings to insert at the end of the string in the format() parameters.

f-strings enable the use of being able to write your variable insertions into the original string by using placeholders where the placeholders contain the name of the variables to be inserted directly.

Here is a demonstration of their use:

>>> my_name = "Ryan"
>>> my_age = 44
>>> my_city = "Sydney"
>>> f"My name is {my_name}, I am {my_age} years old and people call me {my_name}. I live in {my_city}."
'My name is Ryan, I am 44 years old and people call me Ryan. I live in Sydney.'

As you can see from the above example the reason why this technique is called f-strings is that before entering the quotes for your string you need to prefix it with the letter f. Then inside the string each insertion point is like the previous format() method by using the curly braces {} with the only difference being instead of index numbers inside there are variable names.

If you happen to reference a variable name that doesn’t exist you will get a NameError informing you of the variable used in your string that is not defined.


There are several techniques in Python to insert a variable into a string. The most common approach is to use the + operator and to concatenate strings together, this can give rise to using the assignment operator should strings and/or variables be appended to each other.

The other techniques are somewhat the same and one involves the .format() string method whereas the other is a more recent development in Python and involves f-strings. Both of these techniques use curly braces to insert variables into the original string with the former method using index references according to where a variable has been inserted into the parameters, whereas the other relies on the variable already being defined and using its variable name.

Your approach to using a particular technique will depend on which method best suits your use case and makes your code easy to understand.