Форматирование строк — одна из тех базовых возможностей Python, которые сопровождают разработчика каждый день. Эта задача кажется тривиальной на первый взгляд, но на самом деле представляет собой глубокую тему с множеством нюансов. От формирования сообщений пользователям до подготовки отчетов и аналитических выводов — грамотное управление текстовыми данными критически важно для создания читаемого, поддерживаемого и эффективного кода.
Интересно наблюдать как Python эволюционировал и менял подходы к такой фундаментальной задаче. На заре появления языка программисты использовали оператор форматирования % (процент), унаследованный от языка C. Этот подход, хоть и функциональный, имел свои ограничения и не всегда был интуитивно понятен, особенно для новичков. С выходом Python 2.6 сообщество получило более гибкий метод .format(), предоставивший расширенные возможности и более читаемый синтаксис. Этот метод стал шагом вперед, позволяя работать с именованными аргументами и создавать сложные шаблоны форматирования. Настоящий прорыв произошел с внедрением f-строк в Python 3.6 (PEP 498). Этот механизм не только упростил код, но и значительно улучшил его читаемость, позволив программистам вставлять выражения непосредственно в строковые литералы. Такой подход существенно сократил количество знаков препинания и сделал код более лаконичным.
Технологии форматирования строк приобретают особую значимость при работе с данными разных типов. Представьте вам нужно объединить числовые, текстовые и временные данные в единую читаемую структуру, учитывая при этом специфические требования к отображению каждого типа. Или вы работаете над интернационализацией приложения, где форматирование должно учитывать особенности различных языков и культур. В этих и многих других сценариях умение грамотно манипулировать строками становится не просто полезным навыком, а необходимым инструментом.
Форматирование строк в Python: от базовых техник до продвинутых приёмов
Разработчики регулярно сталкиваются с необходимостью управлять выводом информации: выравнивать текст в консольных приложениях, форматировать таблицы с данными, создавать читабельные отчеты или готовить данные для API. Без знания различных техник форматирования эти задачи превращаются в сложные головоломки, отнимающие время и ресурсы.
Основные способы форматирования
За историю Python развились три основных подхода к форматированию строк, каждый со своими особенностями и областями применения. Понимание всех трёх методов важно не только для работы с устаревшим кодом, но и для выбора наиболее подходящего инструмента под конкретную задачу.
Оператор % (старый стиль)
Самый ранний механизм форматирования строк в Python — оператор процента (%). Этот подход был заимствован из языка C и стал частью Python с самых первых версий. Синтаксис его использования прост: строка с заполнителями слева от оператора % и значения для подстановки справа.
| Python | 1
2
3
4
| name = "Алиса"
age = 25
print("Привет, %s! Тебе %d лет." % (name, age))
# Вывод: Привет, Алиса! Тебе 25 лет. |
|
| Python | 1
2
| print("%(name)s имеет %(age)d лет." % {"name": "Боб", "age": 30})
# Вывод: Боб имеет 30 лет. |
|
| Python | 1
2
3
4
5
6
| pi = 3.14159265359
print("Значение пи с точностью до 3 знаков: %.3f" % pi)
[H2]Вывод: Значение пи с точностью до 3 знаков: 3.142[/H2]
print("Выравнивание числа по правому краю в поле шириной 10: %10.2f" % pi)
# Вывод: Выравнивание числа по правому краю в поле шириной 10: 3.14 |
|
Метод .format()
С появлением Python 2.6 был введён метод .format(), который значительно улучшил процесс форматирования строк. Этот метод вызывается на строковом объекте и принимает аргументы, которые будут подставлены в соответствующие заполнители.
| Python | 1
2
3
4
| name = "Виктор"
age = 35
print("Привет, {}! Тебе {} лет.".format(name, age))
# Вывод: Привет, Виктор! Тебе 35 лет. |
|
{}) обозначают места подстановки. По умолчанию аргументы вставляются по порядку, но можно явно указать их индексы:
| Python | 1
2
| print("Второй: {1}, Первый: {0}".format("яблоко", "банан"))
# Вывод: Второй: банан, Первый: яблоко |
|
.format() особенно заметно при работе с именованными аргументами:
| Python | 1
2
| print("Имя: {name}, Возраст: {age}".format(name="Елена", age=28))
# Вывод: Имя: Елена, Возраст: 28 |
|
| Python | 1
2
| print("{0} {1}. Ещё раз {0}.".format("Привет", "мир"))
# Вывод: Привет мир. Ещё раз Привет. |
|
.format() также поддерживает расширенные возможности форматирования через спецификаторы, указываемые после двоеточия внутри фигурных скобок:
| Python | 1
2
3
| import math
print("Пи примерно равно {0:.3f}".format(math.pi))
# Вывод: Пи примерно равно 3.142 |
|
.format() — вложенное форматирование, когда внутри фигурных скобок можно использовать другие фигурные скобки для динамического определения формата:
| Python | 1
2
3
4
| width = 10
precision = 4
print("Результат: {0:{1}.{2}f}".format(math.pi, width, precision))
# Вывод: Результат: 3.1416 |
|
f-строки (PEP 498)
С выходом Python 3.6 появились f-строки (форматированные строковые литералы), которые представляют собой самый лаконичный и эффективный способ форматирования строк. F-строки обозначаются префиксом f или F перед строковым литералом и позволяют напрямую встраивать выражения Python внутрь фигурных скобок:
| Python | 1
2
3
4
| name = "Иван"
age = 40
f"Привет, {name}! В следующем году тебе будет {age + 1} лет."
# Вывод: Привет, Иван! В следующем году тебе будет 41 лет. |
|
.format(), который выполняет подстановку при вызове). Это не только более лаконично, но и более производительно. Внутри фигурных скобок можно размещать практически любые выражения Python, включая вызовы функций, математические операции и даже условные выражения:
| Python | 1
2
3
4
5
6
7
8
9
10
11
12
| import datetime
current_time = datetime.datetime.now()
f"Текущее время: {current_time:%H:%M:%S}"
[H2]Вывод: Текущее время: 15:30:45[/H2]
x = 10
f"Квадрат числа {x} равен {x**2}"
[H2]Вывод: Квадрат числа 10 равен 100[/H2]
status = "активный"
f"Статус пользователя: {'активен' if status == 'активный' else 'неактивен'}"
# Вывод: Статус пользователя: активен |
|
.format():
| Python | 1
2
3
| value = 12345.6789
f"Форматированное число: {value:,.2f}"
# Вывод: Форматированное число: 12,345.68 |
|
=, который позволяет отображать и выражение, и его значение, что особенно удобно при отладке:
| Python | 1
2
3
4
| x = 42
print(f"{x=}") # Вывод: x=42
y = "привет"
print(f"{y.upper()=}") # Вывод: y.upper()='ПРИВЕТ' |
|
Спецификаторы форматирования в деталях
Все три механизма форматирования строк в Python используют схожую систему спецификаторов, которые определяют, как значение будет представлено в результирующей строке. После двоеточия внутри фигурных скобок (для .format() и f-строк) или после знака процента (для оператора %) можно указать различные параметры форматирования.
Общий синтаксис спецификатора выглядит так:
| Python | 1
| [[заполнитель]выравнивание][знак][#][0][ширина][,][.точность][тип] |
|
Выравнивание и заполнитель
Для контроля выравнивания текста в поле фиксированной ширины можно использовать следующие спецификаторы:
| Python | 1
2
3
4
5
6
7
8
9
10
11
| # Левое выравнивание (по умолчанию для строк)
print(f"{'левый':<10}|") # Вывод: "левый |"
# Правое выравнивание (по умолчанию для чисел)
print(f"{'правый':>10}|") # Вывод: " правый|"
# Центрирование
print(f"{'центр':^10}|") # Вывод: " центр |"
# С указанием символа-заполнителя
print(f"{'звёзды':*^10}|") # Вывод: "[B]звёзды[/B]|" |
|
Для числовых типов можно управлять отображением знака:
| Python | 1
2
3
4
5
6
7
8
| # + выводит знак для всех чисел (и положительных, и отрицательных)
print(f"{42:+} и {-42:+}") # Вывод: "+42 и -42"
# - выводит знак только для отрицательных чисел (по умолчанию)
print(f"{42:-} и {-42:-}") # Вывод: "42 и -42"
# пробел ставит пробел перед положительными числами и минус перед отрицательными
print(f"{42: } и {-42: }") # Вывод: " 42 и -42" |
|
Для числовых значений существует множество способов форматирования:
| Python | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
| # Целочисленное форматирование
print(f"{42:d}") # Десятичное (по умолчанию): "42"
print(f"{42:b}") # Двоичное: "101010"
print(f"{42:o}") # Восьмеричное: "52"
print(f"{42:x}") # Шестнадцатеричное (нижний регистр): "2a"
print(f"{42:X}") # Шестнадцатеричное (верхний регистр): "2A"
# С добавлением префикса системы счисления
print(f"{42:#b}") # "0b101010"
print(f"{42:#o}") # "0o52"
print(f"{42:#x}") # "0x2a"
# Форматирование чисел с плавающей точкой
pi = 3.14159265359
print(f"{pi:f}") # Фиксированная точка: "3.141593"
print(f"{pi:.2f}") # Две цифры после точки: "3.14"
print(f"{pi:e}") # Экспоненциальная форма: "3.141593e+00"
print(f"{pi:.2e}") # Экспоненциальная форма с двумя цифрами: "3.14e+00"
print(f"{pi:g}") # Общий формат (f или e, в зависимости от значения): "3.14159"
print(f"{pi:.3g}") # Общий формат с тремя значащими цифрами: "3.14"
# Разделение групп разрядов
print(f"{1234567:,}") # "1,234,567"
print(f"{1234567:_}") # "1_234_567" |
|
Для представления чисел в виде процентов используется спецификатор %:
| Python | 1
2
3
| rate = 0.25
print(f"{rate:%}") # Вывод: "25.000000%"
print(f"{rate:.1%}") # Вывод: "25.0%" |
|
Особенности форматирования строк в Python 2 vs Python 3
Между Python 2 и Python 3 есть несколько ключевых различий в механизмах форматирования строк:
1. Строковые литералы: В Python 2 по умолчанию строки представляли собой последовательности байтов, тогда как в Python 3 строки — это последовательности символов Unicode. Это влияет на форматирование неанглийских символов.
2. f-строки: Доступны только в Python 3.6 и выше. В Python 2 нет нативной поддержки этой функциональности.
3. Метод .format(): Появился в Python 2.6 и полностью поддерживается в Python 3. Однако, существуют некоторые различия в деталях реализации.
4. Оператор %: В Python 3 оператор % был сохранен для обратной совместимости, но его использование считается устаревшим. В Python 2 он был основным методом форматирования строк.
Пример, демонстрирующий проблему совместимости с Unicode в Python 2:
| Python | 1
2
3
4
5
6
7
| # В Python 2
name = u"Иванов" # Необходимо явное указание Unicode строки
print("Привет, %s!" % name) # Может вызвать проблемы с кодировкой
# В Python 3
name = "Иванов" # Строки уже по умолчанию в Unicode
print("Привет, %s!" % name) # Работает корректно |
|
Ошибки и исключения при работе с разными методами форматирования
При работе с форматированием строк можно столкнуться с рядом типичных ошибок:
1. Несоответствие количества аргументов
| Python | 1
2
3
4
5
6
7
8
9
10
11
| # Оператор %
try:
"Привет, %s и %s!" % "Алиса" # Не хватает одного аргумента
except TypeError as e:
print(f"Ошибка: {e}") # "not enough arguments for format string"
# Метод .format()
try:
"Привет, {} и {}!".format("Боб") # Не хватает одного аргумента
except IndexError as e:
print(f"Ошибка: {e}") # "tuple index out of range" |
|
| Python | 1
2
3
4
| try:
"Число: %d" % "не число" # Строка вместо числа
except TypeError as e:
print(f"Ошибка: {e}") # "must be..." |
|
| Python | 1
2
3
4
| try:
"Привет, {name}!".format(имя="Джон") # Ключи не совпадают
except KeyError as e:
print(f"Ошибка: {e}") # "name" |
|
| Python | 1
2
3
4
5
6
7
8
9
| # Незакрытые скобки или некорректные выражения вызовут синтаксическую ошибку при парсинге
[H2]f"Незакрытая скобка: {1 + 2" # SyntaxError[/H2]
# Ошибки в выражениях обрабатываются на этапе выполнения
x = None
try:
result = f"Результат: {x.nonexistent_method()}"
except AttributeError as e:
print(f"Ошибка: {e}") # "'NoneType' object has no attribute 'nonexistent_method'" |
|
| Python | 1
2
3
4
5
| try:
# Двоичный формат для строки
"{:b}".format("строка")
except ValueError as e:
print(f"Ошибка: {e}") # "Unknown format code 'b' for object of type 'str'" |
|
Выбор метода форматирования
Каждый из методов форматирования имеет свои преимущества и недостатки. При выборе подхода стоит учитывать следующие факторы:
Версия Python: Если код должен работать на Python 2 и Python 3, оператор % или .format() — более безопасный выбор.
Читаемость: F-строки обычно дают наиболее компактный и читаемый код.
Производительность: F-строки обычно работают быстрее других методов.
Повторное использование шаблонов: Если нужно многократно использовать один и тот же шаблон строки с разными данными, .format() может быть удобнее.
Динамическое построение строк: При необходимости построения строк "на лету" из переменных или заголовков таблиц, метод .format() с ключевыми аргументами предлагает больше гибкости.
Современный Python код, особенно на Python 3.6+ все чаще отдает предпочтение f-строкам благодаря их лаконичности и выразительности. Тем не менее, знание всех методов форматирования строк остается важным навыком для понимания существующего кода и выбора оптимального решения для конкретной задачи.
Практическое применение
Теория форматирования строк становится по-настоящему полезной, когда мы применяем её к решению реальных задач. В этом разделе рассмотрим наиболее распространённые сценарии использования строкового форматирования в Python.
Числовые форматы и выравнивание
При работе с числовыми данными часто требуется их представление в определённом формате — будь то фиксированное количество знаков после запятой, научная нотация или выравнивание в колонках.
Для целых чисел можно управлять шириной поля и выравниванием:
| Python | 1
2
3
4
5
6
7
| for num in range(1, 16, 5):
print(f"{num:03d}") # Дополнение нулями слева до 3 цифр
# Вывод:
# 001
# 006
# 011 |
|
| Python | 1
2
3
4
5
| value = 12345.6789
print(f"Фиксированная точка: {value:.2f}") # 12345.68
print(f"Экспоненциальная форма: {value:.2e}") # 1.23e+04
print(f"Процентный формат: {value/100:.2%}") # 123.46%
print(f"С разделителями разрядов:{value:,.2f}") # 12,345.68 |
|
| Python | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
| # Создадим мини-отчёт с разным выравниванием
header = "Отчёт о продажах"
print(f"{header:=^30}") # Центрирование с заполнением символом =
data = [
("Яблоки", 150, 5.25),
("Апельсины", 85, 4.75),
("Бананы", 210, 3.50)
]
print(f"{'Товар':<12}{'Кол-во':^8}{'Цена':>10}")
print("-" * 30)
for item, qty, price in data:
print(f"{item:<12}{qty:^8}{price:>10.2f}") |
|
| Python | 1
2
3
4
5
6
| ===========Отчёт о продажах===========
Товар Кол-во Цена
------------------------------
Яблоки 150 5.25
Апельсины 85 4.75
Бананы 210 3.50 |
|
Дата и время
Форматирование даты и времени — распространённая задача при создании отчётов, логов или пользовательских интерфейсов. Python предоставляет гибкие возможности для работы с временными метками:
| Python | 1
2
3
4
5
6
7
8
9
10
11
| import datetime
now = datetime.datetime.now()
# Различные форматы даты и времени
print(f"Стандартный формат: {now}")
print(f"Только дата: {now:%Y-%m-%d}")
print(f"Только время: {now:%H:%M:%S}")
print(f"Локальный формат даты: {now:%x}")
print(f"Локальный формат времени: {now:%X}")
print(f"Пользовательский формат: {now:%d %B %Y г., %A}") |
|
%Y - год (4 цифры)
%m - месяц (01-12)
%d - день (01-31)
%H - час в 24-часовом формате (00-23)
%M - минуты (00-59)
%S - секунды (00-59)
%A - полное название дня недели
%B - полное название месяца
Таблицы и структурированные данные
Построение таблиц — частая задача при работе с данными. С помощью форматирования строк можно создавать компактные и читаемые таблицы:
| Python | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
| # Данные для таблицы
headers = ["ID", "Имя", "Возраст", "Зарплата"]
employees = [
(1, "Иванов А.С.", 35, 78000),
(2, "Петрова М.И.", 28, 65750),
(3, "Сидоров К.П.", 42, 95230),
(4, "Кузнецова В.В.", 31, 70100)
]
# Определение ширины столбцов
widths = [max(len(str(row[i])) for row in [headers] + employees)
for i in range(len(headers))]
# Создание строки формата для каждой строки
fmt = ' | '.join(f"{{:{w}}}" for w in widths)
# Вывод заголовка
print(fmt.format(*headers))
print('-' * (sum(widths) + 3 * (len(widths) - 1)))
# Вывод данных
for emp in employees:
print(fmt.format(*[str(x) for x in emp])) |
|
Работа с денежными величинами и валютами
Денежные значения требуют особого внимания при форматировании. Важно правильно округлять и отображать символы валют:
| Python | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
| prices = {
"USD": 42.50,
"EUR": 57.85,
"GBP": 68.93,
"JPY": 0.39
}
# Функция для форматирования валют с соответствующими символами
def format_currency(amount, currency):
symbols = {"USD": "$", "EUR": "€", "GBP": "£", "JPY": "¥"}
symbol = symbols.get(currency, "")
if currency == "JPY": # Японская йена обычно без десятичных знаков
return f"{symbol}{amount:.0f}"
else:
return f"{symbol}{amount:.2f}"
# Вывод прайс-листа
print("Прайс-лист:")
for currency, amount in prices.items():
print(f"{currency}: {format_currency(amount, currency)}") |
|
decimal для точных вычислений или babel для локализованного форматирования валют), но для простых случаев описанный подход работает достаточно хорошо.
Обрезка и заполнение строк при форматировании
Иногда требуется ограничить длину строки или дополнить её до определённой длины:
| Python | 1
2
3
4
5
6
7
8
9
10
| long_text = "Это очень длинный текст, который нужно обрезать"
# Обрезка с многоточием
print(f"{long_text:.20}...") # Обрезка до 20 символов
# Заполнение строки до фиксированной длины
short_text = "Короткий текст"
print(f"{short_text:*<20}") # Дополнение звездочками справа
print(f"{short_text:*>20}") # Дополнение звездочками слева
print(f"{short_text:*^20}") # Центрирование с дополнением звездочками |
|
Конвертация между разными системами счисления
Python позволяет легко конвертировать числа между различными системами счисления:
| Python | 1
2
3
4
5
6
7
8
9
10
11
12
13
| number = 255
# Представление в различных системах счисления
print(f"Десятичное: {number:d}") # 255
print(f"Двоичное: {number:b}") # 11111111
print(f"Восьмеричное: {number:o}") # 377
print(f"Шестнадцатеричное: {number:x}") # ff
print(f"ШЕСТНАДЦАТЕРИЧНОЕ: {number:X}") # FF
# С префиксами систем счисления
print(f"Двоичное (с префиксом): {number:#b}") # 0b11111111
print(f"Восьмеричное (с префиксом): {number:#o}") # 0o377
print(f"Шестнадцатеричное (с префиксом): {number:#x}") # 0xff |
|
В реальных проектах полезно создавать вспомогательные функции, инкапсулирующие часто используемые шаблоны форматирования:
| Python | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
| def format_size(size_bytes):
"""Форматирует размер файла в читаемом виде."""
units = ['Б', 'КБ', 'МБ', 'ГБ', 'ТБ']
size = float(size_bytes)
unit_index = 0
while size >= 1024 and unit_index < len(units) - 1:
size /= 1024
unit_index += 1
return f"{size:.2f} {units[unit_index]}"
# Примеры использования
print(format_size(1023)) # 1023.00 Б
print(format_size(1024)) # 1.00 КБ
print(format_size(1048576)) # 1.00 МБ
print(format_size(2.5 * 10**9)) # 2.33 ГБ |
|
Форматирование для генерации отчетов
Часто нужно генерировать файлы CSV или подобные документы с правильным форматированием. Вот как можно создать CSV-файл с правильными разделителями полей:
| Python | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
| import csv
from io import StringIO
# Данные для отчета
sales_data = [
["Регион", "Q1", "Q2", "Q3", "Q4", "Всего"],
["Север", 10500, 12600, 9800, 13400, 46300],
["Юг", 8700, 9400, 11200, 10800, 40100],
["Запад", 14200, 15300, 15900, 16200, 61600]
]
# Создание CSV в памяти
output = StringIO()
csv_writer = csv.writer(output)
for row in sales_data:
csv_writer.writerow(row)
print(output.getvalue()) |
|
| Python | 1
2
3
4
5
6
7
8
9
10
11
| # Вывод тех же данных красиво в консоль
column_widths = [max(len(str(row[i])) for row in sales_data) for i in range(len(sales_data[0]))]
# Вывод заголовка
header_format = " | ".join(f"{{:{w}}}" for w in column_widths)
print(header_format.format(*sales_data[0]))
print("-" * (sum(column_widths) + 3 * (len(column_widths) - 1)))
# Вывод данных
for row in sales_data[1:]:
print(header_format.format(*[str(x) for x in row])) |
|
Форматирование для создания HTML
Python также отлично подходит для генерации HTML-контента с помощью строкового форматирования:
| Python | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
| def generate_html_table(data):
html = ['<table border="1">']
# Заголовок таблицы
html.append('<tr>')
for header in data[0]:
html.append(f'<th>{header}</th>')
html.append('</tr>')
# Строки данных
for row in data[1:]:
html.append('<tr>')
for cell in row:
# Красим ячейки с высокими значениями
if isinstance(cell, int) and cell > 15000:
html.append(f'<td style="color:green"><b>{cell}</b></td>')
else:
html.append(f'<td>{cell}</td>')
html.append('</tr>')
html.append('</table>')
return '\n'.join(html)
# Использование функции
html_table = generate_html_table(sales_data)
print(html_table) |
|
Локализация и форматирование многоязычных строк
При создании многоязычных приложений часто требуется учитывать особенности форматирования для разных языков:
| Python | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
| import locale
from datetime import datetime
# Функция для отображения даты в разных локалях
def show_date_in_locales(date, locales):
results = []
original_locale = locale.getlocale(locale.LC_TIME)
for loc in locales:
try:
locale.setlocale(locale.LC_TIME, loc)
formatted = date.strftime('%x %X')
results.append(f"{loc}: {formatted}")
except locale.Error:
results.append(f"{loc}: не поддерживается")
# Восстановление исходной локали
locale.setlocale(locale.LC_TIME, original_locale)
return results
# Пример использования
now = datetime.now()
for result in show_date_in_locales(now, ['ru_RU.UTF-8', 'en_US.UTF-8', 'de_DE.UTF-8', 'fr_FR.UTF-8']):
print(result) |
|
Форматирование логов и отладочной информации
Правильное форматирование логов — ключевой аспект в отладке приложений:
| Python | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
| import logging
import time
# Настройка форматирования логов
logging.basicConfig(
level=logging.DEBUG,
format='%(asctime)s [%(levelname)s] %(name)s - %(message)s',
datefmt='%Y-%m-%d %H:%M:%S'
)
logger = logging.getLogger('my_app')
# Пример логирования с форматированными строками
def process_order(order_id, items, customer):
logger.info(f"Начало обработки заказа #{order_id}")
total = sum(item['price'] * item['quantity'] for item in items)
logger.debug(
f"Детали заказа: ID={order_id}, "
f"Клиент={customer['name']}, "
f"Товаров={len(items)}, "
f"Сумма={total:.2f}₽"
)
# Имитация обработки
time.sleep(0.5)
if total > 10000:
logger.warning(f"Требуется дополнительная проверка для заказа #{order_id} (сумма: {total:.2f}₽)")
logger.info(f"Заказ #{order_id} успешно обработан")
return True
# Тестовые данные
order = {
'id': 12345,
'customer': {'name': 'Иванов И.И.', 'email': 'ivanov@example.com'},
'items': [
{'name': 'Ноутбук', 'price': 45000, 'quantity': 1},
{'name': 'Мышь', 'price': 1200, 'quantity': 2}
]
}
# Вызов функции с логированием
process_order(order['id'], order['items'], order['customer']) |
|
Форматирование строк для записи в файл. Функция append() и циклы
Добрый вечер!
С питоном начала разбираться совсем недавно и у меня возникла проблема при записи... Форматирование строк и генераторы списков
Доброго времени суток. Задача очень легка, вывести таблицу умножения на определенное число,... Xlwt и форматирование строк(столбцов)
Доброго времени суток, Уважаемые форумчане. Будьте так добры, подскажите как в модуле xlwt... Форматирование строк
Не могу понять куда вставить .format для выравнивания столбиков с числами
import random
a = ...
Продвинутые техники
Освоив основы форматирования строк, можно перейти к более сложным техникам, которые значительно расширяют возможности работы с текстовыми данными в Python. Эти методы особенно полезны при создании сложных приложений с интернациональной аудиторией или при разработке специализированных инструментов обработки данных.
Локализация и интернационализация
При разработке приложений для международной аудитории важно учитывать различия в представлении дат, чисел и валют. Python предоставляет инструменты для локализации форматирования.
Модуль locale позволяет адаптировать форматирование под конкретные региональные стандарты:
| Python | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
| import locale
from datetime import date
# Установка локали для России (может не работать на некоторых системах)
try:
locale.setlocale(locale.LC_ALL, 'ru_RU.UTF-8')
except locale.Error:
# Запасной вариант, если русская локаль недоступна
locale.setlocale(locale.LC_ALL, '') # Используем системную локаль
# Форматирование даты с учетом локали
today = date.today()
print(f"Дата (локализованный формат): {today}")
print(f"Дата (с использованием locale): {today:%x}")
# Форматирование чисел
large_number = 1234567.89
print(f"Локализованное число: {locale.format_string('%.2f', large_number, grouping=True)}")
print(f"Локализованная валюта: {locale.currency(large_number, symbol=True, grouping=True)}") |
|
babel, которая обеспечивает надежную поддержку различных локалей:
| Python | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
| from babel.dates import format_date, format_datetime, format_time
from babel.numbers import format_currency
from datetime import datetime
now = datetime.now()
# Форматирование с помощью babel для разных локалей
for locale_name in ['en_US', 'ru_RU', 'de_DE', 'ja_JP']:
print(f"\nЛокаль: {locale_name}")
print(f"Дата: {format_date(now, locale=locale_name)}")
print(f"Время: {format_time(now, locale=locale_name)}")
print(f"Полная дата и время: {format_datetime(now, locale=locale_name)}")
print(f"Валюта (USD): {format_currency(1234.56, 'USD', locale=locale_name)}")
print(f"Валюта (EUR): {format_currency(1234.56, 'EUR', locale=locale_name)}") |
|
Собственные классы форматирования с методом __format__
Один из наиболее мощных механизмов форматирования в Python — возможность определить собственное поведение форматирования для пользовательских классов через специальный метод __format__.
| Python | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
| class Point:
def __init__(self, x, y):
self.x = x
self.y = y
def __format__(self, format_spec):
if not format_spec:
return f"({self.x}, {self.y})"
if format_spec == 'p': # полярные координаты
import math
r = math.sqrt(self.x[B]2 + self.y[/B]2)
theta = math.atan2(self.y, self.x)
return f"(r={r:.2f}, θ={theta:.2f})"
if format_spec == 'h': # HTML формат
return f"<point x='{self.x}' y='{self.y}' />"
# Можно обрабатывать сложные строки формата
parts = format_spec.split(',')
if len(parts) == 2:
x_spec, y_spec = parts
# Форматируем x и y с использованием переданных спецификаторов
x_formatted = format(self.x, x_spec)
y_formatted = format(self.y, y_spec)
return f"({x_formatted}, {y_formatted})"
# Если формат не распознан, используем стандартное форматирование
return f"({self.x}, {self.y})"
# Примеры использования
point = Point(3.14159, 2.71828)
print(f"Стандартный формат: {point}") # Стандартный формат: (3.14159, 2.71828)
print(f"Полярные координаты: {point:p}") # Полярные координаты: (r=4.15, θ=0.71)
print(f"HTML формат: {point:h}") # HTML формат: <point x='3.14159' y='2.71828' />
# Передача форматов отдельно для каждой координаты
print(f"Пользовательский формат: {point:.2f,.3f}") # Пользовательский формат: (3.14, 2.718) |
|
Форматирование строк при работе с API и JSON
При взаимодействии с веб-сервисами через API часто приходится работать с данными в формате JSON. Python предоставляет мощные инструменты для форматирования таких данных:
| Python | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
| import json
import requests
# Пример данных в формате JSON
data = {
"name": "Иван Петров",
"age": 35,
"skills": ["Python", "SQL", "JavaScript"],
"experience": {
"company": "ТехноСофт",
"years": 5,
"projects": ["CRM", "ERP", "Mobile App"]
}
}
# Форматирование JSON для удобного просмотра
formatted_json = json.dumps(data, ensure_ascii=False, indent=4)
print("Форматированный JSON:")
print(formatted_json)
# Использование форматирования при создании URL для API запроса
api_base = "https://api.example.com"
endpoint = "users"
user_id = 42
params = "fields=name,email,phone"
# Разные способы создания URL
url1 = f"{api_base}/{endpoint}/{user_id}?{params}"
url2 = "{}/{}/{}?{}".format(api_base, endpoint, user_id, params)
print(f"API URL (f-строка): {url1}")
print(f"API URL (метод format): {url2}")
# Форматирование вывода результатов API запроса
try:
# Этот код не будет выполняться, так как URL фиктивный
# response = requests.get(url1)
# data = response.json()
# Имитация ответа API для примера
data = {
"id": user_id,
"name": "Иван Иванов",
"email": "ivan@example.com",
"phone": "+7 (123) 456-78-90",
"lastLogin": "2023-04-15T14:32:14Z"
}
# Форматирование вывода информации о пользователе
print(f"\nИнформация о пользователе ID {data['id']}:")
print(f"Имя: {data['name']}")
print(f"Email: {data['email']}")
print(f"Тел.: {data['phone']}")
# Преобразование ISO формата даты
from datetime import datetime
iso_time = data['lastLogin']
dt = datetime.fromisoformat(iso_time.replace('Z', '+00:00'))
local_time = dt.astimezone().strftime('%d.%m.%Y %H:%M:%S')
print(f"Последний вход: {local_time}")
except Exception as e:
print(f"Ошибка при обработке API ответа: {e}") |
|
Комбинирование методов форматирования для сложных случаев
При работе со сложными структурами данных часто требуется комбинировать разные методы форматирования:
| Python | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
| # Создание динамических строк формата
widths = [10, 15, 8]
alignments = ['<', '^', '>']
# Создаем строку формата динамически
dynamic_format = ' | '.join(f"{{:{align}{width}}}" for align, width in zip(alignments, widths))
print(dynamic_format) # {:<10} | {:^15} | {:>8}
# Применяем динамический формат
print(dynamic_format.format("Имя", "Должность", "Стаж"))
print(dynamic_format.format("Иван", "Разработчик", "5 лет"))
print(dynamic_format.format("Мария", "Тестировщик", "3 года"))
# Вложенное форматирование с динамическими значениями
def get_table_row(name, title, years, align_specs=None):
if align_specs is None:
align_specs = ['<', '^', '>']
widths = [len(name) + 2, len(title) + 4, len(str(years)) + 2]
# Создаем строку формата внутри f-строки!
return f"| {name:{align_specs[0]}{widths[0]}} | {title:{align_specs[1]}{widths[1]}} | {years:{align_specs[2]}{widths[2]}} |"
# Использование вложенного форматирования
employees = [
("Андрей", "Старший разработчик", 7),
("Елена", "Руководитель проекта", 5),
("Дмитрий", "QA инженер", 3)
]
for emp in employees:
print(get_table_row(*emp)) |
|
Форматирование строк при работе с байтовыми данными и кодировками
При работе с байтовыми данными и различными кодировками также можно применять методы форматирования:
| Python | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
| # Работа с байтовыми строками
text = "Привет, мир!"
encoded = text.encode('utf-8')
# Форматирование вывода байтов в разных представлениях
print(f"Исходный текст: {text}")
print(f"UTF-8 байты: {encoded}")
# Вывод в шестнадцатеричном формате
hex_bytes = ' '.join(f"{b:02x}" for b in encoded)
print(f"Шестнадцатеричное представление: {hex_bytes}")
# Преобразование между кодировками
cp1251_bytes = text.encode('cp1251')
print(f"CP1251 байты: {cp1251_bytes}")
print(f"Из CP1251 обратно в текст: {cp1251_bytes.decode('cp1251')}")
# Форматирование с обработкой ошибок кодирования
problematic_text = "Hello, 世界!" # Содержит символы разных алфавитов
try:
# Попытка закодировать в ASCII (не поддерживает не-ASCII символы)
ascii_bytes = problematic_text.encode('ascii')
except UnicodeEncodeError as e:
print(f"Ошибка кодирования: {e}")
# Использование замены для неподдерживаемых символов
ascii_bytes = problematic_text.encode('ascii', errors='replace')
print(f"С заменой: {ascii_bytes}")
# Использование игнорирования для неподдерживаемых символов
ascii_bytes = problematic_text.encode('ascii', errors='ignore')
print(f"С игнорированием: {ascii_bytes}")
# Именованные кодовые точки (escape-последовательности)
ascii_bytes = problematic_text.encode('ascii', errors='namereplace')
print(f"С именованием: {ascii_bytes}") |
|
struct для работы с бинарными данными фиксированного формата.
Шаблоны строк для повторного использования
При разработке приложений часто возникает необходимость многократного использования одних и тех же шаблонов форматирования. Для этого Python предоставляет специальный класс string.Template:
| Python | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
| from string import Template
# Создание шаблона
email_template = Template("""
Здравствуйте, $name!
Благодарим за регистрацию на нашем сервисе.
Ваши учетные данные:
Логин: $username
Дата регистрации: $date
С уважением,
Команда поддержки
""")
# Использование шаблона для разных пользователей
users = [
{"name": "Анна Смирнова", "username": "anna_s", "date": "15.04.2023"},
{"name": "Иван Петров", "username": "ivan_p", "date": "16.04.2023"},
{"name": "Елена Козлова", "username": "elena_k", "date": "17.04.2023"}
]
for user in users:
email_content = email_template.substitute(user)
print(f"Email для {user['name']}:")
print(email_content)
print("-" * 50) |
|
Template в его простоте и безопасности — метод substitute() вызовет исключение KeyError, если какой-то из заполнителей отсутствует в словаре. Если же вам нужно более гибкое поведение, можно использовать метод safe_substitute(), который оставит незамененные заполнители как есть:
| Python | 1
2
3
4
5
6
7
8
9
10
| # Пример с отсутствующими данными
incomplete_user = {"name": "Дмитрий", "username": "dmitry_v"}
# Вызовет исключение KeyError, т.к. ключ 'date' отсутствует
[H2]email_template.substitute(incomplete_user)[/H2]
# Безопасная версия — заполнитель останется в тексте
safe_email = email_template.safe_substitute(incomplete_user)
print("Email с отсутствующими данными:")
print(safe_email) |
|
Форматирование для логирования и отладки
Одно из частых применений форматирования строк — создание информативных сообщений для логирования и отладки. Python 3.8 добавил специальный синтаксис f-строк (=), который значительно упрощает отладку:
| Python | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
| import logging
from pprint import pformat
import time
# Настройка логирования
logging.basicConfig(
level=logging.DEBUG,
format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
)
logger = logging.getLogger('app')
# Функция с отладочным выводом
def process_user_data(user_id, data):
logger.debug(f"{user_id=}, {data=}") # Python 3.8+ синтаксис
# Для сложных структур данных можно использовать pprint
complex_data = {"user": user_id, "processing": {"start_time": time.time(), **data}}
logger.debug(f"Обработка данных:\n{pformat(complex_data)}")
# Имитация обработки
processed = {k: v.upper() if isinstance(v, str) else v for k, v in data.items()}
result = {"status": "success", "processed_items": len(processed)}
logger.info(f"Данные пользователя {user_id} обработаны: {result}")
return processed
# Пример использования
sample_data = {"name": "Алексей", "email": "alexey@example.com", "visits": 42}
processed_data = process_user_data(12345, sample_data) |
|
| Python | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
| def debug_context(context):
logger.debug(f"""
Контекст выполнения:
- Пользователь: {context.get('user', 'Гость')}
- Время: {context.get('timestamp', time.time())}
- Параметры: {context.get('params', {})}
- Среда: {context.get('environment', 'production')}
""")
# Пример использования
debug_context({
"user": "admin",
"timestamp": time.time(),
"params": {"action": "export", "format": "csv"},
"environment": "development"
}) |
|
Нестандартные решения и трюки
Иногда стандартные методы форматирования не покрывают все нужды. Рассмотрим несколько нестандартных приемов и трюков, которые могут пригодиться в сложных случаях.
Условное форматирование
Внутри f-строк можно использовать условные выражения, что позволяет создавать динамические шаблоны:
| Python | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
| products = [
{"name": "Ноутбук", "price": 45000, "in_stock": True},
{"name": "Смартфон", "price": 25000, "in_stock": True},
{"name": "Планшет", "price": 15000, "in_stock": False}
]
# Форматирование списка с условным выделением
for i, product in enumerate(products, 1):
status = "В наличии" if product["in_stock"] else "Нет в наличии"
price_color = "green" if product["in_stock"] else "red"
# В консоли можно использовать ANSI-коды для цвета
print(f"{i}. {product['name']} - {product['price']} руб. "
f"({status})") |
|
В некоторых случаях требуется создать строку формата динамически, на основе входных данных:
| Python | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
| def create_table(headers, rows, col_separator='|', align_center=None):
"""
Создает ASCII таблицу из заголовков и строк данных.
align_center - список индексов столбцов, которые нужно центрировать
"""
if align_center is None:
align_center = []
# Определение ширины каждого столбца
col_widths = [max(len(str(row[i])) for row in [headers] + rows)
for i in range(len(headers))]
# Создание строки формата для каждой строки
format_parts = []
for i, width in enumerate(col_widths):
align = '^' if i in align_center else '<'
format_parts.append(f"{{:{align}{width}}}")
row_format = f" {col_separator} ".join(format_parts)
# Создание таблицы
result = []
result.append(row_format.format(*headers))
result.append('-' * (sum(col_widths) + 3 * (len(col_widths) - 1)))
for row in rows:
result.append(row_format.format(*[str(item) for item in row]))
return '\n'.join(result)
# Пример использования
table_headers = ["Товар", "Количество", "Цена", "Сумма"]
table_data = [
["Ноутбук", 2, 45000, 90000],
["Мышь", 5, 1200, 6000],
["Клавиатура", 3, 3500, 10500]
]
print(create_table(table_headers, table_data, align_center=[1, 2, 3])) |
|
Интересное применение форматирования строк — генерация кода или запросов SQL:
| Python | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
| def generate_sql_query(table, fields, conditions=None, order_by=None, limit=None):
"""Генерирует SQL запрос с заданными параметрами"""
query = f"SELECT {', '.join(fields)} FROM {table}"
if conditions:
where_clauses = [f"{k} = '{v}'" if isinstance(v, str) else f"{k} = {v}"
for k, v in conditions.items()]
query += f" WHERE {' AND '.join(where_clauses)}"
if order_by:
query += f" ORDER BY {order_by}"
if limit:
query += f" LIMIT {limit}"
return query + ";"
# Пример использования
query = generate_sql_query(
table="users",
fields=["id", "name", "email"],
conditions={"is_active": 1, "group_id": 5},
order_by="created_at DESC",
limit=100
)
print("Сгенерированный SQL запрос:")
print(query) |
|
При работе со сложными структурами данных часто требуется создавать их удобное текстовое представление:
| Python | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
| def format_tree(node, level=0, indent=" "):
"""Форматирует древовидную структуру для консольного вывода"""
result = []
prefix = indent * level
if isinstance(node, dict):
for key, value in node.items():
if isinstance(value, (dict, list, tuple)):
result.append(f"{prefix}{key}:")
result.append(format_tree(value, level + 1, indent))
else:
result.append(f"{prefix}{key}: {value}")
elif isinstance(node, (list, tuple)):
for item in node:
if isinstance(item, (dict, list, tuple)):
result.append(f"{prefix}-")
result.append(format_tree(item, level + 1, indent))
else:
result.append(f"{prefix}- {item}")
else:
result.append(f"{prefix}{node}")
return '\n'.join(result)
# Пример использования
data = {
"project": "MyApp",
"version": "1.0.0",
"dependencies": [
{"name": "requests", "version": "2.26.0"},
{"name": "flask", "version": "2.0.1"}
],
"settings": {
"debug": True,
"cache": {"enabled": True, "timeout": 3600},
"allowed_hosts": ["localhost", "127.0.0.1"]
}
}
print("Форматированная структура данных:")
print(format_tree(data)) |
|
Сравнение производительности
При выборе метода форматирования строк важно учитывать не только удобство и выразительность кода, но и аспекты производительности. Особенно это актуально для высоконагруженных приложений, где каждая микрооптимизация может иметь значение.
Бенчмарки разных методов
F-строки, метод .format() и оператор % демонстрируют разную производительность при тестировании. Рассмотрим простой бенчмарк:
| Python | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
| import timeit
text = "Привет"
num = 42
# Оператор %
print(timeit.timeit(
'"%s, %d!" % (text, num)',
globals=globals(),
number=1000000
))
# Метод .format()
print(timeit.timeit(
'"{}, {}!".format(text, num)',
globals=globals(),
number=1000000
))
# F-строки
print(timeit.timeit(
'f"{text}, {num}!"',
globals=globals(),
number=1000000
)) |
|
1. F-строки (самые быстрые).
2. Оператор %.
3. Метод .format().
Однако эти различия становятся заметны только при очень большом количестве операций форматирования. Для типичных задач разница в скорости настолько незначительна, что не должна быть основным критерием выбора метода.
Влияние размера строк на производительность
Размер форматируемых строк также влияет на производительность различных методов:
| Python | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
| # Создание строки с большим количеством подстановок
large_format = ' '.join(['{}'] * 100)
large_percent = ' '.join(['%s'] * 100)
values = list(range(100))
# Тестирование метода .format() для больших строк
large_format_time = timeit.timeit(
'large_format.format(*values)',
globals=globals(),
number=10000
)
# Тестирование оператора % для больших строк
large_percent_time = timeit.timeit(
'large_percent % tuple(values)',
globals=globals(),
number=10000
)
# Тестирование f-строк (сложнее создать динамически) |
|
% может быть эффективнее метода .format() при большом количестве замен.
Оптимальные подходы для микросервисов и высоконагруженных систем
В контексте высоконагруженных приложений и микросервисов стоит учитывать следующие моменты:
1. Предварительная подготовка шаблонов: Если один и тот же шаблон используется многократно с разными данными, эффективнее определить его заранее, а не создавать каждый раз:
| Python | 1
2
3
4
5
| # Оптимальный подход для многократного использования
template = "User {}: {} - {}"
def process_user(user_id, name, status):
return template.format(user_id, name, status) |
|
join():
| Python | 1
2
3
4
5
6
7
8
| # Неэффективно
result = ""
for i in range(1000):
result += f"Item {i}: {data[i]}\n"
# Эффективно
result = [f"Item {i}: {data[i]}" for i in range(1000)]
final = "\n".join(result) |
|
Кэширование форматированных строк: когда это оправдано
Кэширование результатов форматирования может значительно повысить производительность при определённых условиях:
| Python | 1
2
3
4
5
6
7
8
| import functools
@functools.lru_cache(maxsize=128)
def get_formatted_message(user_id, template_id):
# Сложные операции по получению шаблона и данных пользователя
template = get_template(template_id)
user_data = get_user_data(user_id)
return template.format(**user_data) |
|
- Форматирование требует затратных операций (загрузка данных из БД).
- Набор уникальных комбинаций входных параметров ограничен.
- Результат форматирования используется многократно без изменений.
Подводные камни при форматировании строк в многопоточных приложениях
В многопоточных приложениях следует учитывать несколько важных моментов:
1. Безопасность формирования шаблонов: Избегайте динамического формирования строковых шаблонов на основе пользовательского ввода:
| Python | 1
2
3
4
| # Потенциально небезопасно в многопоточной среде
user_format = request.get_param("format", "name: {name}")
result = user_format.format([B]user_data) # Возможное место для атаки
[/B] |
|
2. Локальная буферизация: При массовом форматировании в многопоточной среде эффективнее использовать локальные буферы для каждого потока:
| Python | 1
2
3
4
5
6
| def process_batch(items):
buffer = []
for item in items:
formatted = f"{item.id}: {item.name}"
buffer.append(formatted)
return buffer |
|
| Python | 1
2
3
| # Требуется синхронизация при обновлении общего ресурса
with lock:
log_messages.append(f"{thread_id}: {message}") |
|
Для большинства приложений оптимальным выбором будут f-строки благодаря их выразительности и хорошей производительности. В проектах, где требуется совместимость со старыми версиями Python, метод .format() предоставляет хороший баланс между читаемостью и функциональностью. Оператор % сохраняет актуальность для кода, который должен работать с самыми ранними версиями Python, или для простых случаев, где важна максимальная производительность.
Форматирование строк
Нужно вывести параметрическое уравнение плоскости в стандартном виде. Для 3-мерного пространства... Форматирование строк
Дайте совет или помогите понять как реализовать данную задачу:
Написать функцию... Форматирование строк, выравнивание текста
надо сделать так, чтобы текст был выровнен по правому краю, но при этом убрать ненужные пробелы
n... Форматирование строк по правилу
Попалась интересная задача про изменение слов по заданному правилу. Уже несколько дней кручу ее в... Форматирование строк
Напишите программу, которая соберет рецепт печенья из предложенных компонентов.
Формат ввода... Форматирование строк
Этот рецепт пришел к нам с Противовесного Континента. Очень практичная еда, которую удобно брать в... Поиск строк с нужным словом в файле .csv и перезапись этих строк в новый файл Python
Добрый день.
Господа программисты, нужна Ваша помощь.
Возникла необходимость написать... Как из Python скрипта выполнить другой python скрипт?
Как из Python скрипта выполнить другой python скрипт?
Если он находится в той же папке но нужно... Почему синтаксис Python 2.* и Python 3.* так отличается?
Привет!
Решил на досуге заняться изучением Python'a. Читаю книгу по второму питону, а пользуюсь... Что лучше учить Python 2 или Python 3?
хочу начать учить питон но полазив в нете, частенько попадалась информация что вроде как 2 будет... Python without python
Доброго времени суток!
Хотел узнать, что делать с *.py файлом после того как готова программа,... Python 35 Выполнить файл из python shell
Есть файл do.py :
print('start')
import os
import sys
import re
import inspect
def...
|
