Prettytable python как работать

Модуль 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) в столбик?

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

from prettytable import PrettyTable slovar_1 = slovar_2 = slovar_3 = name = ["Debt To equity Ratio", "Current Ratio", "Total Ratio"] index = [sorted(slovar_1.items(), reverse=True, key=lambda para: para[1]), sorted(slovar_2.items(), reverse=True, key=lambda para: para[1]), sorted(slovar_3.items(), reverse=True, key=lambda para: para[1])] table = PrettyTable(name) data = index[:] table.add_row(data[:]) data = data[:] print(table)

Для таблицы словари уже отсортированы (от большего к меньшему).
Вся проблема в выводе данных в одну длинную строку(приложил скрин).

А нужно что бы было так.

Вопрос задан более двух лет назад
269 просмотров

Читать:

Tools visual studio где находится

Комментировать

Решения вопроса 1

Судя по документации, можно просто добавлять колонками вместо строк

from prettytable import PrettyTable slovar_1 = slovar_2 = slovar_3 = name = ["Debt To equity Ratio", "Current Ratio", "Total Ratio"] table = PrettyTable() table.add_column(name[0], list(slovar_1.items())) table.add_column(name[1], list(slovar_2.items())) table.add_column(name[2], list(slovar_3.items())) print(table)

Ответ написан более двух лет назад

Нравится 1 1 комментарий

Таблицы SQLite + Python: SELECT, INSERT, CREATE TABLE

Часто мы делаем маленькие проекты, которые требуют хранения данных. Мы используем для этого json, txt и другие файлы. В таких ситуациях нам может помочь база данных SQLite3, специально созданная для небольших задач.

В этой БД не используется модель клиент-сервер, как в MySQL или PostgreSQL. База данных SQLite3 находится локально, она сама выступает в роли и клиента, и сервера. Это утверждение немного грубо, но будем придерживается его.

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

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

Компьютер или ноутбук
Редактор кода (У меня PyCharm)
Python версии 3.9 и выше

Установка sqlite3 prettytable и SQLite Studio

Установим необходимые библиотеки.

pip install sqlite3 prettytable

pip3 install sqlite3 prettytable

Чтобы мы могли визуально работать с базой данных SQLite3, скачаем менеджер для БД. Я пользуюсь программой SQLiteSudio, которая достаточно проста и удобна. Переходите по ссылке тут и внизу страницы нажимайте скачать. После установки запускаете программу.

Чтобы добавить новую базу данных, открываем выпадающее меню «Базы данных» и ищем пункт «Добавить базу данных», потом добавляем путь до БД и нажимаем ОК:

Пишем код в SQLite.py

Проект будет помещаться в два файла, первый — это класс с методами взаимодействия с SQLite, второй — сама программа для пользователя.

В файле SQLite.py будем прописывать класс для работы с базой данных. Мы напишем программу для сохранения трат пользователя. Он будет самостоятельно ее заполнять, вводя день, сумму и наименование товара. Также, пользователь сможет получать сводку о потраченных деньгах за выбранный период.

import sqlite3 import datetime

Импортируем библиотеку sqlite3 для подключения и работы с базой данных. Datetime нужен для создание timestamp (это время, которое прошло с 00:00 часов 1 января 1970 года). Создаем класс и даем ему любое имя:

class SQLite:

Вызываем конструктор (подробнее о классах и конструкторах написано тут и тут ) и создаем переменную класса db. Внутри неё будет объект библиотеки sqlite, туда мы передаем путь до БД. Если БД там не будет, библиотека самостоятельно создаст файл). Выносим cursor в отдельную переменную, так как к нему мы будем обращаться часто.

def __init__(self, db_path): self.db = sqlite3.connect(db_path) self.cursor = self.db.cursor()

Метод создания таблицы не сильно нужен, так как можно создать таблицу и через менеджера БД. Но на нем мы разберем, как можно использовать **kwargs.

Метод create_table принимает в себя два аргумента: table_name – имя создаваемой таблицы и kwargs – это будут столбцы таблицы:

def create_table(self, table_name: str, **kwargs) -> None: columns = ', '.join([' '.join(i) for i in kwargs.items()]) query = f"""CREATE TABLE IF NOT EXISTS (id INTEGER PRIMARY KEY AUTOINCREMENT, )""" try: self.cursor.execute(query) self.db.commit() except Exception as e: print(e)

На выходе мы получаем словарь:

Ключ — это имя колонки, а значение — её тип в SQLite. Дальше мы используем генератор, чтобы перебрать все значения key + value, выглядит он так:

[“date INTEGER”, “amount INTEGER”, “name TEXT”]

Собираем его еще раз в строку, на выходе она будет такой:

“date INTEGER, amount INTEGER, name TEXT”

После всех манипуляций собираем до конца запрос и передаем его в метод курсора execute. Все запросы к базе данных обернуты в try except, чтобы ошибки не останавливали полностью программу.

В методе get_all мы вытаскиваем все строки из базы данных и печатаем их:

def get_all(self) -> list: query = f"""SELECT * FROM payments""" try: return self.cursor.execute(query).fetchall() except Exception as e: print(e)

В методе get_by_data мы забираем траты за определенный период времени. Даты будут приходить в формате массива «год, месяц, день» (пример — [“2005”, “04”, “15”]). Потом мы прогоняем их через метод и получаем timestamp (этот метод рассмотрен ниже). Затем встраиваем в SQL-запрос нужные даты и получаем ответ:

def get_by_data(self, date_from: list, date_to: list) -> list: date_from = self.get_timestamp(*date_from) date_to = self.get_timestamp(*date_to) query = f"""SELECT * FROM payments WHERE (date > ) AND (date < )""" try: return self.cursor.execute(query).fetchall() except Exception as e: print(e)

Добавим немного декораторов:

@staticmethod def get_timestamp(y, m, d): return datetime.datetime.timestamp(datetime.datetime(int(y), int(m), int(d)))

Давайте разберемся, что за декоратор staticmethod . Эта функция может находиться отдельно от класса, и мы можем вызывать её извне. Декоратор позволяет положить функцию внутрь и обращаться к ней не создавая объекта. Да, звучит запутанно, если хотите разобраться в деталях - их можно найти в этой статье.

Дальше обращаемся к библиотеке datetime и трансформируем дату в timestamp. По итогу возвращается timestamp.

Ну и последний запрос к БД – добавление записи в таблицу:

def insert(self, date, amount, name): date = self.get_timestamp(*date) query = f"""INSERT INTO payments (date, amount, name) VALUES(, , '')""" try: self.cursor.execute(query) self.db.commit() except Exception as e: print(e)

В методе get_date аналогично, как и get_timestamp , мы используем встроенную библиотеку datetime (подробнее о библиотеке можно узнать тут ):

@staticmethod def get_date(timestamp): return datetime.datetime.fromtimestamp(timestamp).date()

После удаления класса или завершения работы программы на Python вызываем деконструктор, чтобы завершить соединение с БД:

def __del__(self): self.db.close()

Взаимодействие базы данных с пользователем

Создадим таблицу для работы - передаем название таблицы и столбцы с типами данных:

db = SQLite('db.db') db.create_table('payments', date='INTEGER', amount='INTEGER', name='TEXT')

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

Импортируем наш класс из файла SQLite.py. Дальше идет prettytable – библиотека для опрятных и красивых таблиц в консоли:

from SQLite import SQLite from prettytable import PrettyTable

Создаем объект класса SQLite и передаем путь к БД:

db = SQLite('db.db')

Для работы с таблицей выписываем колонки, которые есть в таблице:

header = ['id', 'date', 'amount', 'name']

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

print("Взаимодействие с базой данных SQLite") print("Команды: 1-Показать БД 2-Добавить новую запись 3-Поиск платеже за период 4-Еще раз вывести команды 0-Завершить программу\n")

Создаем бесконечный цикл для постоянного приема команды.
Это нужно, чтобы не перезапускать программу постоянно:

while True: command = int(input("Введите номер команды: ")) print('\n') match command: case 1: print('Таблица `payments`:') table = PrettyTable(header) all_rows = db.get_all() money = 0 for row in all_rows: row = list(row) row[1] = db.get_date(row[1]) table.add_row(row) money += float(row[-2]) print(table) print("Вы потратили всего: ", money) case 2: print('Таблица `payments`:') print("Введите данные как в примере yyyy-mm-dd 000 name") text = input("Новая запись: ").split(' ') date = text[0].split('-') db.insert(date, text[1], text[2]) print("Запись добавлена") case 3: print('Таблица `payments`:') print("Введите даты периода в формате yyyy-mm-dd yyyy-mm-dd") text = input("Новая запись: ").split(' ') date_from = text[0].split('-') date_to = text[1].split('-') rows = db.get_by_data(date_from, date_to) table = PrettyTable(header) money = 0 for row in rows: row = list(row) row[1] = db.get_date(row[1]) table.add_row(row) money += float(row[-2]) print(table) print(f"Вы потратили: \nЗа период с по ") case 4: print("Команды: 1-Показать БД 2-Добавить новую запись 3-Поиск платеже за период 4-Еще раз вывести команды 0-Завершить программу") case 0: exit() case _: print("Такой команды не сушествует") print('\n\n4-Еще раз вывести команды')

Command – принимает от пользователя цифру ID команды и преобразовывает из строки в число.

Match – новая фишка Python (ее добавили с версии 3.10). Она прогоняет передаваемое значение по возможным вариантам и если есть совпадение, то запускается код внутри.

Case 1 – выводит все строки в таблице и составляет таблицу. Мы создаем в переменной table таблицу и передаем внутрь ее столбцы. Потом собираем в table строки, полученные из БД.

Case 2 – отображает пользователю пример как нужно добавлять новую запись в таблицу и делает запрос к БД.

Case 3 – запрашивает даты периода, по которому нужна сводка и потом совершает запрос и ответ выводит пользователю.

Case 4 – повторно выводит возможные команды.

Case 0 – завершает программу

Case _ - нижнее подчеркивание срабатывает, если команды не удовлетворяет ни одному варианту

Пример работы программы:

Заключение

SQLite - хорошая база данных для локальных задач. На ней нельзя построить большой проект, а также масштабировать его, что является ее минусом. SQLite не допускает несколько параллельных потоков получения или загрузки данных, что сильно ограничивает её использование.

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