f-строки: вставить значение в текст

Из урока 1 мы умеем собирать текст конкатенацией. Посмотрим, как это выглядит на практике, когда в сообщение нужно вставить пару значений:

name = 'Аня'
age = 20
message = 'Привет, ' + name + '! Тебе ' + str(age) + ' лет.'
print(message)

Привет, Аня! Тебе 20 лет.

Работает — но как читается: четыре плюса, кавычки рвут текст на части, а про str(age) легко забыть и получить TypeError. Для такой частой задачи — «вставить значения в текст» — Python предлагает инструмент получше.

f-строка: буква f и фигурные скобки

Поставь букву f перед кавычками — и строка станет f-строкой: всё, что в фигурных скобках, Python вычислит и вставит в текст. Это называется интерполяция — подстановка значений внутрь шаблона:

name = 'Аня'
age = 20
message = f'Привет, {name}! Тебе {age} лет.'
print(message)

Привет, Аня! Тебе 20 лет.

Одна строка вместо конкатенации из пяти кусков, и текст читается слева направо, как обычное предложение. Число age вставилось без всякого str() — f-строка конвертирует значения сама. Фигурные скобки при этом исчезают: на их месте оказывается вычисленное значение.

Внутри скобок работает любое выражение

Главное, что делает f-строки мощными: в фигурных скобках стоит не «имя переменной», а любое выражение Python. Сумма, вызов метода, обращение к элементу списка — всё вычисляется прямо внутри строки:

prices = [120, 80, 45]
name = 'питон'
print(f'Сумма: {sum(prices)}')
print(f'Кричим: {name.upper()}!')
print(f'Длина: {len(name)} букв')

Сумма: 245
Кричим: ПИТОН!
Длина: 5 букв

sum(prices) посчитал сумму списка, name.upper() крикнул заглавными, len(name) посчитал буквы — и всё это без единой промежуточной переменной. Арифметика тоже работает:

ticket = 350
count = 3
print(f'{count} билета стоят {ticket * count} руб.')

3 билета стоят 1050 руб.

name = 'Аня'
print('Привет, {name}!')

Привет, {name}!

Почему f-строки — стандарт

До f-строк в Python жили два способа: метод format() и старый процентный стиль %s. F-строки появились в Python 3.6 и быстро вытеснили оба — вот почему:

• читаемость: шаблон читается слева направо как обычный текст, значения видны на своих местах, а не в конце строки аргументов;
• выражения внутри: {sum(prices)} считает на месте — format() заставляет выносить вычисления в аргументы;
• скорость: f-строки быстрее format() и процентов — интерпретатор собирает строку эффективнее;
• краткость: ни плюсов, ни str(), ни индексов-подстановок вроде {0} — только текст и скобки.

Старые способы никуда не делись: чужой код с format() и %s встречается постоянно, их разбор — в уроке 12. Но в новом коде стандарт — f-строки.

Сценарий: письмо клиенту

В боте интернет-магазина каждое письмо собирается из трёх-четырёх кусков: имя клиента, номер заказа, сумма и дата. С конкатенацией такая сборка выглядит тремя строками кода, а в шаблоне письма — ещё и мучительными склейками на каждом абзаце. С f-строками шаблон читается как обычный текст, в котором просто стоят значения.

name = 'Анна'
order_id = 'ORD-2026-0042'
total = 2450.50

letter = f'Здравствуйте, {name}! Заказ {order_id} на сумму {total:.2f} руб. ждёт оплаты.'
print(letter)

Здравствуйте, Анна! Заказ ORD-2026-0042 на сумму 2450.50 руб. ждёт оплаты.

Что именно делает буква f

Буква f не меняет строку — она меняет то, как Python её собирает. Обычная строка со скобками остаётся текстом, а f-строка разбирается на части: текстовые куски идут в результат как есть, а на месте каждой пары фигурных скобок появляется значение выражения, которое внутри них стоит. Сами скобки в результате не остаются.

И сразу важное следствие: f-строка — не объект-шаблон, который можно переиспользовать с другими данными. Подставив значения, она становится обычной строкой. Для переиспользуемого шаблона нужен метод format — о нём отдельный урок.

Скобки внутри скобок: как вставить фигурные

Иногда в тексте нужны собственные фигурные скобки — например, заготовка с плейсхолдером для стороннего сервиса или пример синтаксиса JSON. Внутри f-строки двойные скобки экранируются: {{ превращается в {, а }} — в }.

print(f'{{name}} — это имя переменной')
print(f'{{{1 + 2}}}')

{name} — это имя переменной
{3}

Подстановка из словаря

Значения часто лежат в словаре, и доставать их прямо в скобках f-строки удобнее, чем писать user['city'] заранее отдельной строкой. Работает и так, и так — просто первый вариант короче и не плодит промежуточных переменных.

user = {'name': 'Анна', 'city': 'Казань'}
print(f"Клиент из {user['city']}")

Клиент из Казань

Шесть строк таблицы — это шесть способов наполнить скобки, но все они работают по одному правилу: внутри фигурных скобок Python ждёт выражение, а не имя. Как только вы это поняли, вопросов больше не остаётся.

prices = [120, 80, 45]
print(f'Первая цена: {prices[0]} руб.')

Первая цена: 120 руб.

Двоеточие после значения

Иногда значение нужно не просто вставить, а оформить: цену — с двумя знаками после точки, число — с разделителями тысяч. Для этого после выражения ставится двоеточие и формат-спецификация — короткий код, который говорит, как оформить значение:

prices = [120, 80, 45]
avg = sum(prices) / len(prices)
print(f'Средняя: {avg}')
print(f'Средняя: {avg:.2f}')

Средняя: 81.66666666666667
Средняя: 81.67

Первая строка честно показала весь бесконечный хвост деления, вторая — оформила число до двух знаков. Спецификация {avg:.2f} читается так: значение avg оформи как число с плавающей точкой (f) с двумя знаками после точки (.2). Это целая мини-грамматика — точность, ширина, выравнивание, знаки, — и ей посвящён урок 4.

Мини-практика: шаблон чека

Соберём маленький чек целиком: номер заказа, клиент, состав заказа и итог с двумя знаками. Обратите внимание на две разные склейки: позиции списка собираются через join, а всё остальное подставляется в f-строку.

order_id = 'ORD-2026-0042'
client = 'Анна'
items = ['чай', 'кофе']
total = 2450.5

print(f'Заказ {order_id}')
print(f'Клиент: {client}')
print('Состав: ' + ', '.join(items))
print(f'Итого: {total:.2f} руб.')

Заказ ORD-2026-0042
Клиент: Анна
Состав: чай, кофе
Итого: 2450.50 руб.

Почему f-строка быстрее — и где она дороже

Замеры на одном и том же шаблоне дают разницу в десятки процентов: format() разбирает шаблон заново при каждом вызове, а f-строка разбирается один раз — при компиляции файла. На коротких примерах разницу не видно, и это нормально: выигрыш становится заметен, когда шаблон собирают в цикле десятки тысяч раз.

До версии 3.12 f-строка внутри собиралась через механизм format, и часть выигрыша терялась. Начиная с 3.12 (PEP 701) у f-строк собственный компилятор — на новых версиях они ощутимо быстрее предшественников.

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

Три правила, из которых следует всё остальное

Буква f перед кавычками — иначе скобки останутся текстом. Внутри скобок — любое выражение Python, а не только имя переменной. Двоеточие после выражения — и включается оформление значения. Всё, что мы разобрали дальше, — частные случаи этих трёх правил. Дальше по разделу: разобрать готовый текст на части поможет split из урока 9, а собрать строку из кусков — join из урока 10.

f-строка — это шаблон: буква f перед кавычками, значения в фигурных скобках, любое выражение Python вычисляется прямо внутри текста.