DEV Community

Cover image for What the f-strings?
Tushar Sadhwani
Tushar Sadhwani

Posted on • Updated on

What the f-strings?

So a couple months ago, I wrote a comprehensive blog on mypy. Today I'm planning to do the same with f-strings, putting everything I know about them into a single source of knowledge. It's an awesome Python feature, and I hope you'll get to learn something new about it ✨


What is an f-string?

"f-strings" are a feature added to Python in version 3.6, and it's essentially a new, more concise way to embed values inside strings.

They're called f-strings because of the syntax: you put an f before the string literal, like so:

string = f'this is an f-string'
Enter fullscreen mode Exit fullscreen mode

Simple examples

Here's a few basic examples on how to use f-strings to get you started:

>>> name, birth_year = 'Tushar', 2000
>>> print(f'I am {name}, and I was born in {birth_year}')
I am Tushar, and I was born in 2000
>>> import datetime; now =
>>> print(f'I am {now.year - birth_year} years old')
I am 21 years old
>>> age = now.year - birth_year
>>> print(f'I am {"an adult" if age >= 18 else "a child"}.')
I am an adult.
Enter fullscreen mode Exit fullscreen mode

A brief history of string formatting

String formatting in Python dates back a long time. The original formatting using the % sign has existed in Python ever since version 1.x (and even before that in C, which is where this feature's inspiration comes from). It allowed you to do most string formatting very easily, even though the syntax was a bit unusual: it uses % flags in your string, which get replaced by the values you pass in. Here's an example:

>>> city = 'London'
>>> print('She lives in %s since %d' % (city, 2000))
She lives in London since 2000
Enter fullscreen mode Exit fullscreen mode

There's a bunch of these % patterns, and each of them has a meaning:

  • %s - String
  • %c - Character (ASCII/Unicode)
  • %d - Digits (Integer)
  • %f - Floats
  • %x - Hexadecimal number, etc.

Each of these can be modified with more information, like padding and alignment, for example:

  • %9s means a string of length 9.
  • %-7d means an integer of length 7, but left-aligned.
>>> print('%15f seconds' % 31.415926)
      31.415926 seconds
>>> print('%-15f seconds' % 31.415926)
31.415926       seconds
Enter fullscreen mode Exit fullscreen mode

Eventually, people realised that the % syntax borrowed from C might not be the most readable way to format strings. So in Python 3.0 (alongside 2.6), A new method was added to the str data type: str.format. Not only was it more obvious in what it was doing, it added a bunch of new features, like dynamic data types, center alignment, index-based formatting, and specifying padding characters. Here's a few examples:

>>> month = 'May'
>>> print('I was born in {}.'.format(month))
I was born in May
>>> blog_title = 'What the f-string?'
>>> print('{title:-^30}'.format(title=blog_title))
------What the f-string?------
>>> print('{:_<15f} seconds'.format(31.415926))
31.415926______ seconds
>>> print('{:>15f} seconds'.format(31.415926))
      31.415926 seconds
Enter fullscreen mode Exit fullscreen mode

Note that if you don't specify an alignment character using <, > or ^, it will always default to left alignment. This is different from %-formatting, as that defaults to right-alignment for numbers.

Along with str.format method, there's also a built-in format function which does the same thing.

For a lot more information about %-formatting and str.format, and all of their (many) features, head to It is very useful as a reference for the features and syntax.

Why f-strings?

One thing that you should know is that str.format() can already do (almost) everything that f-strings can do. You might be wondering then, "why were f-strings created in the firt place? And why should I care about them?"

Well, it's for two reasons:

  • it's way more intuitive, and
  • it's way more readable.

Here's a comparision:

>>> name, age = 'Mark', 31
>>> # str.format version
>>> print('Hi, I'm {0} and I'm {1} years old.'.format(name, age)
Hi, I'm Mark and I'm 31 years old.
>>> # f-string version
>>> print(f'Hi, I'm {name} and I'm {age} years old.')
Hi, I'm Mark and I'm 31 years old.
Enter fullscreen mode Exit fullscreen mode

These two properties, of being intuitive and readable, are part of the core philisophy of Python (refer The Zen of Python).

More Examples

Now, a few examples on everything that you can do with f-strings.

Padding / truncating

>>> pi = 3.141592
>>> print(f'{pi}')
>>> print(f'{pi:10}')     # padding to make length 10
>>> print(f'{pi:010}')    # padding with zeroes
>>> print(f'{pi:.3}')     # 3 digits total, ignoring decimal
>>> string = "Hello! this is a string"
>>> print(f'{string:.6}')  # 6 characters
Enter fullscreen mode Exit fullscreen mode


>>> heading = 'Test'
>>> print(f'{heading:>20}')
>>> print(f'{heading:~>20}')  # specify alignment for custom padding
>>> print(f'{heading:_<20}')
>>> print(f'{heading:=^20}')
Enter fullscreen mode Exit fullscreen mode

Rounding numbers

>>> num = 2.136
>>> print(f'{num}')
>>> print(f'{num:.3}')  # Rounded up
>>> print(f'{num:.2}')  # Rounded down
Enter fullscreen mode Exit fullscreen mode

Converting types

>>> print(f'{42:c}')       # int to ascii
>>> print(f'{604:f}')      # int to float
>>> print(f'{84:.2f}%')
>>> print(f'{604:x}')      # int to hex
>>> print(f'{604:b}')      # int to binary
>>> print(f'{604:0>16b}')  # int to binary, with zero-padding
Enter fullscreen mode Exit fullscreen mode

Adding commas to large numbers

>>> large_num = 12_345_678  # int syntax supports underscores :D
>>> print(f'{large_num}')
>>> print(f'{large_num:,}')
Enter fullscreen mode Exit fullscreen mode

Special syntax

There's a few special set of syntaxes that don't exist in the original %-formatting:

!s !r and !a

>>> from datetime import datetime
>>>                # repr value
datetime.datetime(2021, 7, 6, 2, 21, 56, 698285)
>>> print(         # str value
2021-07-06 02:22:02.772826     
>>> print(f'{}')    # str value by default
2021-07-06 02:22:14.357562
>>> print(f'{!r}')  # repr value
datetime.datetime(2021, 7, 6, 2, 22, 17, 709937)
>>> print(f'{!s}')  # str value
2021-07-06 02:22:20.081837
>>> sparkles = '✨'
>>> print(f'{sparkles}')

>>> print(f'{sparkles!a}')        # ascii-safe value
Enter fullscreen mode Exit fullscreen mode

datetime formatting

>>> from datetime import datetime
>>> print(f'{, %B %d %Y}')
Tuesday, July 06 2021
Enter fullscreen mode Exit fullscreen mode

For more info on the % codes specifically for datetime objects, check out the documentation for datetime.strftime, or check out

{x=} syntax

This is a new syntax that was added to Python 3.8, and it helps you quickly print out a variable's value, usually for debugging purposes. Essentially, f'{abc=}' is the same as f'abc={abc!r}'.

>>> x, y = 3, 5
>>> print(f'{x=}')
>>> print(f'{x = }')
x = 3
>>> x, y = y, x+y
>>> print(f'{x=} {y=}')
x=5 y=8
>>> string = 'test'.center(10, '*')
>>> print(f'{string = }')
string = '***test***'
>>> print(f'{10 * 2 = }')
10 * 2 = 20
Enter fullscreen mode Exit fullscreen mode

Nested formatting

Since we can sometimes have rather complicated format specifications, like ~^30s or 0>12,.2f, it makes sense to be able to extract those out into variables as well. And that's exactly what nested formatting lets us do.

Some things that you can do with

  • Variable length padding
>>> string = 'Python'
>>> size = 20
>>> print(f'{string:{size}}')
Enter fullscreen mode Exit fullscreen mode
  • putting in the format spec as a variable, or as multiple variables:
from math import pi

digits = int(input('Enter number of digits of pi: '))
length = int(input('Enter string length: '))
alignment = input('Enter alignment (<, > or ^): ')
padding_char = input('Enter padding character: ')
Enter fullscreen mode Exit fullscreen mode


Enter number of digits of pi: 8   
Enter string length: 30
Enter alignment (<, > or ^): ^
Enter padding character: _
Enter fullscreen mode Exit fullscreen mode

Custom formatting using __format__

You can define custom format handling in your own objects by overriding the __format__ method on the formatter object. This allows you to define (mostly) arbitrary formatting semantics.

Here's an example, with more sensible names for datetime formatting:

from datetime import datetime

class BetterDatetime(datetime):
    substitutions = {
        '%day': '%A',
        '%date': '%d',
        '%monthname': '%B',
        '%month': '%m',
        '%year': '%Y'

    def __format__(self, format_spec):
        for token, replacement in self.substitutions.items():
            format_spec = format_spec.replace(token, replacement)

        return super().__format__(format_spec)

print(f'Today is {, %date %monthname %year}')

# Output: Today is Monday, 8 July 2021
Enter fullscreen mode Exit fullscreen mode


As amazing as f-strings are, they're not the be-all and end-all of string formatting in Python. (but they come very close!)

Some nitpicks from my side about f-strings are:

  • You can't separate the string template from the data being embedded. In str.format, you can store the strings themselves as templates in a separate file, like text = '{user} has left'. Then, you can import text and use text.format(user=...). You can't do this with f-strings.

  • f-strings only work in Python 3.6+, and {x=} syntax only works in Python 3.8+

  • There's also no real replacement for the str.format_map method using f-strings.


All in all, f-strings are awesome, and everyone should use them :P

Anywho, if you have any questions or suggestions, drop them below. I'd love to hear from you ✨

Top comments (3)

anuragtech02 profile image
Anurag Pal

Well written and formatted, nice article!

brandonwallace profile image

Nice article! I love f-strings.

ps173 profile image
Pratham Sharma

great article as always... :)