How to use f-strings in Python | note.nkmk.me (2024)

Python 3.6 introduced a new feature, known as formatted string literals, or f-strings, to simplify the use of the string method format().

Contents

  • Basic usage of f-strings
  • Format specifications
    • Left-justify, center, right-justify
    • Zero-padding
    • Separator
    • Binary, octal, and hexadecimal representation
    • Decimal places and significant digits
    • Scientific notation
    • Percentage
    • Date and time (datetime)
  • Braces (curly brackets) {}
  • Nested replacement fields
  • Raw strings and f-strings
  • Difference between the format() method and f-strings
    • Expressions
    • How to specify dictionary keys
  • The = specifier in f-strings (Python 3.8 and later)

For a detailed overview of the string method format(), the built-in function format(), and format specification strings, refer to the following article.

  • Format strings and numbers with format() in Python

Basic usage of f-strings

The format() method inserts values into the replacement field {} using positional or keyword arguments.

a = 123b = 'abc'print('{} and {}'.format(a, b))# 123 and abcprint('{first} and {second}'.format(first=a, second=b))# 123 and abc

source: f_strings.py

An f-string is a string literal prefixed with f or F, like f'...' or F'...'. It allows you to specify variables directly in the replacement field {}.

print(f'{a} and {b}')# 123 and abcprint(F'{a} and {b}')# 123 and abc

source: f_strings.py

Like regular string literals, f-strings can use single quotes '', double quotes "", and triple quotes ''', """.

  • Create a string in Python (single/double/triple quotes, str())
print(f"{a} and {b}")# 123 and abcprint(f'''{a} and {b}''')# 123 and abcprint(f"""{a} and {b}""")# 123 and abc

source: f_strings.py

Format specifications

As with the format() method, f-strings can specify a variety of formats by adding a format specification string after the colon : in {}.

Some examples are shown here. For more information, refer to the following article.

  • Format strings and numbers with format() in Python

Left-justify, center, right-justify

s = 'abc'print(f'right : {s:*>8}')print(f'center: {s:*^8}')print(f'left : {s:*<8}')# right : *****abc# center: **abc***# left : abc*****

source: f_strings.py

Zero-padding

i = 1234print(f'zero padding: {i:08}')# zero padding: 00001234

source: f_strings.py

Separator

Binary, octal, and hexadecimal representation

i = 255print(f'bin : {i:b}')print(f'oct : {i:o}')print(f'hex(lower): {i:x}')print(f'hex(upper): {i:X}')# bin : 11111111# oct : 377# hex(lower): ff# hex(upper): FFprint(f'bin : {i:08b}')print(f'oct : {i:08o}')print(f'hex(lower): {i:08x}')print(f'hex(upper): {i:08X}')# bin : 11111111# oct : 00000377# hex(lower): 000000ff# hex(upper): 000000FFprint(f'bin : {i:#010b}')print(f'oct : {i:#010o}')print(f'hex(lower): {i:#010x}')print(f'hex(upper): {i:#010X}')# bin : 0b11111111# oct : 0o00000377# hex(lower): 0x000000ff# hex(upper): 0X000000FF

source: f_strings.py

Decimal places and significant digits

f = 12.3456print(f'decimal places : {f:.3f}')print(f'significant digits: {f:.3g}')# decimal places : 12.346# significant digits: 12.3

source: f_strings.py

Scientific notation

f = 12.3456print(f'exponent(lower): {f:.3e}')print(f'exponent(upper): {f:.3E}')# exponent(lower): 1.235e+01# exponent(upper): 1.235E+01

source: f_strings.py

Percentage

f = 0.123print(f'percent: {f:.2%}')# percent: 12.30%

source: f_strings.py

Date and time (datetime)

import datetimedt = datetime.datetime(2020, 1, 5, 20, 15, 30)print(f'datetime: {dt}')# datetime: 2020-01-05 20:15:30print(f'datetime: {dt:%A, %m/%d/%Y %I:%M:%S %p}')# datetime: Sunday, 01/05/2020 08:15:30 PMprint(f'datetime: {dt.isoformat()}')# datetime: 2020-01-05T20:15:30

source: f_strings.py

For more information on the datetime module, see the following article.

  • Handle date and time with the datetime module in Python

As in the last example, it is easier to use the isoformat() method than to specify format codes when converting to ISO 8601 format.

  • Convert between isoformat string and datetime in Python

Braces (curly brackets) {}

To include braces { and } in f-strings, double them like {{ and }}. Note that the backslash \ cannot be used.

n = 123print(f'{{}}-{n}-{{{n}}}')# {}-123-{123}

source: f_strings.py

Nested replacement fields

Similar to the format() method, f-strings allow replacement fields within other replacement fields. The number in the format specification string can be a variable.

n = 123i = 8print('{n:0{i}}'.format(n=n, i=i))# 00000123print(f'{n:0{i}}')# 00000123

You could also write:

f = 1.2345for i in range(5): print(f'{f:.{i}f}')# 1# 1.2# 1.23# 1.234# 1.2345

source: f_strings.py

Raw strings and f-strings

In regular strings, backslash \ represents special characters. However, when a string is prefixed with r or R, creating a raw string literal, backslash escapes are disregarded.

  • Raw strings in Python
print('x\ty')# x yprint(r'x\ty')# x\ty

source: f_strings.py

If you prefix a string with both r and f, it will be treated as both a raw string and an f-string. The order of r and f doesn't matter, and you can use either lowercase or uppercase letters.

x = 'XXX'y = 'YYY'print(f'{x}\t{y}')# XXX YYYprint(rf'{x}\t{y}')# XXX\tYYYprint(FR'{x}\t{y}')# XXX\tYYY

source: f_strings.py

Difference between the format() method and f-strings

Expressions

With the format() method, expressions cannot be included in the replacement field.

a = 3b = 4# print('{a} + {b} = {a + b}'.format(a=a, b=b))# KeyError: 'a + b'

source: f_strings.py

In contrast, f-strings allow the use of expressions within the replacement field. It is also possible to specify a format specification string for the outcome of the expression.

print(f'{a} + {b} = {a + b}')# 3 + 4 = 7print(f'{a} * {b} = {a * b}')# 3 * 4 = 12print(f'{a} / {b} = {a / b:.2e}')# 3 / 4 = 7.50e-01

source: f_strings.py

How to specify dictionary keys

When using a dictionary (dict) in a replacement field, the format() method does not require the key to be surrounded by ' or ".

d = {'key1': 10, 'key2': 20}print('{0[key1]}, {0[key2]}'.format(d))# 10, 20# print('{0["key1"]}, {0["key2"]}'.format(d))# KeyError: '"key1"'

source: f_strings.py

However, f-strings require the key to be enclosed in ' or ".

print(f'{d["key1"]}, {d["key2"]}')# 10, 20# print(f'{d[key1]}, {d[key2]}')# NameError: name 'key1' is not defined

source: f_strings.py

Like regular strings, you cannot use the same quotation marks within the string as the ones enclosing the entire string. For example, if the whole string is enclosed in ", use ' inside.

# print(f'{d['key1']}, {d['key2']}')# SyntaxError: invalid syntaxprint(f"{d['key1']}, {d['key2']}")# 10, 20

source: f_strings.py

Note that backslash escaping cannot be used within a replacement field.

# print(f'{d[\'key1\']}, {d[\'key2\']}')# SyntaxError: f-string expression part cannot include a backslash

source: f_strings.py

The = specifier in f-strings (Python 3.8 and later)

From Python 3.8, f-strings support an = specifier, which prints both variable names and their corresponding values.

i = 123print(f'{i=}')# i=123

source: f_strings.py

If you place a space before or after the variable name and =, it will be preserved in the output.

print(f'{i = }')# i = 123print(f'{ i = }')# i = 123

source: f_strings.py

You can also specify format specification strings and expressions with the = specifier.

print(f'{i = :#b}')# i = 0b1111011print(f'{i * 2 = }')# i * 2 = 246

source: f_strings.py

This also applies to lists and dictionaries.

l = [0, 10, 20]print(f'{l = }, {l[1] = }')# l = [0, 10, 20], l[1] = 10d = {'key1': 10, 'key2': 20}print(f'{d = }, {d["key1"] = }')# d = {'key1': 10, 'key2': 20}, d["key1"] = 10

source: f_strings.py

How to use f-strings in Python | note.nkmk.me (2024)

FAQs

How do you do F-strings in Python? ›

To use formatted string literals, begin a string with f or F before the opening quotation mark or triple quotation mark. Inside this string, you can write a Python expression between { and } characters that can refer to variables or literal values.

Should you use f-strings in Python? ›

Using f-strings, your code will not only be cleaner but also faster to write. With f-strings you are not only able to format strings but also print identifiers along with a value (a feature that was introduced in Python 3.8).

How are F-strings implemented in Python? ›

In Python source code, an f-string is a literal string, prefixed with 'f', which contains expressions inside braces. The expressions are replaced with their values. Some examples are: >>> import datetime >>> name = 'Fred' >>> age = 50 >>> anniversary = datetime.

How do you use .2f in Python? ›

The format specifier . 2f states that we want to display 2 decimals. The letter f at the end means that we want the variable to be displayed as a float , i.e. a floating point number. You can think of an f-string as a sort of function, which creates a normal string based on the "arguments" within the curly brackets.

Can we use F-string in dictionary Python? ›

Python 3.6+ has introduced f-strings support in which keys of a dictionary can be used to format a string. In this approach, you need to place the f prefix before the string and place the key of the dictionary inside the curly braces { }.

How do you use quotes in F-string in Python? ›

We can use any quotation marks {single or double or triple} in the f-string. We have to use the escape character to print quotation marks. The f-string expression doesn't allow us to use the backslash. We have to place it outside the { }.

What can I use instead of F-string in Python? ›

Python has several tools for string interpolation that support many formatting features. In modern Python, you'll use f-strings or the .format() method most of the time. However, you'll see the modulo operator ( % ) being used in legacy code.

What are the disadvantages of F-strings? ›

From the user's perspective, the current f-string implementation imposes some limitations:
  • Reusing quotes or string delimiters isn't possible.
  • Embedding backslashes isn't possible, which means you can't use escape characters.
  • Adding inline comments is forbidden.
Jul 26, 2023

Why are F-strings faster? ›

Conciseness: F-strings provide a concise syntax for string formatting, reducing the amount of code required compared to other methods.

When did Python add f-strings? ›

Python f-strings or formatted strings are the new way to format strings. This feature was introduced in Python 3.6 under PEP-498.

Can you use F-strings in logging Python? ›

Using f-strings to format a logging message requires that Python eagerly format the string, even if the logging statement is never executed (e.g., if the log level is above the level of the logging statement), whereas using the extra keyword argument defers formatting until required.

How to round a number in Python f-string? ›

Rounding Numbers With F-Strings

F-strings can also be used to round numbers to a specific precision, using the round() function. To round a number using f-strings, simply include the number inside the curly braces, followed by a colon and the number of decimal places to round to.

What is {: 2f}? ›

Explanation: format() method is called on the float value, specifying '{:.2f}' as the format specifier. {:.2f} format specifier indicates that the float should be formatted with two decimal places. The formatted value is stored in formatted_value. Finally, print() function is used to display the formatted value.

How to use 0.2 f in Python? ›

%f is for floats. 02:01 In addition to the indicator, you can also put formatting information. The 0.2 here tells Python to put as many digits to the left of the decimal as you like, but only 2 significant digits to the right. 02:15 This formatting will work in more than just floats.

How to use .1f in Python? ›

For instance, if we want to display a floating-point number with one decimal place, we can use :. 1f inside the braces and after the expression.

What is the F-string concatenation in Python? ›

Concatenating Strings in Python Using f-Strings

Python f-strings are prefixed by the letter f and allow you to place variables to interpolate into square brackets. The variables are evaluated at run-time, and their string representation is placed into the string. print(f'Welcome to {website}!' )

How do you make an F-string have no new line in Python? ›

Using Backslashes

The backslashes tell Python to ignore the newline characters in the code and join the f-strings into one single line. Using backslashes, you can create multiline strings with f-strings without having to use triple quotes or escape characters. This can make your code more compact and efficient.

How to type string in Python? ›

Assigning a string in Python is done by enclosing the text within either single quotes (' '), double quotes (" "), or triple quotes (''' ''' or """ """).

Top Articles
Latest Posts
Article information

Author: Wyatt Volkman LLD

Last Updated:

Views: 6234

Rating: 4.6 / 5 (46 voted)

Reviews: 93% of readers found this page helpful

Author information

Name: Wyatt Volkman LLD

Birthday: 1992-02-16

Address: Suite 851 78549 Lubowitz Well, Wardside, TX 98080-8615

Phone: +67618977178100

Job: Manufacturing Director

Hobby: Running, Mountaineering, Inline skating, Writing, Baton twirling, Computer programming, Stone skipping

Introduction: My name is Wyatt Volkman LLD, I am a handsome, rich, comfortable, lively, zealous, graceful, gifted person who loves writing and wants to share my knowledge and understanding with you.