Модуль PrettyTable в Python, вывод табличных данных
Вывод табличных данных в терминал или текстовый файл
Модуль prettytable — полезен при создании простых таблиц и вывода их в терминал или текстовый файл. Он был вдохновлен таблицами ASCII, используемыми в оболочке PostgreSQL.
Возможности модуля prettytable :
- установка ширина заполнения столбца, выравнивание текста или граница таблицы;
- сортировка данных;
- выбор отображения столбцов и строк в окончательном выводе;
- чтение данных из CSV, HTML или курсора базы данных;
- вывод данных в ASCII или HTML.
Установка модуля PrettyTable в виртуальное окружение:
# создаем виртуальное окружение $ python3 -m venv .venv --prompt VirtualEnv # активируем виртуальное окружение $ source .venv/bin/activate # ставим модуль prettytable (VirtualEnv) Idea@Centre:~$ python -m pip install -U prettytable
Создание таблицы и добавление данных.
Для начала, необходимо создать экземпляр PrettyTable() , а затем можно добавлять в него некоторые данные. Eсть несколько вариантов добавления данных.
# импорт установленного модуля from prettytable import PrettyTable # создание экземпляра mytable = PrettyTable()
Добавление данных построчно.
Можно добавлять данные по одной строке за раз. Для этого необходимо сначала установить имена полей, используя атрибут PrettyTable.field_names , а затем добавлять строки по одной, используя метод PrettyTable.add_row() :
from prettytable import PrettyTable mytable = PrettyTable() # имена полей таблицы mytable.field_names = ["City name", "Area", "Population", "Annual Rainfall"] # добавление данных по одной строке за раз mytable.add_row(["Adelaide", 1295, 1158259, 600.5]) mytable.add_row(["Brisbane", 5905, 1857594, 1146.4]) mytable.add_row(["Darwin", 112, 120900, 1714.7]) mytable.add_row(["Hobart", 1357, 205556, 619.5]) mytable.add_row(["Sydney", 2058, 4336374, 1214.8]) mytable.add_row(["Melbourne", 1566, 3806092, 646.9]) mytable.add_row(["Perth", 5386, 1554769, 869.4]) # вывод таблицы в терминал print(mytable)
Вид вывода таблицы в терминале
+-----------+------+------------+-----------------+ | City name | Area | Population | Annual Rainfall | +-----------+------+------------+-----------------+ | Adelaide | 1295 | 1158259 | 600.5 | | Brisbane | 5905 | 1857594 | 1146.4 | | Darwin | 112 | 120900 | 1714.7 | | Hobart | 1357 | 205556 | 619.5 | | Sydney | 2058 | 4336374 | 1214.8 | | Melbourne | 1566 | 3806092 | 646.9 | | Perth | 5386 | 1554769 | 869.4 | +-----------+------+------------+-----------------+
Далее будем создавать эту-же таблицу, только разными способами.
Добавление сразу всех строк.
Когда есть список строк, то можно добавить их за один раз с помощью метода PrettyTable.add_rows() :
from prettytable import PrettyTable mytable = PrettyTable() # имена полей таблицы mytable.field_names = ["City name", "Area", "Population", "Annual Rainfall"] # добавление списка строк mytable.add_rows( [ ["Adelaide", 1295, 1158259, 600.5], ["Brisbane", 5905, 1857594, 1146.4], ["Darwin", 112, 120900, 1714.7], ["Hobart", 1357, 205556, 619.5], ["Sydney", 2058, 4336374, 1214.8], ["Melbourne", 1566, 3806092, 646.9], ["Perth", 5386, 1554769, 869.4], ] ) print(mytable)
Добавление данных колонками.
Также можно добавлять данные по одному столбцу за раз. Для этого необходимо использовать метод PrettyTable.add_column() , который принимает два аргумента — строку, которая является именем поля таблицы добавляемого столбца, и список или кортеж, содержащий данные столбца:
from prettytable import PrettyTable mytable = PrettyTable() # Добавление колонки таблицы с именем 'City name' mytable.add_column("City name", ["Adelaide", "Brisbane", "Darwin", "Hobart", "Sydney", "Melbourne", "Perth"]) # Добавление колонки таблицы с именем 'Area' mytable.add_column("Area", [1295, 5905, 112, 1357, 2058, 1566, 5386]) # Добавление колонки таблицы с именем 'Population' mytable.add_column("Population", [1158259, 1857594, 120900, 205556, 4336374, 3806092, 1554769]) # Добавление колонки таблицы с именем 'Annual Rainfall' mytable.add_column("Annual Rainfall", [600.5, 1146.4, 1714.7, 619.5, 1214.8, 646.9, 869.4]) print(mytable)
Импорт данных из файла CSV.
Если данные таблицы хранятся в файле CSV, то можно прочитать эти данные и добавить в таблицу PrettyTable() следующим образом:
# импорт загрузчика `from_csv` from prettytable import from_csv with open("myfile.csv") as fp: # создание таблицы из `myfile.csv` mytable = from_csv(fp) print(mytable)
Импорт данных из курсора базы данных.
Если данные таблицы хранятся в базе данных, к которой можно получить доступ с помощью модуля имеющего Python DB-API (например, база данных SQLite, доступная с помощью модуля sqlite3 ), то можно создать экземпляр PrettyTable() с данными, используя объект курсора, например:
import sqlite3 # импорт загрузчика `from_db_cursor` from prettytable import from_db_cursor connection = sqlite3.connect("mydb.db") cursor = connection.cursor() cursor.execute("SELECT field1, field2, field3 FROM my_table") # создание таблицы из объекта курсора mytable = from_db_cursor(cursor) print(mytable)
- КРАТКИЙ ОБЗОР МАТЕРИАЛА.
- Печать табличных данных в файл, модуль prettytable
- Удаление данных из таблицы, модуль prettytable
- Управление выводом таблицы, модуль prettytable
- Управление внешним видом таблицы, модуль prettytable
- Генерация HTML и JSON при помощи prettytable
Управление выводом таблицы, модуль prettytable в Python
Модуль prettytable позволяет управлять выводом таблицы, например можно ограничить вывод только теми полями или строками, которые необходимы к просмотру.
Создадим таблицу с которой будем работать:
from prettytable import PrettyTable mytable = PrettyTable() mytable.field_names = ["City name", "Area", "Population", "Annual Rainfall"] mytable.add_rows( [ ["Adelaide", 1295, 1158259, 600.5], ["Brisbane", 5905, 1857594, 1146.4], ["Darwin", 112, 120900, 1714.7], ["Hobart", 1357, 205556, 619.5], ] )
Управление выводом данных таблицы осуществляется методом PrettyTable.get_string() .
Управление выводом колонок.
Аргумент fields метода PrettyTable.get_string() принимает список имен полей, которые нужно напечатать:
>>> table = mytable.get_string(fields=["City name", "Population"]) >>> print(table) #+-----------+------------+ #| City name | Population | #+-----------+------------+ #| Adelaide | 1158259 | #| Brisbane | 1857594 | #| Darwin | 120900 | #| Hobart | 205556 | #+-----------+------------+
Управление выводом строк.
Аргументы start и end метода PrettyTable.get_string() принимают индекс первой и последней строки для печати соответственно.
Обратите внимание, что индексация работает так же, как срезы списка Python — для печати 3-й и 4-й строк таблицы установите start равным 2 (первая строка — это строка 0, поэтому третья — это строка 2) и установите end на 4 (индекс 4-ой строки, плюс 1):
>>> table = mytable.get_string(start=2, end=4) >>> print(table) #+-----------+------+------------+-----------------+ #| City name | Area | Population | Annual Rainfall | #+-----------+------+------------+-----------------+ #| Darwin | 112 | 120900 | 1714.7 | #| Hobart | 1357 | 205556 | 619.5 | #+-----------+------+------------+-----------------+
Управление сортировкой данных в таблице.
Аргументы sortby метода PrettyTable.get_string() , который принимает строку с именем одного поля, отсортирует данный столбец таблицы по возрастанию (от меньшего к большему).
>>> table = mytable.get_string(sortby='Area') >>> print(table) #+-----------+------+------------+-----------------+ #| City name | Area | Population | Annual Rainfall | #+-----------+------+------------+-----------------+ #| Darwin | 112 | 120900 | 1714.7 | #| Adelaide | 1295 | 1158259 | 600.5 | #| Hobart | 1357 | 205556 | 619.5 | #| Brisbane | 5905 | 1857594 | 1146.4 | #+-----------+------+------------+-----------------+
Если необходимо отсортировать в обратном порядке, то в метод нужно добавить ключевой аргумент reversesort=True .
>>> table = mytable.get_string(sortby='Area', reversesort=True) >>> print(table) #+-----------+------+------------+-----------------+ #| City name | Area | Population | Annual Rainfall | #+-----------+------+------------+-----------------+ #| Brisbane | 5905 | 1857594 | 1146.4 | #| Hobart | 1357 | 205556 | 619.5 | #| Adelaide | 1295 | 1158259 | 600.5 | #| Darwin | 112 | 120900 | 1714.7 | #+-----------+------+------------+-----------------+
Если необходимо, чтобы таблицы сортировались всегда определенным образом, то можно сделать этот параметр долгосрочным при помощи атрибута экземпляра класса PrettyTable.sortby :
# сортировка по колонке `Population` >>> mytable.sortby = "Population" # отсортирует вывод по колонке `Population` >>> print(mytable)
Теперь, команда print(mytable) напечатает таблицу, отсортированную по колонке Population . Также, при помощи атрибута mytable.reversesort = True можно сортировать таблицу по колонке, указанной в mytable.sortby — в обратном порядке. Такое поведение будет сохраняться, пока не отключить сортировку атрибутом x.sortby = None .
# отключение сортировки >>> mytable.sortby = None # выведет таблицу в исходном виде >>> print(mytable)
Если нужно указать пользовательскую функцию сортировки, то можно использовать ключевой аргумент sort_key .
Передайте аргументу sort_key функцию, которая принимает два списка значений и возвращает отрицательное или положительное значение в зависимости от того, должен ли первый список появляться до или после второго. Если в таблице n столбцов, то в каждом списке будет n + 1 элемент. Каждый список соответствует одной строке таблицы. Первым элементом будут данные из соответствующей строки в столбце, заданном аргументом sort_by . Остальные n элементов — это данные в каждом столбце таблицы по порядку, включая повторяющийся экземпляр данных в столбце sort_by .
- КРАТКИЙ ОБЗОР МАТЕРИАЛА.
- Печать табличных данных в файл, модуль prettytable
- Удаление данных из таблицы, модуль prettytable
- Управление выводом таблицы, модуль prettytable
- Управление внешним видом таблицы, модуль prettytable
- Генерация HTML и JSON при помощи prettytable
PrettyTable — вывод табличных данных в ASCII
PrettyTable — это библиотека Python, разработанная для простого и быстрого отображения табличных данных в визуально удобных таблицах ASCII.
Введение
По словам автора библиотеки он был очень вдохновлен таблицами ASCII, используемых в оболочке PostgreSQL. PrettyTable позволяет выбирать, какие столбцы должны быть напечатаны, производить независимое выравнивание столбцов, а так же печать частично таблицы путем указания диапазона строк.
Установка
Существует возможность установить стабильную версию или же экспериментальную, на ваш выбор, воспользуемся для этого пакетным менеджером
Стабильная версия
Воспользуемся пакетным менеджером pip для установки из репозитория
pip install -U prettytable
Эксперементальная версия
Метод установки схожий со стабильной версией, но теперь мы устанавливаем ее из репозитория автора на github.
pip install -U git+https://github.com/jazzband/prettytable
Использование
Создадим объект prettytable или другими словами пустую таблицу.
from prettytable import PrettyTable x = PrettyTable()
Для того чтобы поместить в него наши данные, у нас есть несколько способов это выполнить.
Построчный ввод
Вы можете добавлять данные по одной строке за раз. Для этого можно сначала задать имена полей с помощью атрибута field_names, а затем добавить строки по одной с помощью метода add_row:
x.field_names = ["Сотрудник", "Возраст", "Должность", "Оклад"] x.add_row(["Николай", 43, "Плотник", 25000]) x.add_row(["Андрей", 29, "Менеджер", 30000]) x.add_row(["Анатолий", 19, "Практикант", 12500]) x.add_row(["Юлия", 27, "Секретарь", 35000]) x.add_row(["Наталья", 35, "Руководитель отдела продаж", 40000]) x.add_row(["Екатерина", 30, "Менеджер", 27000]) x.add_row(["Георгий", 44, "Охранник", 17500])
Ввод данных по одному столбцу
Вы также можете добавлять данные по одному столбцу за раз. Для этого используется метод add_column, который принимает два аргумента, название столбца и список или кортеж, содержащий значения.
x.add_column("Сотрудник", ["Николай", "Андрей", "Анатолий", "Юлия", "Наталья", "Екатерина", "Георгий"]) x.add_column("Возраст", [43, 29, 19, 27, 35, 30, 44]) x.add_column("Должность", ["Плотник", "Менеджер", "Практикант", "Секретарь", "Руководитель отдела продаж", "Менеджер", "Охранник"]) x.add_column("Annual Оклад", [25000, 30000, 12500, 35000, 40000, 27000, 17500])
Импорт данных из CSV-файла
Если вы храните данные в таблицах CSV вы можете прочитать эти данные в красивую таблицу всего парой строк кода:
from prettytable import from_csv f = open("table.csv", "r") table = from_csv(f) f.close()
Импорт из базы данных
Если вы храните информацию в реляционных базах данных, то при наличии поддержки Python DB-API в реализации ее библиотеке вы сможете импортировать их в таблицу с помощью объекта курсора
import sqlite3 from prettytable import from_cursor conn = sqlite3.connect("db.sqlite3") cur = conn.cursor() cur.execute("SELECT field FROM table WHERE = from_cursor(cur)
Удаление данных
Существует три способа удаления данных
- Метод del_row принимает целочисленный индекс одной строки для удаления.
- Метод clear_rows не принимает аргументов и удаляет все строки в таблице, но сохраняет имена полей такими, какими они были, чтобы вы могли повторно заполнить их данными.
- Метод clear не принимает аргументов и удаляет все строки и все имена полей. Это не совсем то же самое, что создание нового экземпляра таблицы, хотя связанные со стилем настройки сохраняются.
Отображение вашей таблицы в ASCII
Основная цель PrettyTable — позволить вам печатать таблицы в привлекательной форме ASCII, например так:
+-----------+---------+----------------------------+-------+ | Сотрудник | Возраст | Должность | Оклад | +-----------+---------+----------------------------+-------+ | Николай | 43 | Плотник | 25000 | | Андрей | 29 | Менеджер | 30000 | | Анатолий | 19 | Практикант | 12500 | | Юлия | 27 | Секретарь | 35000 | | Наталья | 35 | Руководитель отдела продаж | 40000 | | Екатерина | 30 | Менеджер | 27000 | | Георгий | 44 | Охранник | 17500 | +-----------+---------+----------------------------+-------+Распечатать таблицу в формате ASCII очень просто, достаточно сделать это:
print(x)
Заключение
Мы рассмотрели библиотеку PrettyTable, варианты ее установки, принципы использования, построчный ввод, импорт данных из csv таблицы и базы данных.
Это не полный функционал, более подробную информацию об использование параметров таблицы, сортировки данных, печать в другие форматы (HTML/JSON) вы можете найти на официальной странице разработчика
Модуль Prettytable в Python – вывод таблиц ASCII
В этом руководстве мы научимся создавать реляционную таблицу с помощью модуля Python Prettytable. Мы будем создавать таблицы без использования внешних библиотек.
Что такое Pretty Table в Python?
Prettytable в Python – это визуальное отображение данных в табличной форме в формате таблиц ASCII, которые просты в использовании. Библиотека prettytable состоит из класса PrettyTable, который используется для создания реляционных таблиц. Чтобы работать с этой библиотекой, нам нужно установить ее с помощью следующей команды.
pip install prettytable
Создание таблицы с помощью Pretty Table
Давайте на примере создадим построчную таблицу с помощью модуля pretty table.
Пример 1: построчный способ.
from prettytable import PrettyTable # Creating a new table newTable = PrettyTable(["Student Name", "Class", "Subject", "Makrs"]) # Add rows newTable.add_row(["Camron", "X", "English", "91"]) newTable.add_row(["Haris", "X", "Math", "63"]) newTable.add_row(["Jenny", "X", "Science", "90"]) newTable.add_row(["Bernald", "X", "Art", "92"]) newTable.add_row(["Jackson", "X", "Science", "98"]) newTable.add_row(["Samual", "X", "English", "88"]) newTable.add_row(["Stark", "X", "English", "95"]) print(newTable)
+--------------+-------+---------+-------+ | Student Name | Class | Subject | Makrs | +--------------+-------+---------+-------+ | Camron | X | English | 91 | | Haris | X | Math | 63 | | Jenny | X | Science | 90 | | Bernald | X | Art | 92 | | Jackson | X | Science | 98 | | Samual | X | English | 88 | | Stark | X | English | 95 | +--------------+-------+---------+-------+
Пример – 2: столбцовый способ.
from prettytable import PrettyTable columns = ["Student Name", "Class", "Subject", "Marks"] newTable = PrettyTable() # Add Columns newTable.add_column(columns[0], ["Jacob", "Peter", "Grenger", "Stark", "Falcon", "Matthew", "Jackson"]) newTable.add_column(columns[1], ["X", "X", "X", "X", "X", "X", "X"]) newTable.add_column(columns[2], ["English", "Art", "Science", "Math", "Science", "English", "English"]) newTable.add_column(columns[3], ["91", "63", "90", "92", "98", "83", "95"]) print(newTable)
+--------------+-------+---------+-------------------+ | Student Name | Class | Subject | Marks | +--------------+-------+---------+-------------------+ | Jacob | X | English | 91 | | Peter | X | Art | 63 | | Grenger | X | Science | 90 | | Stark | X | Math | 92 | | Falcon | X | Science | 98 | | Matthew | X | English | 83 | | Jackson | X | English | 95 | +--------------+-------+---------+------------------+
Мы использовали метод add_column() модуля pretty table.
Пример 3: добавить строки за один раз.
from prettytable import PrettyTable # Creating a new table newTable = PrettyTable(["Student Name", "Class", "Subject", "Makrs"]) # # Add rows newTable.add_rows( [ ["Camron", "X", "English", "91"], ["Haris", "X", "Math", "63"], ["Jenny", "X", "Science", "90"], ["Bernald", "X", "Art", "92"], ["Jackson", "X", "Science", "98"], ["Samual", "X", "English", "88"], ["Stark", "X", "English", "95"], ] ) print(newTable)
+--------------+-------+---------+-------+ | Camron | X | English | 91 | | Haris | X | Math | 63 | | Jenny | X | Science | 90 | | Bernald | X | Art | 92 | | Jackson | X | Science | 98 | | Samual | X | English | 88 | | Stark | X | English | 95 | +--------------+-------+---------+-------+
Удаление строк в PrettyTable
Этот модуль предоставляет метод del_row(), который позволяет нам удалять строки. Для удаления строки требуется знать значение индекса, который нужно удалить. Индексация начинается с нуля. Давайте разберемся в следующем коде.
from prettytable import PrettyTable # Creating a new table newTable = PrettyTable(["Student Name", "Class", "Subject", "Makrs"]) # # Add rows newTable.add_row(["Camron", "X", "English", "91"]) newTable.add_row(["Haris", "X", "Math", "63"]) newTable.add_row(["Jenny", "X", "Science", "90"]) newTable.add_row(["Bernald", "X", "Art", "92"]) newTable.add_row(["Jackson", "X", "Science", "98"]) newTable.add_row(["Samual", "X", "English", "88"]) newTable.add_row(["Stark", "X", "English", "95"]) newTable.del_row(1) newTable.del_row(2) newTable.del_row(3) print(newTable)
+--------------+-------+---------+-------+ | Student Name | Class | Subject | Makrs | +--------------+-------+---------+-------+ | Camron | X | English | 91 | | Jenny | X | Science | 90 | | Jackson | X | Science | 98 | | Stark | X | English | 95 | +--------------+-------+---------+-------+
Мы удалили определенные строки из таблицы. Чтобы очистить всю таблицу, мы используем следующий метод:
myTable.clear_rows()
from prettytable import PrettyTable # Creating a new table newTable = PrettyTable(["Student Name", "Class", "Subject", "Makrs"]) # # Add rows newTable.add_row(["Camron", "X", "English", "91"]) newTable.add_row(["Haris", "X", "Math", "63"]) newTable.add_row(["Jenny", "X", "Science", "90"]) newTable.add_row(["Bernald", "X", "Art", "92"]) newTable.add_row(["Jackson", "X", "Science", "98"]) newTable.add_row(["Samual", "X", "English", "88"]) newTable.add_row(["Stark", "X", "English", "95"]) newTable.clear_rows() print(newTable)
+--------------+-------+---------+------------------+ | Student Name | Class | Subject | Makrs | +--------------+-------+---------+--------------------+ +--------------+-------+---------+--------------------+
Как видно из приведенного выше кода, все строки были удалены. Мы можем видеть только названия столбцов.
Получение определенных строк и столбцов
Основная цель prettytable – получить таблицы в формате ASCII. Мы можем ограничить вывод таблицы, используя следующий метод.
get_string(fields=["Column 1", "Column2", . ColumnN]
Давайте разберемся в следующем примере.
from prettytable import PrettyTable # Creating a new table newTable = PrettyTable(["Student Name", "Class", "Subject", "Makrs"]) # # Add rows newTable.add_rows( [ ["Camron", "X", "English", "91"], ["Haris", "X", "Math", "63"], ["Jenny", "X", "Science", "90"], ["Bernald", "X", "Art", "92"], ["Jackson", "X", "Science", "98"], ["Samual", "X", "English", "88"], ["Stark", "X", "English", "95"], ] ) print(newTable.get_string(fields=["Student Name", "Class"]))
+--------------+--------------+ | Student Name | Class | +--------------+--------------+ | Camron | X | | Haris | X | | Jenny | X | | Bernald | X | | Jackson | X | | Samual | X | | Stark | X | +--------------+---------------+
Аргумент поля принимает список имен для печати.
Мы также можем использовать следующий метод для проверки результата.
print(newTable.get_string(start=1, end=4)
+--------------+-------+---------+-------------------+ | Student Name | Class | Subject | Makrs | +--------------+-------+---------+-------------------+ | Camron | X | English | 91 | | Haris | X | Math | 63 | | Jenny | X | Science | 90 | +--------------+-------+---------+------------------+
Изменение формата выравнивания столбца
Мы можем заметить, что все столбцы в таблице выровнены по центру. Мы можем изменить его в соответствии с требованиями, назначив один символ для выравнивания атрибута. Есть три строки выравнивания – «l» (для левого), «r» (для правого) и «c» (для центра), соответственно.
Посмотрим на следующий пример:
newTable.align = 'r' print(newTable)
+--------------+-------+---------+-------------------+ | Student Name | Class | Subject | Makrs | +--------------+-------+---------+------------------+ | Camron | X | English | 91 | | Haris | X | Math | 63 | | Jenny | X | Science | 90 | | Bernald | X | Art | 92 | | Jackson | X | Science | 98 | | Samual | X | English | 88 | | Stark | X | English | 95 | +--------------+-------+---------+------------------+
Изменение внешнего вида таблицы
Таблица по умолчанию выглядит как оболочка базы данных SQL. Однако мы можем изменить внешний вид таблицы на другой формат. Модуль prettytable предоставляет метод set_style(), преобразующий таблицу в MSWord.
Пример. Добавим следующий код в программу создания таблицы.
from prettytable import MSWORD_FRIENDLY newTable.set_style(MSWORD_FRIENDLY) print(newTable)
| Student Name | Class | Subject | Makrs | | Camron | X | English | 91 | | Haris | X | Math | 63 | | Jenny | X | Science | 90 | | Bernald | X | Art | 92 | | Jackson | X | Science | 98 | | Samual | X | English | 88 | | Stark | X | English | 95 |
Мы ясно видим разницу между таблицей по умолчанию и таблицей, дружественной с MSWord.
Заключение
Мы обсудили некоторые важные операции с табличными данными, используя модуль prettytable. Это очень эффективный модуль для работы с таблицами с использованием скрипта Python.