String interpolation can be performed using multiple ways in Python. There are several methods provided by Python that can help us interpolate strings. Some of them are known as an old school or traditional way of formatting the string and some are added recently been added and gained so much popularity.
One of the modern ways of interpolating the strings in Python is called f-string. First of all, what is string interpolation? String interpolation can be defined as assessing the string literal that contains one or more placeholders and replacing the placeholders with the corresponding values.
f-string was introduced in Python version 3.6 and proposed in the PEP 498 to make the string formatting easier and easy to read. This improved the way how a string is formatted.
f-string
f-string is also called Formatted String literal and is a convenient way to interpolate variables into the string. Unlike the other formatting methods that use the %
operator and .format()
method, the f-strings are prefixed with the letter f
with the curly braces containing expressions that will be replaced by the corresponding values.
The f
in f-string can also stand for fast because of its better performance than the other formatting methods and it has several advantages.
Advantages
The big advantages of using f-strings are listed below:
- Readability: F-strings are easier to read and write compared to other string formatting methods, such as the
%
operator and the.format()
method. They allow us to include variables and expressions directly in the string literal, which makes the code more concise and expressive. - Flexibility: F-strings offer more flexibility and control over the formatting of interpolated values. We can specify a format specifier after the variable or expression in the curly braces to control how the value is formatted.
- Performance: F-strings are faster than the
.format()
method and the%
operator.
Syntax
The syntax of the f-string is very simple.
1 2 3 4 5 6 7 |
var1 = "Geeks" var2 = "GeekPython" f"Hey, there {var1}, Welcome to {var2}." ---- Hey, there Geeks, Welcome to GeekPython. |
The above example shows the usage of f-string where the string literal has the letter f
at the beginning with the placeholders containing expressions.
Using expressions
The values are evaluated at the runtime in f-string, so we can put valid arbitrary expressions inside them.
1 2 3 4 5 |
import math exp = f'{math.pow(2, 3)}' print(exp) >>> 8.0 |
The above code was executed without any error and printed the value of 2 raised to power 3.
Like this, we can use the user-defined functions inside the f-string. Here’s the example
1 2 3 4 5 6 7 8 |
def add(exp): return exp + 'python' val = 'geek' str = f'{add(val)}' print(str) >>> geekpython |
The function named add()
was called inside the f-string that adds the exp
argument with 'python'
and prints it.
Using methods
We can call Python methods directly inside the f-string. The following example will show you calling the methods directly inside the f-string.
1 2 3 4 5 |
val = 'geekpython' str = f'{val.upper()}' print(str) >>> GEEKPYTHON |
In the above code, the upper()
method was called directly inside the f-string.
Using f-string inside Python classes
Classes in Python are used in OOPs (Object Oriented Programming) and we can use objects created from classes with f-string. Here’s an example below demonstrating the use of f-string inside a Python class.
1 2 3 4 5 6 7 |
class Detail: def __init__(self, firstname, lastname): self.firstname = firstname self.lastname = lastname def __str__(self): return f'Hello from {self.firstname} {self.lastname}' |
Now we can call the class Detail
with the arguments. Here’s how we can do it.
1 2 3 4 |
detail = Detail('Geek', 'Python') print(f'{detail}') >>> Hello from Geek Python |
In the class Detail
, the __str__
method is used for the presentation of the objects as a string and __str__
is the informal presentation of the string. We could even use __repr__
to print the objects as the official representation of the string.
1 2 3 4 5 6 |
def __repr__(self): return f'Good bye from {self.firstname} {self.lastname}' print(f'{detail!r}') >>> Good bye from Geek Python |
Well, you could have noticed that !r
is used inside the f-string to print the __repr__
object. It is because !r
chooses the repr
method to format the object.
Using multiline f-string
We can use multiple f-string in a single statement. Take a look at the example below.
1 2 3 4 5 6 7 8 9 10 11 12 |
real_name = 'Robert Downey Jr' reel_name = 'Tony Stark' hero_name = 'Iron Man' details = ( f'The real name is {real_name}, ' f'The reel name is {reel_name}, ' f'The hero name is {hero_name}.' ) print(details) >>> The real name is Robert Downey Jr, The reel name is Tony Stark, The hero name is Iron Man. |
But there is a flaw in using multiline f-string, we have to place f
at the beginning of each string when writing multiline f-strings. If we try to do so then we’ll get something like the below.
1 2 3 4 5 6 7 8 9 10 11 12 |
real_name = 'Robert Downey Jr' reel_name = 'Tony Stark' hero_name = 'Iron Man' details = ( f'The real name is {real_name}, ' 'The reel name is {reel_name}, ' 'The hero name is {hero_name}.' ) print(details) >>> The real name is Robert Downey Jr, The reel name is {reel_name}, The hero name is {hero_name}. |
Escape sequences
We cannot use backlashes inside the f-string to escape the quotation mark and all, if we try to do it, we’ll get an error.
1 2 3 4 |
val = f'{\'hello\'}' print(val) >>> SyntaxError: f-string expression part cannot include a backslash |
There is a way to escape quotation marks by using different types of quotes inside the expression.
1 2 3 4 |
val = f"{'hello'}" print(val) >>> hello |
Braces
If we want to include braces in our code then we should use extra braces to the string literal in order to appear in the output.
1 2 3 4 5 6 7 8 9 |
val = f'{{{4**2}}}' print(val) >>> {16} val1 = f'{{2 ** 2 * 4}}' print(val1) >>> {2**2*4} |
In the first block of code, we used two pairs of braces and we got the output with the braces whereas, in the second block of code, we used a single pair of braces and we didn’t get the expected output instead we got the whole expression as it is in the f-string.
Using format specifiers
We can use format specifiers to evaluate the expression inside the f-string. The following example demonstrates the usage of floating-point precision inside the f-string.
1 2 3 4 5 6 7 8 9 10 |
import math value = math.pi width = 5 precision = 10 val = f'result: {value:{width}.{precision}}' print(val) >>> result: 3.141592654 |
Dictionaries
We have seen the direction to use quotation marks inside an f-string, but we need to be more careful when using the dictionary inside an f-string.
1 2 3 4 5 6 |
greet = {'expression': 'Hello', 'from': 'GeekPython'} my_dict = f'{greet["from"]} is saying {greet["expression"]}.' print(my_dict) >>> GeekPython is saying Hello. |
The above code works because we used different types of quotation marks but if we use the same type of quotation marks then we’ll get an error.
1 2 3 4 5 6 |
greet = {'expression': 'Hello', 'from': 'GeekPython'} my_dict = f'{greet['from']} is saying {greet['expression']}.' print(my_dict) >>> SyntaxError: f-string: unmatched '[' |
Using inline comments
Expressions inside the f-strings cannot contain comments using the #
symbol, we’ll get an error.
1 2 3 4 |
name = 'geeks' print(f'Hey there, {name #this is a comment}') >>> SyntaxError: f-string expression part cannot include '#' |
Comparing the speed
As mentioned earlier, the f-strings are much faster than the other formatting methods. We can say that the letter f
in f-string stands for “fast“.
Here’s a speed comparison among f-string
, %
formatting and .format
method.
%
(modulo) operator formatting
1 2 3 4 5 6 7 8 |
import timeit duration_mod = timeit.timeit("""name = 'RDJ' hero = 'Iron Man' '%s plays the role of %s.' % (name, hero)""", number=10000) print(duration_mod) >>> 0.00748830009251833 |
str.format()
method
1 2 3 4 5 6 7 8 |
import timeit duration_format = timeit.timeit("""name = 'RDJ' hero = 'Iron Man' '{} plays the role of {}.' .format(name, hero)""", number=10000) print(duration_format) >>> 0.009640300180763006 |
f-string
1 2 3 4 5 6 7 8 |
import timeit duration_fstring = timeit.timeit("""name = 'RDJ' hero = 'Iron Man' f'{name} plays the role of {hero}.'""", number=10000) print(duration_fstring) >>> 0.0016423999331891537 |
We can clearly see the differences in the time of execution of the code for different formatting methods. Thus, we can conclude that the f-string
took less time to execute the code than the other formatting methods.
Conclusion
In this article, we learned about the f-string and its usage in the code. F-string is an improved and modern way to interpolate the string.
F-string reduces the mess in the code and increases the readability of the code and provides flexibility and control over the formatted string literal.
🏆Other articles you might like if you like this article
✅Integrate PostgreSQL database with Python and perform CRUD operations.
✅Display static and dynamic images on the frontend using Flask.
✅Tackle the shortage of data with data augmentation techniques.
✅8 Different ways you can reverse a Python list.
✅Scrape the data from the website using BeautifulSoup in Python.
That’s all for now
Keep Coding✌✌