Курс Python → Функция format() в Python

Знаете, когда нужно вывести в консоль что-то вроде «Привет, [имя пользователя]! Тебе [возраст] лет!»? Если просто склеивать строки, получается какой-то бардак. Особенно, когда там числа, которые надо сначала в строку перевести. Вот тут-то и приходит на помощь форматирование строк в Python. Это такая штука, которая помогает делать строки читаемыми и динамичными. Как будто ты строишь конструктор из кубиков — берешь нужные детали и ставишь их на место. А главные герои тут — метод format() и, конечно, супер-удобные f-строки. Они реально упрощают жизнь, если хочешь, чтобы вывод был красивым и понятным.

Кстати, мы в Marketello тоже любим, когда все четко и по делу. Ведь наша задача — помогать вам осваивать нужные навыки, будь то Google Analytics или вот, например, грамотное представление данных. Мы работаем онлайн по всей России и СНГ, чтобы вы могли учиться из Москвы, Питера, Новосибирска или любого другого города. Если интересно, как мы помогаем маркетологам и владельцам бизнеса становиться круче, заходите на marketello.org.

Основы метода format()

Метод format() — это такой универсальный солдатик для форматирования строк. Работает он очень просто: ты пишешь строку, а внутри ставишь фигурные скобки {}. Эти скобки — как окошки, куда потом вставляются твои данные. Ну, типа, вместо {} подставится одно значение, вместо следующего {} — другое. И вот тебе, пожалуйста, готовая строка!

Синтаксис выглядит так: "строка с {} и {}".format(значение1, значение2). Все, что внутри фигурных скобок, называется плейсхолдерами. Можно просто ставить скобки, а Python сам поймет, какое значение куда подставить, ну, по порядку. А еще можно указывать номера: "{1} и {0}".format(значение0, значение1). Это называется позиционные аргументы. Или вообще давать им имена: "{имя} и {возраст}".format(имя="Маша", возраст=25). Это именованные аргументы. Круто, правда? Главное, что format() всегда возвращает новую строку, ничего в оригинале не меняет.

Простые примеры format()

Давайте посмотрим, как это реально работает. Представьте, у нас есть переменная с именем и переменная с возрастом:

name = "Алексей"

age = 30

Теперь хотим вывести строку «Привет, Алексей! Тебе 30 лет.»

С помощью format() это будет выглядеть так:

print("Привет, {}! Тебе {} лет.".format(name, age))

И вывод будет именно таким, как мы хотим. Никаких лишних кавычек или ошибок преобразования типов.

А если нам нужно подставить одно и то же значение несколько раз? Да легко!

product = "Python"

print("Изучение {product} - это здорово! {product} - мощный язык.".format(product=product))

Результат:

Изучение Python - это здорово! Python - мощный язык.

Можно даже использовать числа в качестве позиционных аргументов, если их больше, чем значений:

print("Первое: {0}, второе: {1}, первое снова: {0}".format("яблоко", "груша"))

Вывод:

Первое: яблоко, второе: груша, первое снова: яблоко

Как видите, format() очень гибкий. Можно подставлять что угодно: строки, числа, даже другие объекты, если у них есть строковое представление.

Управление форматированием чисел

Вот тут начинается самое интересное. Форматировать не только строки, но и числа, чтобы они выглядели как надо. Например, показать копейки до сотых, выровнять числа по ширине, добавить знаки или даже перевести в другую систему счисления. Для этого есть специальные спецификаторы формата.

Представьте, у вас есть число с кучей знаков после запятой: price = 123.456789. Хотите показать только два знака? Просто:

print("Цена: {:.2f}".format(price))

Результат: Цена: 123.46. Python сам округлил. Магия!

А если нужно, чтобы число занимало определенное количество места, например, 10 символов, и выравнивалось по правому краю? Используем ширину поля:

number = 42

print("Число: {:>10}".format(number))

Вывод будет:

Число: 42 (с пробелами слева).

Можно добавить знак плюса для положительных чисел, хотя это редко используют. А вот разделители тысяч — это удобно:

large_number = 1234567890

print("Большое число: {:,}".format(large_number))

Вывод:

Большое число: 1,234,567,890

Есть и экзотика: двоичная, восьмеричная, шестнадцатеричная системы счисления. Используйте b, o, x соответственно.

print("Десятичное: {}, Двоичное: {:b}, Шестнадцатеричное: {:x}".format(255, 255, 255))

Результат:

Десятичное: 255, Двоичное: 11111111, Шестнадцатеричное: ff

Еще можно выводить числа в экспоненциальной записи (e или E), что удобно для очень больших или очень маленьких чисел.

scientific_number = 0.00000123

print("Научная запись: {:.3e}".format(scientific_number))

Вывод:

Научная запись: 1.230e-06

Вот так, мелочь, а приятно. Можно точно контролировать, как ваши числа будут выглядеть.

Форматирование строк и текста

С числами разобрались, а как же текст? В format() есть и для этого фишки. Например, выравнивание. Можно сделать так, чтобы текст был прижат к левому краю, правому или стоял ровно посередине. Это делается с помощью символов выравнивания: < (влево), > (вправо), ^ (по центру).

text = "Python"

print("'{:<10}'".format(text)) # Выравнивание по левому краю, ширина 10

print("'{:>10}'".format(text)) # Выравнивание по правому краю, ширина 10

print("'{:^10}'".format(text)) # Выравнивание по центру, ширина 10

Вывод будет:

'Python '

' Python'

' Python '

А что делать, если нужно заполнить пустое пространство каким-то символом, а не пробелом? Например, звездочками? Легко! Просто ставим символ заполнения перед символом выравнивания:

print("'{:*^10}'".format(text))

Вывод:

'**Python**'

Очень удобно, когда нужно создать красивые разделители или оформить таблицы.

Еще одна полезная штука — усечение строк. Если строка слишком длинная, можно указать максимальную длину, и она обрежется. Например, если нужно вывести имя пользователя, но оно может быть слишком длинным:

long_name = "Александра Ивановна Петрова"

print("Имя: '{:.10}'".format(long_name)) # Ограничиваем до 10 символов

Вывод:

Имя: 'Александра'

Вот так, играючи, можно привести любой текст в нужный вид. Главное — знать, какие символы использовать.

Использование словарей и списков

А что, если данные у вас хранятся не просто в отдельных переменных, а, например, в словаре или списке? format() и тут справится. Это реально удобно, когда у вас много связанных данных.

Давайте возьмем словарь с информацией о пользователе:

user_data = {

"name": "Елена",

"city": "Москва",

"age": 28

}

Теперь мы можем обращаться к данным по ключам прямо внутри фигурных скобок:

print("Пользователь: {name}, город: {city}, возраст: {age}".format(**user_data))

**user_data — это такой магический прием, который распаковывает словарь в именованные аргументы. То есть, Python понимает, что name из скобок — это user_data["name"], city — это user_data["city"] и так далее. Очень лаконично!

Вывод будет:

Пользователь: Елена, город: Москва, возраст: 28

А если у вас данные в списке? Тоже не проблема. Доступ к элементам будет по индексу, прямо как в обычной работе со списками:

user_info = ["Иван", "Санкт-Петербург", 35]

print("Имя: {0[0]}, город: {0[1]}, возраст: {0[2]}".format(user_info))

Здесь {0[0]} означает: взять первый аргумент (это user_info, то есть индекс 0), а из него взять элемент с индексом 0. Получается, user_info[0].

Вывод:

Имя: Иван, город: Санкт-Петербург, возраст: 35

Или можно комбинировать: взять элемент списка по индексу, а потом обратиться к его словарю:

users = [

{"name": "Петр", "age": 22},

{"name": "Анна", "age": 31}

]

print("Первый пользователь: {0[0][name]}, возраст: {0[0][age]}".format(users))

Вывод:

Первый пользователь: Петр, возраст: 22

Это показывает, насколько мощный и гибкий `format()`. Можно строить сложные конструкции и работать с любыми структурами данных.

Спецификаторы формата: Полный обзор

Мини-язык спецификаций формата — это, по сути, набор правил, которые определяют, как именно будет выглядеть конечное значение. Это такая маленькая, но очень мощная система внутри format(). Давайте разберем ее по частям. Общий вид такого спецификатора: {значение:fill_align_sign_width_grouping_precision_type}.

fill — символ заполнения (например, *). Работает вместе с выравниванием. Если его нет, по умолчанию используется пробел.

align — выравнивание: < (влево), > (вправо), ^ (по центру), = (только для чисел, знак выравнивается слева, а число — справа, например, +123).

sign — что делать со знаком числа: + (всегда показывать знак), - (только для отрицательных, по умолчанию), (пробел) (пробел для положительных, минус для отрицательных).

width — минимальная ширина поля. Число должно занимать минимум столько символов. Если значение короче, оно будет дополнено символом fill.

grouping — как группировать разряды. Обычно это , для разделения тысяч (например, 1,000,000). В разных локалях могут быть другие символы, но в Python обычно запятая.

precision — точность. Для чисел с плавающей точкой — количество знаков после запятой. Для строк — максимальное количество символов. Например, .2 для float означает два знака после запятой, а .10 для строки — максимум 10 символов.

type — тип представления. Тут целая куча вариантов:

• s: строка (по умолчанию для строк).
• b: двоичное представление.
• o: восьмеричное представление.
• x: шестнадцатеричное представление (нижний регистр).
• X: шестнадцатеричное представление (верхний регистр).
• d: десятичное целое число (по умолчанию для целых).
• e: экспоненциальная запись (нижний регистр).
• E: экспоненциальная запись (верхний регистр).
• f: число с плавающей точкой (fixed-point).
• F: то же, что f, но для NaN и inf — верхний регистр.
• %: процент (умножает число на 100 и добавляет %).
• g: общий формат (e или f, в зависимости от того, что короче).
• G: то же, что g, но с использованием E или F.

Пример сложного спецификатора:

num = 12345.6789

print("Число: {:+15,.2f}".format(num))

Разберем: + (показывать знак), 15 (ширина 15 символов), , (разделитель тысяч), .2f (два знака после запятой, формат float).

Вывод:

Число: +12,345.68

Это действительно мощный инструмент, который позволяет добиться практически любого представления данных. Главное — не запутаться во всех этих символах!

Форматирование дат и времени

Работать с датами и временем — отдельная песня. Но благодаря format(), даже такие сложные штуки, как вывод даты в нужном формате, становятся намного проще. Для этого нужно использовать специальные директивы формата, которые применимы к объектам datetime.

Сначала импортируем модуль datetime:

import datetime

now = datetime.datetime.now() # Получаем текущую дату и время

Теперь давайте выведем дату в разных форматах:

print("Полная дата и время: {}".format(now))

print("Год: {}, Месяц: {}, День: {}".format(now.year, now.month, now.day))

print("Формат ДД.ММ.ГГГГ: {:02d}.{:02d}.{}".format(now.day, now.month, now.year)) # Используем спецификаторы для чисел

print("День недели (полное название): %A".format(now)) # Для этого часто используют старый %-формат, но можно и через format:

print("День недели (полное название): {:%A}".format(now))

print("Месяц (сокращенное название): {:%b}".format(now))

print("Время: {:%H:%M:%S}".format(now))

print("Дата и время в стиле ISO: {:%Y-%m-%dT%H:%M:%S}".format(now))

Основные директивы:

• %Y или %Y: год (четыре цифры)
• %y: год (две цифры)
• %m: месяц (01-12)
• %d: день месяца (01-31)
• %H: час (00-23)
• %I: час (01-12)
• %M: минута (00-59)
• %S: секунда (00-59)
• %A: полное название дня недели
• %a: сокращенное название дня недели
• %B: полное название месяца
• %b: сокращенное название месяца

Как видите, format() умеет работать с объектами datetime, позволяя выводить дату и время в любом мыслимом формате. Это крайне полезно для логов, отчетов или просто для отображения информации пользователю.

Сравнение format() с f-строками

Итак, мы знаем про format(), но как насчет f-строк? Это появилось в Python 3.6 и стало настоящим хитом. Многие считают f-строки более современным и читаемым способом форматирования.

Давайте возьмем тот же пример с именем и возрастом:

name = "Алексей"

age = 30

print("Привет, {}! Тебе {} лет.".format(name, age)) # С format()

А вот так же с f-строкой:

print(f"Привет, {name}! Тебе {age} лет.")

Разница очевидна, да? В f-строке вы просто ставите букву f перед открывающей кавычкой и вставляете переменные прямо в фигурные скобки. Никаких лишних вызовов метода format().

Читаемость: f-строки часто выигрывают по читаемости, особенно для простых случаев. Код выглядит чище и понятнее.

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

Функциональность: Почти все, что можно сделать с format(), можно сделать и с f-строками. Спецификаторы формата, вызовы функций внутри скобок — все работает.

print(f"Цена: {price:.2f}")

print(f"Число: {number:>10}")

print(f"Большое число: {large_number:,}")

Когда что использовать?

f-строки — отличный выбор для большинства современных Python-проектов (Python 3.6+). Они проще, читабельнее и чуть быстрее.

format() — все еще актуален, особенно если:

• Вы работаете со старыми версиями Python.
• Вам нужно создать шаблон строки, который будет использоваться многократно (например, для переводов или конфигурационных файлов), потому что format() позволяет передавать аргументы отдельно от самой строки.
• Вам нужно использовать __format__ метод объекта (об этом чуть ниже).

Короче говоря, f-строки — это наше будущее (и настоящее для многих), но format() тоже не стоит забывать. Они оба решают одну задачу, просто немного по-разному.

Продвинутые техники format()

Мы уже многое рассмотрели, но format() может еще больше! Есть несколько продвинутых фишек, которые могут пригодиться в сложных ситуациях. Например, динамическое форматирование.

Что если у вас параметры форматирования (например, ширина поля или точность) тоже хранятся в переменных? Вы можете передавать их прямо в спецификатор:

width = 10

precision = 3

value = 123.456789

print("Значение: {:.*f}".format(precision, value, width)) # Обратите внимание: width идет после value, но используется для width

Это немного запутанно, потому что Python смотрит на порядок аргументов. Для width и precision нужно передавать их ПЕРЕД значением, которое форматируется. Более наглядно:

width = 10

precision = 3

value = 123.456789

print("Значение: {1:{0}.{2}f}".format(width, value, precision)) # Здесь 0 - это width, 1 - value, 2 - precision

Этот синтаксис немного вычурный, но позволяет создавать очень гибкие форматировщики. Еще одна крутая штука — модификаторы !s, !r, !a.

Они применяют к объекту соответствующие функции: str(), repr(), ascii() перед форматированием. Полезно, когда нужно явно указать, как объект должен быть представлен.

my_list = [1, 2, 3]

print("Стандартное: {}".format(my_list)) # Использует str() по умолчанию

print("repr(): {!r}".format(my_list)) # Использует repr()

print("ascii(): {!a}".format(my_list)) # Использует ascii()

Вывод:

Стандартное: [1, 2, 3]

repr(): [1, 2, 3]

ascii(): [1, 2, 3]

В данном случае разница невелика, но для пользовательских объектов она может быть существенной. Например, repr() часто используется для отладки, так как дает более точное представление объекта.

И, наконец, можно переопределить метод __format__() для собственных классов. Это позволяет вашим объектам управлять тем, как они будут форматироваться.

class MyNumber:

def __init__(self, value):

self.value = value

def __format__(self, format_spec):

return f"Мое число ({format_spec}): {self.value:{format_spec}}"

num_obj = MyNumber(42)

print("{:d}".format(num_obj))

print("{:10}".format(num_obj))

Вывод:

Мое число (d): 42

Мое число (10): 42

Это уже совсем глубокое погружение, но знать о таких возможностях полезно. Так вы можете сделать свои классы полностью совместимыми с системой форматирования Python.