f-строки в Python: форматирование строк

f-строка в Python — это строковый литерал с буквой f перед кавычками, внутри которого в фигурных скобках можно писать переменные и выражения. Короткий ответ: чтобы вставить переменную в строку, напишите f"Привет, {name}!" — Python подставит значение name. После двоеточия задаётся формат: f"{price:.2f}" выведет число с двумя знаками после точки.

f-строки появились в Python 3.6 (PEP 498). Запись получается короче, чем с format() и оператором %, а значения стоят прямо там, где появятся в тексте. Ниже — выражения внутри f-строк, форматирование чисел и дат, выравнивание, отладочный спецификатор =, работа с кавычками и типичные ошибки. Примеры проверены на Python 3.12.

Как вставить переменную в строку

name = "Анна"
age = 30
print(f"Меня зовут {name}, мне {age} лет")  # → Меня зовут Анна, мне 30 лет
print("Меня зовут {name}")                  # → Меня зовут {name}

Без префикса f фигурные скобки остаются обычным текстом. Префикс можно писать и заглавной буквой F, и с любыми кавычками: f'...', f"...", f"""...""". Тип переменной не важен — число, список или объект будут преобразованы в строку автоматически.

Сравнение со старыми способами

Ту же строку можно собрать ещё тремя способами:

print("Меня зовут " + name + ", мне " + str(age) + " лет")  # конкатенация
print("Меня зовут {}, мне {} лет".format(name, age))         # str.format
print("Меня зовут %s, мне %d лет" % (name, age))             # оператор %

Все три выведут то же самое, но конкатенация требует ручного str() для чисел, а format() и % разносят шаблон и значения по разным местам строки. Метод format() по-прежнему полезен, когда шаблон хранится отдельно от данных — например, в настройках: "Привет, {name}!".format(name="Олег").

Выражения внутри фигурных скобок

В скобках может стоять любое выражение Python: арифметика, вызов метода или функции, обращение к элементу списка и словаря, условное выражение.

price = 250
qty = 3
print(f"Итого: {price * qty} ₽")                  # → Итого: 750 ₽
print(f"{name.upper()} — {len(name)} буквы")      # → АННА — 4 буквы

items = ["кофе", "чай"]
print(f"Первый: {items[0]}, всего: {len(items)}") # → Первый: кофе, всего: 2

user = {"name": "Иван", "role": "admin"}
print(f"{user['name']} ({user['role']})")         # → Иван (admin)
print(f"{'взрослый' if age >= 18 else 'ребёнок'}")  # → взрослый

Не перегружайте f-строку логикой: если выражение длинное, вычислите его в отдельной переменной.

Форматирование чисел

Формат указывается после двоеточия: {значение:спецификатор}. Самые нужные спецификаторы:

pi = 3.14159265
print(f"{pi:.2f}")          # → 3.14         (2 знака после точки)
print(f"{pi:.0f}")          # → 3            (округление до целого)

big = 1234567.891
print(f"{big:,.2f}")        # → 1,234,567.89 (разделитель тысяч)
print(f"{big:_.2f}")        # → 1_234_567.89
print(f"{big:,.2f}".replace(",", " "))  # → 1 234 567.89

print(f"{0.256:.1%}")       # → 25.6%        (процент: умножает на 100)
print(f"{1234567:.2e}")     # → 1.23e+06     (экспоненциальная запись)

n = 7
print(f"{n:03d}")           # → 007          (ведущие нули)
print(f"{5:+d}")            # → +5           (всегда показывать знак)
print(f"{255:b} {255:o} {255:x} {255:#x}")  # → 11111111 377 ff 0xff

Округление в формате .0f идёт по банковскому правилу, как у round(): f"{2.5:.0f}" даст '2', а f"{3.5:.0f}" — '4'. Разделитель тысяч в виде пробела, принятый в русском тексте, получают заменой запятой, как в примере выше.

Таблица спецификаторов формата

Спецификатор	Значение	Пример	Результат
.2f	число с 2 знаками после точки	f"{3.14159:.2f}"	3.14
, или _	разделитель тысяч	f"{1234567:,}"	1,234,567
%	процент	f"{0.256:.1%}"	25.6%
e	экспоненциальная запись	f"{1234567:.2e}"	1.23e+06
03d	целое, ширина 3, ведущие нули	f"{7:03d}"	007
+	знак у положительных чисел	f"{5:+d}"	+5
b, o, x	двоичная, восьмеричная, шестнадцатеричная	f"{255:x}"	ff
<10, >10, ^10	выравнивание влево, вправо, по центру	f"[{'py':^8}]"	[ py ]
*^10	выравнивание с символом-заполнителем	f"{'py':*^8}"	***py***
%d.%m.%Y	формат даты для datetime	f"{dt:%d.%m.%Y}"	09.10.2026

Полный синтаксис описан в разделе Format Specification Mini-Language документации. Тот же язык понимают str.format() и встроенная функция format(): format(3.14159, ".3f") вернёт '3.142'.

Выравнивание и таблицы

Число после символа выравнивания — ширина поля. Строки по умолчанию прижимаются влево, числа — вправо:

print(f"[{'py':<8}]")    # → [py      ]
print(f"[{'py':>8}]")    # → [      py]
print(f"[{'py':^8}]")    # → [   py   ]
print(f"[{42:>6}]")      # → [    42]
print(f"[{3.14159:>8.2f}]")  # → [    3.14]

Так удобно выводить ровные колонки:

rows = [("Кофе", 250), ("Чай", 180), ("Сок", 1220)]
for title, cost in rows:
    print(f"{title:<10}{cost:>6} ₽")

Кофе         250 ₽
Чай          180 ₽
Сок         1220 ₽

Ширину и точность можно передать переменными через вложенные скобки:

width = 10
precision = 3
print(f"[{pi:{width}.{precision}f}]")  # → [     3.142]

Даты в f-строках

Объекты datetime понимают те же коды, что и метод strftime():

from datetime import datetime

dt = datetime(2026, 10, 9, 14, 30)
print(f"{dt:%d.%m.%Y %H:%M}")  # → 09.10.2026 14:30
print(f"{dt:%Y-%m-%d}")        # → 2026-10-09

Подробнее о датах и форматах — в статье о модуле datetime.

Отладка: спецификатор =

С Python 3.8 знак = после выражения выводит и само выражение, и его значение — удобно для отладочного print:

x = 10
y = 3
print(f"{x=}")            # → x=10
print(f"{x / y=:.2f}")    # → x / y=3.33
print(f"{x + y = }")      # → x + y = 13
print(f"{name=}")         # → name='Анна'

Пробелы вокруг = сохраняются в выводе. Для строк значение показывается в кавычках, как у repr().

Преобразования !r, !s и !a

После выражения можно указать, какое представление использовать: !s — str() (по умолчанию), !r — repr(), !a — ascii():

s = "текст"
print(f"{s}")    # → текст
print(f"{s!r}")  # → 'текст'
print(f"{s!a}")  # → '\u0442\u0435\u043a\u0441\u0442'

!a заменяет все символы вне ASCII, в том числе кириллицу, escape-последовательностями. !r полезен в логах и сообщениях об ошибках: по кавычкам сразу видно пустую строку или лишние пробелы.

Фигурные скобки, кавычки и многострочные f-строки

Чтобы вывести саму фигурную скобку, удвойте её:

print(f"{{name}} = {name}")  # → {name} = Анна
print(f"{{{name}}}")         # → {Анна}

В Python 3.12 f-строки стали полноценной частью грамматики (PEP 701): внутри выражения можно использовать те же кавычки, что и снаружи, и обратную косую черту:

print(f"{user["name"]}")         # Python 3.12+ → Иван
print(f"{'\n'.join(items)}")     # Python 3.12+ → кофе и чай на отдельных строках

В Python 3.11 и раньше первая строка вызовет SyntaxError: f-string: unmatched '[', а вторая — SyntaxError: f-string expression part cannot include a backslash. Если код должен работать на старых версиях, используйте внутри другие кавычки (user['name']) и вынесите выражение с \n в переменную. Проверить версию интерпретатора поможет статья о том, как узнать версию Python.

Длинную строку удобно разбить на части в скобках — соседние литералы склеиваются, и каждый из них должен иметь префикс f:

total = 750
report = (
    f"Клиент: {name}\n"
    f"Сумма: {total:.2f} ₽"
)
print(report)

Клиент: Анна
Сумма: 750.00 ₽

Тройные кавычки f"""...""" тоже работают и сохраняют переводы строк.

Частые ошибки

Забыли букву f

"Привет, {name}" без префикса выводит фигурные скобки как есть. Если в выводе видны { и имя переменной — проверьте префикс.

ValueError: Unknown format code ‘d’ for object of type ‘float’

Спецификатор не подходит к типу значения: d работает только с целыми, f — только с числами.

print(f"{3.7:d}")       # → ValueError: Unknown format code 'd' for object of type 'float'
print(f"{'3.7':.1f}")   # → ValueError: Unknown format code 'f' for object of type 'str'
print(f"{float('3.7'):.1f}")  # → 3.7

Значения из input() и файлов — строки; преобразуйте их в число до форматирования. Подробнее — в статье о преобразовании строки в число.

SyntaxError из-за кавычек

Код вида f"{user["name"]}" работает только в Python 3.12+. На сервере со старой версией используйте разные кавычки снаружи и внутри.

f-строки в логах и SQL

В logging принято передавать аргументы отдельно — logger.info("Пользователь %s вошёл", name): строка соберётся, только если сообщение действительно будет записано. А SQL-запросы никогда не собирайте через f-строки из пользовательских данных — это открывает путь SQL-инъекциям. Передавайте значения параметрами запроса или используйте ORM.

Частые вопросы

Можно ли подготовить f-строку заранее и заполнить позже?

Нет: f-строка вычисляется в момент выполнения строки кода, и переменные должны уже существовать. Если шаблон хранится отдельно (в настройках, файле, базе), используйте str.format() или string.Template:

template = "Привет, {name}!"
print(template.format(name="Олег"))  # → Привет, Олег!

Не передавайте в format() шаблоны, которые пишут пользователи: через поля вроде {obj.attr} они могут прочитать атрибуты переданных объектов.

Что такое t-строки в Python 3.14?

Это шаблонные строки с префиксом t (PEP 750). Синтаксис как у f-строки, но результат — объект Template из модуля string.templatelib, а не готовая строка. Части текста и подставленные значения хранятся отдельно, и библиотека может их обработать, например экранировать HTML или SQL:

name = "Анна"
tpl = t"Привет, {name}!"
print(type(tpl).__name__)  # → Template
print(tpl.strings)         # → ('Привет, ', '!')
print(tpl.values)          # → ('Анна',)

Как вывести число без лишних нулей после точки?

Спецификатор g убирает незначащие нули, а с точностью .3g ограничивает общее число значащих цифр:

print(f"{3.10:g} {2.0:g} {0.125:g}")  # → 3.1 2 0.125
print(f"{3.14159:.3g}")              # → 3.14

Для очень больших и очень маленьких чисел g переходит к экспоненциальной записи.

Как вывести знак процента в f-строке?

Просто напишите % в тексте: удваивать его нужно только в форматировании через оператор %. Если значение — доля от единицы, спецификатор % сам умножит его на 100:

x = 25
print(f"Готово на {x}%")  # → Готово на 25%
print(f"{0.25:.0%}")      # → 25%

Бывают ли f-строки для байтов?

Нет, префикс fb или bf вызывает SyntaxError. Соберите обычную f-строку и закодируйте её: f"id={user_id}".encode("utf-8"). Для байтов также работает старое форматирование через %: b"id=%d" % 42.

Итог

f-строка f"...{выражение:формат}..." — самый короткий способ вставить переменную в строку и отформатировать число, дату или колонку таблицы. Запомните .2f, ,, 03d, выравнивание <, >, ^ и отладочный = — этого хватает для большинства задач. Больше о работе с текстом — в статье о строках в Python, а остальной синтаксис собран в шпаргалке по Python.