Python f-strings or formatted strings are the new way to format strings. This feature was introduced in Python 3.6 under PEP-498. It’s also called literal string interpolation.
Python provides various ways to format a string. Let’s quickly look at them and what are the issues they have.
% formatting - great for simple formatting but limited support for strings, ints, doubles only. We can’t use it with objects.
Template Strings - it’s very basic. Template strings work with keyword arguments like dictionary only. We are not allowed to call any function and arguments must be strings.
String format() - Python String format() function was introduced to overcome the issues and limited features of %-formatting and template strings. However, it’s too verbose. Let’s look at its verbosity with a simple example.
>>> age = 4 * 10
>>> 'My age is {age}.'.format(age=age)
'My age is 40.'
Python f-strings works almost similar like format() function but removes all the verbosity that format() function has. Let’s see how easily we can format the above string using f-strings.
>>> f'My age is {age}'
'My age is 40.'
Python f-strings is introduced to have minimal syntax for string formatting. The expressions are evaluated at runtime. If you are using Python 3.6 or higher version, you should use f-strings for all your string formatting requirements.
Let’s look at a simple example of f-strings.
name = 'Pankaj'
age = 34
f_string = f'My Name is {name} and my age is {age}'
print(f_string)
print(F'My Name is {name} and my age is {age}') # f and F are same
name = 'David'
age = 40
# f_string is already evaluated and won't change now
print(f_string)
Output:
My Name is Pankaj and my age is 34
My Name is Pankaj and my age is 34
My Name is Pankaj and my age is 34
Python executes statements one by one and once f-string expressions are evaluated, they don’t change even if the expression value changes. That’s why in the above code snippets, f_string value remains same even after ‘name’ and ‘age’ variable has changed in the latter part of the program.
We can use f-strings to convert datetime to a specific format. We can also run mathematical expressions in f-strings.
from datetime import datetime
name = 'David'
age = 40
d = datetime.now()
print(f'Age after five years will be {age+5}') # age = 40
print(f'Name with quotes = {name!r}') # name = David
print(f'Default Formatted Date = {d}')
print(f'Custom Formatted Date = {d:%m/%d/%Y}')
Output:
Age after five years will be 45
Name with quotes = 'David'
Default Formatted Date = 2018-10-10 11:47:12.818831
Custom Formatted Date = 10/10/2018
We can create raw strings using f-strings too.
print(f'Default Formatted Date:\n{d}')
print(fr'Default Formatted Date:\n {d}')
Output:
Default Formatted Date:
2018-10-10 11:47:12.818831
Default Formatted Date:\n 2018-10-10 11:47:12.818831
We can access object attributes too in f-strings.
class Employee:
id = 0
name = ''
def __init__(self, i, n):
self.id = i
self.name = n
def __str__(self):
return f'E[id={self.id}, name={self.name}]'
emp = Employee(10, 'Pankaj')
print(emp)
print(f'Employee: {emp}\nName is {emp.name} and id is {emp.id}')
Output:
E[id=10, name=Pankaj]
Employee: E[id=10, name=Pankaj]
Name is Pankaj and id is 10
We can call functions in f-strings formatting too.
def add(x, y):
return x + y
print(f'Sum(10,20) = {add(10, 20)}')
Output: Sum(10,20) = 30
If there are leading or trailing whitespaces in the expression, they are ignored. If the literal string part contains whitespaces then they are preserved.
>>> age = 4 * 20
>>> f' Age = { age } '
' Age = 80 '
We can use lambda expressions insidef-string expressions too.
x = -20.45
print(f'Lambda Example: {(lambda x: abs(x)) (x)}')
print(f'Lambda Square Example: {(lambda x: pow(x, 2)) (5)}')
Output:
Lambda Example: 20.45
Lambda Square Example: 25
Let’s look at some miscellaneous examples of Python f-strings.
print(f'{"quoted string"}')
print(f'{{ {4*10} }}')
print(f'{{{4*10}}}')
Output:
quoted string
{ 40 }
{40}
That’s all for python formatted strings aka f-strings.
You can checkout complete python script and more Python examples from our GitHub Repository.
Reference: PEP-498, Official Documentation
Thanks for learning with the DigitalOcean Community. Check out our offerings for compute, storage, networking, and managed databases.
While we believe that this content benefits our community, we have not yet thoroughly reviewed it. If you have any suggestions for improvements, please let us know by clicking the “report an issue“ button at the bottom of the tutorial.
Sign up for Infrastructure as a Newsletter.
Working on improving health and education, reducing inequality, and spurring economic growth? We'd like to help.
Get paid to write technical tutorials and select a tech-focused charity to receive a matching donation.
Hi Pankaj, I can’t seem to use logging module along with f-string formatting. I get an pylint error: use lazy % formatting in logging (logging-fstring-interpolation) I’m unable to figure out the right reason for it. Any suggestions?
- Srivatsava Guduri
Great codes you write!
- Parakshit