Как выравнивать вывод при печати в Python

Введение

При написании программ на Python представление вывода в чистом и организованном виде является важным как для читаемости кода, так и для пользовательского опыта. Независимо от того, создаете ли вы отчеты, отображаете табличные данные или просто выводите информацию в консоль, правильное выравнивание текста делает вывод более профессиональным и легким для чтения.

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

Базовое выравнивание строк в Python

На этом первом этапе вы узнаете о фундаментальных концепциях выравнивания текста в Python и реализуете базовые техники выравнивания.

Что такое выравнивание текста?

Выравнивание текста относится к тому, как текст располагается в заданном пространстве. Python предоставляет несколько методов для управления позиционированием текста при выводе в консоль. Три основные типы выравнивания:

• Выравнивание по левому краю: Текст начинается с левого края выделенного пространства.
• Выравнивание по правому краю: Текст заканчивается на правом краю выделенного пространства.
• Центрирование: Текст центрируется в выделенном пространстве.

Ваша первая программа по выравниванию

Создадим простой скрипт на Python, чтобы продемонстрировать базовые техники выравнивания.

1. Откройте WebIDE в среде LabEx.

2. Создайте новый файл с именем basic_alignment.py в директории /home/labex/project, нажав на иконку "New File" в WebIDE.

3. Добавьте следующий код в файл:

## basic_alignment.py
print("Basic String Alignment Examples")
print("-" * 30)

## Left alignment example
print("Left alignment:")
print("Python".ljust(20) + "|")
print("Programming".ljust(20) + "|")
print("Alignment".ljust(20) + "|")
print()

## Right alignment example
print("Right alignment:")
print("Python".rjust(20) + "|")
print("Programming".rjust(20) + "|")
print("Alignment".rjust(20) + "|")
print()

## Center alignment example
print("Center alignment:")
print("Python".center(20) + "|")
print("Programming".center(20) + "|")
print("Alignment".center(20) + "|")

4. Сохраните файл, нажав Ctrl+S или выбрав "File" > "Save" из меню.

5. Откройте терминал в WebIDE (если он еще не открыт), нажав на меню "Terminal" и выбрав "New Terminal".

6. Запустите скрипт с помощью интерпретатора Python:

cd ~/project
python3 basic_alignment.py

7. Вы должны увидеть следующий вывод:

Basic String Alignment Examples
------------------------------
Left alignment:
Python              |
Programming         |
Alignment           |

Right alignment:
              Python|
         Programming|
           Alignment|

Center alignment:
       Python       |
     Programming    |
      Alignment     |

Понимание кода

Скрипт, который вы только что создали, демонстрирует три базовых метода выравнивания строк в Python:

• ljust(width): Выравнивает строку по левому краю в поле заданной ширины.
• rjust(width): Выравнивает строку по правому краю в поле заданной ширины.
• center(width): Центрирует строку в поле заданной ширины.

В каждом примере мы добавили вертикальную черту (|) в конце каждой строки, чтобы ясно показать границу выделенного пространства. Обратите внимание, как текст выравнивается по-разному в каждом случае, при этом общая ширина остается равной 20 символам.

Выравнивание строк с использованием разных символов

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

1. Создайте новый файл с именем alignment_with_chars.py в директории /home/labex/project.

2. Добавьте следующий код в файл:

## alignment_with_chars.py
print("String Alignment With Custom Characters")
print("-" * 40)

## Using different padding characters
print("Left alignment with dots:")
print("Python".ljust(20, '.') + "|")
print("Programming".ljust(20, '.') + "|")
print()

print("Right alignment with asterisks:")
print("Python".rjust(20, '*') + "|")
print("Programming".rjust(20, '*') + "|")
print()

print("Center alignment with hyphens:")
print("Python".center(20, '-') + "|")
print("Programming".center(20, '-') + "|")

3. Сохраните файл и запустите его:

python3 ~/project/alignment_with_chars.py

4. Вы должны увидеть такой вывод:

String Alignment With Custom Characters
----------------------------------------
Left alignment with dots:
Python..............|
Programming.........|

Right alignment with asterisks:
**************Python|
*********Programming|

Center alignment with hyphens:
-------Python------|
----Programming----|

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

Расширенные методы форматирования для выравнивания

В предыдущем шаге вы узнали о базовом выравнивании строк с помощью методов ljust(), rjust() и center(). Теперь давайте рассмотрим более мощные и гибкие методы форматирования, доступные в Python.

Методы форматирования строк в Python

Python предлагает несколько способов форматирования строк:

1. Форматирование старого стиля (используя оператор %)
2. Метод str.format()
3. F-строки (форматируемые строковые литералы, доступные в Python 3.6+)

Каждый метод предоставляет способы выравнивания текста и форматирования различных типов данных. Давайте рассмотрим их по одному.

1. Форматирование старого стиля (% Оператор)

Это самый старый метод форматирования строк в Python, аналогичный функции printf() языка C.

1. Создайте новый файл с именем old_style_formatting.py в каталоге /home/labex/project:

## old_style_formatting.py
print("Форматирование строк старого стиля")
print("-" * 30)

## Выравнивание влево с помощью форматирования %
print("Выравнивание влево:")
print("%-15s | %-10s" % ("Python", "Язык"))
print("%-15s | %-10s" % ("JavaScript", "Веб"))
print()

## Выравнивание вправо с помощью форматирования %
print("Выравнивание вправо:")
print("%15s | %10s" % ("Python", "Язык"))
print("%15s | %10s" % ("JavaScript", "Веб"))
print()

## Форматирование чисел
price = 125.5
tax_rate = 0.21
print("Цена: $%8.2f" % price)
print("Ставка налога: %6.1f%%" % (tax_rate * 100))
print("Сумма налога: $%6.2f" % (price * tax_rate))
print("Итого: $%8.2f" % (price * (1 + tax_rate)))

2. Сохраните файл и запустите его:

python3 ~/project/old_style_formatting.py

3. Вы увидите вывод, похожий на этот:

Форматирование строк старого стиля
------------------------------
Выравнивание влево:
Python          | Язык
JavaScript      | Веб

Выравнивание вправо:
         Python |  Язык
     JavaScript |       Веб

Форматирование чисел:
Цена: $   125.50
Ставка налога:   21.0%
Сумма налога: $ 26.36
Итого: $   151.86

2. Метод str.format()

Метод str.format() предоставляет более универсальный способ форматирования строк и был введен для решения некоторых ограничений оператора %.

1. Создайте новый файл с именем format_method.py в каталоге /home/labex/project:

## format_method.py
print("Форматирование строк с помощью str.format()")
print("-" * 35)

## Базовое выравнивание с помощью format
print("Базовое выравнивание:")
print("{:<15} | {:<10}".format("Python", "Язык"))
print("{:>15} | {:>10}".format("Python", "Язык"))
print("{:^15} | {:^10}".format("Python", "Язык"))
print()

## Выравнивание с пользовательским символом заполнения
print("Пользовательский символ заполнения:")
print("{:*<15} | {:.>10}".format("Python", "Язык"))
print("{:#^15} | {:=^10}".format("Python", "Язык"))
print()

## Выравнивание с именами полей
print("Использование имён полей:")
print("{name:<15} | {type:<10}".format(name="JavaScript", type="Веб"))
print("{name:>15} | {type:>10}".format(name="Python", type="Язык"))
print()

## Форматирование чисел
price = 125.5
tax_rate = 0.21
print("Форматирование чисел:")
print("Цена: ${:8.2f}".format(price))
print("Ставка налога: {:6.1f}%".format(tax_rate * 100))
print("Сумма налога: ${:6.2f}".format(price * tax_rate))
print("Итого: ${:8.2f}".format(price * (1 + tax_rate)))

2. Сохраните файл и запустите его:

python3 ~/project/format_method.py

3. Вы увидите вывод, похожий на этот:

Форматирование строк с помощью str.format()
-----------------------------------
Базовое выравнивание:
Python          | Язык
         Python |   Язык
    Python      |  Язык

Пользовательский символ заполнения:
Python********* | Язык...
#####Python##### | ==Язык==

Использование имён полей:
JavaScript      | Веб
         Python |  Язык

Форматирование чисел:
Цена: $  125.50
Ставка налога:   21.0%
Сумма налога: $ 26.36
Итого: $  151.86

3. F-строки (Python 3.6+)

F-строки предоставляют лаконичный и удобный способ встраивания выражений внутри строковых литералов. Они предваряются буквой 'f' и используют фигурные скобки {} для включения выражений.

1. Создайте новый файл с именем f_strings.py в каталоге /home/labex/project:

## f_strings.py
print("Форматирование строк с помощью F-строк")
print("-" * 35)

language = "Python"
category = "Язык"
version = 3.10
year = 2022

## Базовое выравнивание с помощью f-строк
print("Базовое выравнивание:")
print(f"{language:<15} | {category:<10}")
print(f"{language:>15} | {category:>10}")
print(f"{language:^15} | {category:^10}")
print()

## Динамическая ширина
width1 = 15
width2 = 10
print("Динамическая ширина:")
print(f"{language:<{width1}} | {category:<{width2}}")
print(f"{language:>{width1}} | {category:>{width2}}")
print()

## Выражения внутри f-строк
print("Выражения в f-строках:")
print(f"{language + ' ' + str(version):<15} | {year - 1991:>10} лет")
print()

## Форматирование чисел
price = 125.5
tax_rate = 0.21
print("Форматирование чисел:")
print(f"Цена: ${price:8.2f}")
print(f"Ставка налога: {tax_rate * 100:6.1f}%")
print(f"Сумма налога: ${price * tax_rate:6.2f}")
print(f"Итого: ${price * (1 + tax_rate):8.2f}")

2. Сохраните файл и запустите его:

python3 ~/project/f_strings.py

3. Вы увидите вывод, похожий на этот:

Форматирование строк с помощью F-строк
-----------------------------------
Базовое выравнивание:
Python          | Язык
         Python |  Язык
    Python      | Язык

Динамическая ширина:
Python          | Язык
         Python |  Язык

Выражения в f-строках:
Python 3.1      |         31 лет

Форматирование чисел:
Цена: $  125.50
Ставка налога:   21.0%
Сумма налога: $ 26.36
Итого: $  151.86

Сравнение методов форматирования

Каждый метод форматирования имеет свои преимущества. Вот когда использовать каждый из них:

• Оператор %: Используйте в устаревшем коде или когда необходима совместимость со старыми версиями Python.
• str.format(): Более мощный, чем форматирование %, особенно для сложных требований форматирования.
• F-строки: Самый лаконичный и читаемый вариант, рекомендуется для всего нового кода Python (Python 3.6+).

Современная тенденция в Python — использовать f-строки всякий раз, когда это возможно, благодаря их удобочитаемости и производительности.

Создание форматированных таблиц с помощью Python

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

Простая таблица с колонками фиксированной ширины

Начнём с создания простой таблицы с колонками фиксированной ширины.

1. Создайте новый файл с именем simple_table.py в каталоге /home/labex/project:

## simple_table.py
print("Простая таблица фиксированной ширины")
print("-" * 50)

## Определите данные
header = ["Имя", "Возраст", "Город", "Профессия"]
data = [
    ["John Smith", 34, "New York", "Врач"],
    ["Sarah Johnson", 28, "San Francisco", "Инженер"],
    ["Michael Brown", 42, "Chicago", "Учитель"],
    ["Emily Davis", 31, "Boston", "Учёный"]
]

## Вывод заголовка
print(f"{header[0]:<20} {header[1]:<8} {header[2]:<15} {header[3]:<15}")
print("-" * 60)

## Вывод строк
for row in data:
    print(f"{row[0]:<20} {row[1]:<8} {row[2]:<15} {row[3]:<15}")

2. Сохраните файл и запустите его:

python3 ~/project/simple_table.py

3. Вы увидите аккуратно отформатированную таблицу, подобную этой:

Простая таблица фиксированной ширины
--------------------------------------------------
Имя                 Возраст   Город            Профессия
------------------------------------------------------------
John Smith           34       New York        Врач
Sarah Johnson        28       San Francisco   Инженер
Michael Brown        42       Chicago         Учитель
Emily Davis          31       Boston          Учёный

Динамическая таблица с различными типами выравнивания

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

1. Создайте новый файл с именем dynamic_table.py в каталоге /home/labex/project:

## dynamic_table.py
print("Динамическая таблица с комбинированным выравниванием")
print("-" * 50)

## Определите данные
header = ["Продукт", "Цена", "Количество", "Итого"]
products = [
    ["Ноутбук", 1299.99, 3, 3899.97],
    ["Мышь", 24.50, 10, 245.00],
    ["Монитор", 349.95, 2, 699.90],
    ["Клавиатура", 49.99, 5, 249.95],
    ["Наушники", 89.95, 4, 359.80]
]

## Расчёт ширины колонок на основе содержимого
col_widths = [
    max(len(str(header[0])), max(len(str(row[0])) for row in products)) + 2,
    max(len(str(header[1])), max(len(f"${row[1]:.2f}") for row in products)) + 2,
    max(len(str(header[2])), max(len(str(row[2])) for row in products)) + 2,
    max(len(str(header[3])), max(len(f"${row[3]:.2f}") for row in products)) + 2
]

## Вывод заголовка
print(f"{header[0]:<{col_widths[0]}}"
      f"{header[1]:>{col_widths[1]}}"
      f"{header[2]:>{col_widths[2]}}"
      f"{header[3]:>{col_widths[3]}}")
print("-" * sum(col_widths))

## Вывод строк с соответствующим выравниванием
for product in products:
    print(f"{product[0]:<{col_widths[0]}}",
          f"${product[1]:.2f}".rjust(col_widths[1]),
          f"{product[2]}".rjust(col_widths[2]),
          f"${product[3]:.2f}".rjust(col_widths[3]))

## Вывод итогов
total_quantity = sum(product[2] for product in products)
total_cost = sum(product[3] for product in products)
print("-" * sum(col_widths))
print(f"{'ИТОГО':<{col_widths[0]}}",
      f"".rjust(col_widths[1]),
      f"{total_quantity}".rjust(col_widths[2]),
      f"${total_cost:.2f}".rjust(col_widths[3]))

... (остальная часть кода и текста документации)

Резюме

В этом практическом занятии вы узнали различные техники выравнивания и форматирования текстового вывода в Python:

• Базовые методы выравнивания строк: ljust(), rjust() и center()
• Различные подходы к форматированию строк: оператор %, метод str.format() и f-строки
• Как создавать хорошо структурированные таблицы с фиксированной шириной столбцов
• Как применять разные стили выравнивания в зависимости от типов данных
• Как создавать реальные приложения, такие как финансовые отчеты, с правильным форматированием

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

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