Как сделать программу с интерфейсом на python

Введение в Tkinter

Всем доброго времени суток!

Tkinter – это кроссплатформенная библиотека для разработки графического интерфейса на языке Python (начиная с Python 3.0 переименована в tkinter). Tkinter расшифровывается как Tk interface, и является интерфейсом к Tcl/Tk.
Tkinter входит в стандартный дистрибутив Python.

Весь код в этой статье написан для Python 2.x.
Чтобы убедиться, что Tkinter установлен и работает, воспользуемся стандартной функцией Tkinter _test():

После выполнения данного кода должно появиться следующее окно:

Отлично, теперь можно приступать к написанию нескольких простых программ для демонстрации основных принципов Tkinter.

Hello world

Конечно, куда же без него. Первым делом нам нужно создать главное окно, написав

Да-да, всего одна строка, это вам не WinAPI (=. Теперь создадим кнопку, при нажатии на которую будет выводиться текст в консоль:

Всё просто, не так ли? Создаём экземпляр класса Button, указываем родителя и при желании список параметров. Есть еще немало параметров, таких как шрифт, толщина рамки и т.д.
Затем привязываем к нажатию на кнопку событие (можно привязать несколько разных событий в зависимости, например, от того, какой кнопкой мыши был нажат наш btn.
mainloop() запускает цикл обработки событий; пока мы не вызовем эту функцию, наше окно не будет реагировать на внешние раздражители.

Упаковщики

Функция pack() — это так называемый упаковщик, или менеджер расположения. Он отвечает за то, как виджеты будут располагаться на главном окне. Для каждого виджета нужно вызвать метод упаковщика, иначе он не будет отображён. Всего упаковщиков три:

pack(). Автоматически размещает виджеты в родительском окне. Имеет параметры side, fill, expand. Пример:

grid(). Размещает виджеты на сетке. Основные параметры: row/column – строка/столбец в сетке, rowspan/columnspan – сколько строк/столбцов занимает виджет. Пример:

place(). Позволяет размещать виджеты в указанных координатах с указанными размерами.
Основные параметры: x, y, width, height. Пример:

Теперь для демонстрации других возможностей Tkinter, напишем простейший

Текстовый редактор

Без лишних слов приведу код:

Здесь есть несколько новых моментов.

Во-первых, мы подключили модуль tkFileDialog для диалогов открытия/закрытия файла. Использовать их просто: нужно создать объект типа Open или SaveAs, при желании задав параметр filetypes, и вызвать его метод show(). Метод вернёт строку с именем файла или пустую строку, если пользователь просто закрыл диалог.

Во-вторых, мы создали два фрейма. Фрейм предназначен для группировки других виджетов. Один содержит управляющие кнопки, а другой — поле для ввода текста и полосу прокрутки.
Это сделано, чтобы textbox не налезал на кнопки и всегда был максимального размера.

В-третьих, появился виджет Text. Мы его создали с параметром wrap=’word’, чтобы текст переносился по словам. Основные методы Text: get, insert, delete. Get и delete принимают начальный и конечный индексы. Индекс — это строка вида ‘x.y’, где x — номер символа в строке, а y — номер строки, причём символы нумеруются с 1, а строки — с 0. То есть на самое начала текста указывает индекс ‘1.0’. Для обозначения конца текста есть индекс ‘end’. Также допустимы конструкции вида ‘1.end’.

B в-четвёртых, мы создали полосу прокрутки (Scrollbar). После создания её нужно связать с нужным виджетом, в данном случае, с textbox. Связывание двустороннее:

Вот и всё. Tkinter – это, безусловно, мощная и удобная библиотека. Мы осветили не все её возможности, остальные — тема дальнейших статей.

Графический интерфейс на Python за 5 минут

Python легко использовать. В нем вы можете найти огромное количество библиотек для чего угодно. И это его основное преимущество. Из нескольких строк кода вы ничего не сделаете. Если вам нужны скрипты для личного пользования или для технически подкованной аудитории, то вам даже не придется думать о графическом интерфейсе.

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

Библиотеки Python, которые можно использовать для графического интерфейса

Статья переведена при поддержке компании EDISON Software, которая заботится о здоровье программистов и их завтраке, а также разрабатывает программное обеспечение на заказ.

Однако, к счастью, я наткнулся на четвёртый вариант, который был мне по душе. Это PySimpleGUI, я до сих пор ей пользуюсь. Как ни странно, эта библиотека использует все 3 популярные библиотеки, о которых шла речь выше, но при этом абстрагируется от супер технических моментов

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

Проверьте два одинаковых файла

Я рассказал как это сделать в своей статье “3 быстрых способа сравнить данные в Python”. Мы можем использовать первый раздел, проверку целостности данных, чтобы попытаться создать пользовательский интерфейс.

Запрограммируйте графический интерфейс

Чтобы создать графический интерфейс, можно использовать этот код:

в результате мы получим:

Подключаем логику

Когда есть пользовательский интерфейс, легко понять, как подключить остальную часть кода. Нам просто нужно следить за тем, что вводит пользователь и действовать соответственно. Мы можем очень легко сделать это с помощью следующего кода:

Обучение Python GUI (уроки по Tkinter)

В этом уроке мы узнаем, как разрабатывать графические пользовательские интерфейсы, с помощью разбора некоторых примеров графического интерфейса Python с использованием библиотеки Tkinter.

Библиотека Tkinter установлена в Python в качестве стандартного модуля, поэтому нам не нужно устанавливать что-либо для его использования. Tkinter — очень мощная библиотека. Если вы уже установили Python, можете использовать IDLE, который является интегрированной IDE, поставляемой в Python, эта IDE написана с использованием Tkinter. Звучит круто!

Мы будем использовать Python 3.7 поэтому, если вы все еще используете Python 2.x, настоятельно рекомендуем перейти на Python 3.x, если вы не в курсе нюансов изменения языка, с целью, чтобы вы могли настроить код для запуска без ошибок.

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

Создание своего первого графического интерфейса

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

Создание виджета Label

Затем мы установим позицию в окне с помощью функции grid и укажем ее следующим образом:

Полный код, будет выглядеть следующим образом:

И вот как будет выглядеть результат:
Если функция grid не будет вызвана, текст не будет отображаться.

Настройка размера и шрифта текста

Вы можете задать шрифт текста и размер. Также можно изменить стиль шрифта. Для этого передайте параметр font таким образом:

Отлично, но стандартное окно слишком мало. Как насчет настройки размера окна?

Настройка размеров окна приложения

Мы можем установить размер окна по умолчанию, используя функцию geometry следующим образом:

В приведенной выше строке устанавливается окно шириной до 400 пикселей и высотой до 250 пикселей.

Попробуем добавить больше виджетов GUI, например, кнопки и посмотреть, как обрабатывается нажатие кнопок.

Добавление виджета Button

Начнем с добавления кнопки в окно. Кнопка создается и добавляется в окно так же, как и метка:

Наш код будет выглядеть вот так:

Результат будет следующим:
Обратите внимание, что мы помещаем кнопку во второй столбец окна, что равно 1. Если вы забудете и поместите кнопку в том же столбце, который равен 0, он покажет только кнопку.

Изменение цвета текста и фона у Button

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

Кнопка Click

Для начала, мы запишем функцию, которую нужно выполнить при нажатии кнопки:

Затем мы подключим ее с помощью кнопки, указав следующую ​​функцию:

При нажатии на кнопку, результат, как и ожидалось, будет выглядеть следующим образом:
Круто!

Получение ввода с использованием класса Entry (текстовое поле Tkinter)

В предыдущих примерах GUI Python мы ознакомились со способами добавления простых виджетов, а теперь попробуем получить пользовательский ввод, используя класс Tkinter Entry (текстовое поле Tkinter).
Вы можете создать текстовое поле с помощью класса Tkinter Entry следующим образом:

Если вы нажмете на кнопку — появится текст «Привет » вместе с введенным текстом в виджете записи. Вот полный код:

Запустите вышеуказанный код и проверьте результат:
Прекрасно!

Каждый раз, когда мы запускаем код, нам нужно нажать на виджет ввода, чтобы настроить фокус на ввод текста, но как насчет автоматической настройки фокуса?

Установка фокуса виджета ввода

Здесь все очень просто, ведь все, что нам нужно сделать, — это вызвать функцию focus :

Когда вы запустите свой код, вы заметите, что виджет ввода в фокусе, который дает возможность сразу написать текст.

Отключить виджет ввода

Чтобы отключить виджет ввода, отключите свойство состояния:

Теперь вы не сможете ввести какой-либо текст.

Добавление виджета Combobox

Чтобы добавить виджет поля с выпадающем списком, используйте класс Combobox из ttk следующим образом:

Затем добавьте свои значения в поле со списком.

Добавление виджета Checkbutton (чекбокса)

Кроме того, вы можете задать значение по умолчанию, передав его в параметр var в Checkbutton :

Посмотрите на результат:

Установка состояния Checkbutton

Вы можете установить для BooleanVar значение false, что бы чекбокс не был отмечен.
Так же, используйте IntVar вместо BooleanVar и установите значения 0 и 1.

Добавление виджетов Radio Button

Чтобы добавить radio кнопки, используйте класс RadioButton :

Обратите внимание, что вы должны установить value для каждой radio кнопки с уникальным значением, иначе они не будут работать.

Результатом вышеприведенного кода будет следующий:
Кроме того, вы можете задать command любой из этих кнопок для определенной функции. Если пользователь нажимает на такую кнопку, она запустит код функции.
Вот пример:

Получение значения Radio Button (Избранная Radio Button)

Чтобы получить текущую выбранную radio кнопку или ее значение, вы можете передать параметр переменной и получить его значение.

Каждый раз, когда вы выбираете radio button, значение переменной будет изменено на значение кнопки.

Добавление виджета ScrolledText (текстовая область Tkinter)

Результат:

Настройка содержимого Scrolledtext

Удаление/Очистка содержимого Scrolledtext

Чтобы очистить содержимое данного виджета, используйте метод delete :

Создание всплывающего окна с сообщением

Чтобы показать всплывающее окно с помощью Tkinter, используйте messagebox следующим образом:

Довольно легко! Давайте покажем окно сообщений при нажатии на кнопку пользователем.

Когда вы нажмете на кнопку, появится информационное окно.

Показ сообщений о предупреждениях и ошибках

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

Показ диалоговых окон с выбором варианта

Чтобы показать пользователю сообщение “да/нет”, вы можете использовать одну из следующих функций messagebox :

Вы можете выбрать соответствующий стиль сообщения согласно вашим потребностям. Просто замените строку функции showinfo на одну из предыдущих и запустите скрипт. Кроме того, можно проверить, какая кнопка нажата, используя переменную результата.

Если вы кликнете OK, yes или retry, значение станет True, а если выберете no или cancel, значение будет False.
Единственной функцией, которая возвращает одно из трех значений, является функция askyesnocancel ; она возвращает True/False/None.

Добавление SpinBox (Виджет спинбокс)

Для создания виджета спинбокса, используйте класс Spinbox :

Проверим пример полностью:

Виджет покажет только эти 3 числа: 3, 8 и 11.

Задать значение по умолчанию для Spinbox

В случае, если вам нужно задать значение по умолчанию для Spinbox, вы можете передать значение параметру textvariable следующим образом:

Теперь, если вы запустите программу, она покажет 36 как значение по умолчанию для Spinbox.

Добавление виджета Progressbar

Чтобы создать данный виджет, используйте класс progressbar :

Установите значение progressbar таким образом:

Вы можете установить это значение на основе любого процесса или при выполнении задачи.

Изменение цвета Progressbar

Изменение цвета Progressbar немного сложно. Сначала нужно создать стиль и задать цвет фона, а затем настроить созданный стиль на Progressbar. Посмотрите следующий пример:

И в результате вы получите следующее:

Добавление поля загрузки файла

Для добавления поля с файлом, используйте класс filedialog :

После того, как вы выберете файл, нажмите “Открыть”; переменная файла будет содержать этот путь к файлу. Кроме того, вы можете запросить несколько файлов:

Указание типа файлов (расширение фильтра файлов)

Вы можете запросить каталог, используя метод askdirectory :

Вы можете указать начальную директорию для диалогового окна файла, указав initialdir следующим образом:

Добавление панели меню

Для добавления панели меню, используйте класс menu :

Сначала мы создаем меню, затем добавляем наш первый пункт подменю. Вы можете добавлять пункты меню в любое меню с помощью функции add_cascade() таким образом:

Наш код будет выглядеть так:

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

Теперь мы добавляем еще один пункт меню “Изменить” с разделителем меню. Вы можете заметить пунктирную линию в начале, если вы нажмете на эту строку, она отобразит пункты меню в небольшом отдельном окне.

Можно отключить эту функцию, с помощью tearoff подобным образом:

Добавление виджета Notebook (Управление вкладкой)

Для удобного управления вкладками реализуйте следующее:

Таким образом, вы можете добавлять столько вкладок, сколько нужно.

Добавление виджетов на вкладку

После создания вкладок вы можете поместить виджеты внутри этих вкладок, назначив родительское свойство нужной вкладке.

Добавление интервала для виджетов (Заполнение)

Передайте padx и pady любому виджету и задайте значение.

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

Python GUI: создаём простое приложение с PyQt и Qt Designer

Эта статья предназначена для тех, кто только начинает своё знакомство с созданием приложений с графическим интерфейсом (GUI) на Python. В ней мы рассмотрим основы использования PyQt в связке с Qt Designer. Шаг за шагом мы создадим простое Python GUI приложение, которое будет отображать содержимое выбранной директории.

Что нам потребуется

Нам понадобятся PyQt и Qt Designer, ну и Python, само собой.

В этой статье используется PyQt5 с Python 3, но особых различий между PyQt и PySide или их версиями для Python 2 нет.

Windows: PyQt можно скачать здесь. В комплекте с ним идёт Qt Designer.

macOS: Вы можете установить PyQt с помощью Homebrew:

$ brew install pyqt5

Скачать пакет с большинством компонентов и инструментов Qt, который содержит Qt Designer, можно по этой ссылке.

Linux: Всё нужное, вероятно, есть в репозиториях вашего дистрибутива. Qt Designer можно установить из Центра Приложений, но PyQt придётся устанавливать через терминал. Установить всё, что нам понадобится, одной командой можно, например, так:

Если вы видите сообщение, что такой команды нет или что-то в таком роде, попробуйте загуглить решение проблемы для вашей операционной системы и версии PyQt.

Дизайн

Основы

Теперь, когда у нас всё готово к работе, давайте начнём с простого дизайна.

Откройте Qt Designer, где вы увидите диалог новой формы, выберите Main Window и нажмите Create.

После этого у вас должна появиться форма — шаблон для окна, размер которого можно менять и куда можно вставлять объекты из окна виджетов и т.д. Ознакомьтесь с интерфейсом, он довольно простой.

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

Все элементы формы и их иерархия по умолчанию отображаются в правой части окна Qt Designer под названием Object Inspector. Вы с лёгкостью можете удалять объекты, кликая по ним правой кнопкой мыши в этом окне. Или же вы можете выбрать их в основной форме и нажать клавишу DEL на клавиатуре.

Теперь перетащите куда-нибудь в основную форму List Widget (не List View) и Push Button из Widget Box.

Макеты

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

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

Давайте создадим нашу первую форму без использования макетов. Перетащите список и кнопку в форме и измените их размер, чтобы вышло вот так:

Теперь в меню Qt Designer нажмите Form, затем выберите Preview и увидите что-то похожее на скриншот выше. Выглядит хорошо, не так ли? Но вот что случится, когда мы изменим размер окна:

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

Основное окно уже поддерживает макеты, поэтому нам ничего не нужно добавлять в нашу форму. Просто кликните правой кнопкой мыши по Main Window в Object Inspector и выберите Lay out → Lay out vertically. Также вы можете кликнуть правой кнопкой по пустой области в форме и выбрать те же опции:

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

Так как мы использовали вертикальное размещение, все элементы, которые мы добавим, будут располагаться вертикально. Можно комбинировать размещения для получения желаемого результата. Например, горизонтальное размещение двух кнопок в вертикальном будет выглядеть так:

Если у вас не получается переместить элемент в главном окне, вы можете сделать это в окне Object Inspector.

Последние штрихи

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

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

Свойства элементов можно изменить в разделе Property Editor.

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

Измените значение objectName на btnBrowse и text на Выберите папку.

Должно получиться так:

Сохраните дизайн как design.ui в папке проекта.

Превращаем дизайн в код

Пишем код

Теперь у нас есть файл design.py с нужной частью дизайна нашего приложения и мы начинать работу над созданием его логики.

Используем дизайн

Для Python GUI приложения понадобятся следующие модули:

Также нам нужен код дизайна, который мы создали ранее, поэтому его мы тоже импортируем:

В этом классе мы будем взаимодействовать с элементами интерфейса, добавлять соединения и всё остальное, что нам потребуется. Но для начала нам нужно инициализировать класс при запуске кода. С этим мы разберёмся в функции main() :

И чтобы выполнить эту функцию, мы воспользуемся привычной конструкцией:

В итоге main.py выглядит таким образом:

Но нажатие на кнопку ничего не даёт, поэтому нам придётся с этим разобраться.

Добавляем функциональность в наше Python GUI приложение

Начнём с кнопки Выберите папку. Привязать к функции событие вроде нажатия на кнопку можно следующим образом:

Для открытия диалога выбора папки мы можем использовать встроенный метод QtWidgets.QFileDialog.getExistingDirectory :

Для отображения содержимого директории нам нужно импортировать os :

И получить список содержимого следующим образом:

В итоге функция browse_folder должна выглядеть так:

Теперь, если запустить приложение, нажать на кнопку и выбрать директорию, мы увидим:

Так выглядит весь код нашего Python GUI приложения:

Это были основы использования Qt Designer и PyQt для разработки Python GUI приложения. Теперь вы можете спокойно изменять дизайн приложения и использовать команду pyuic5 без страха потерять написанный код.

PyGame

Напишем к нашему проекту (игре) графический интерфейс (GUI).

Есть много библиотек для создания GUI на python: PyQt (сложная, много может), PyGtk (тоже кроссплатформенная), tkinter (проще).

Для создания GUI игр тоже есть специальные библиотеки, например PyGame и ее упрощение для детей PyGame Zero

Ссылки

Основные концепции GUI на примере tkinter

Внимание, в Windows файлы *.pyw запускаются программой pythonw.exe, а не python.exe, поэтому при запуске не будет консоли. В Linux разницы в расширениях нет.

Жизненный цикл консольной программы и программы с GUI. Рис 13.1 Саммерфилд

Event-Listener

Любое действие с GUI порождает событие (event). Например, нажатие Shift на клавиатуре, движение мыши или нажатие ее кнопки. Его получают те части GUI, которые подписались (слушают) это событие. Много разных частей могут услышать 1 событие. Разные части могут по-разному отреагировать на одно и то же событие.

Hello, world!

Напишем простейшую программу с GUI на tkinter.

Linux, Gnome

Windows:

Окно декорируется (выглядит) согласно оконному менеджеру или стилю, принятому в операционной системе.

В Windows или на Mac это окно будет выглядеть, как принято выглядеть окнам в Windows или на Mac.

Добавим заранее приготовленное изображение в виде логотипа python как Label.

Если хотим написать текст поверх картинки, указываем и картинку, и текст в одной и той же Label

Внимание! Необходимо хранить ссылку на картинку, чтобы она была показана.

Шрифт и цвет

Динамическое изменение Label по таймеру

Список widget (не полный)

Использование tkinter в ООП стиле

Напишем GUI с классами, используя библиотеку tkinter.

Пока не будем использовать наследование, обойдемся композицией. Окно состоит из надписи и двух кнопок.

Добавим к Label (надпись) еще и Button (кнопку). По нажатию на кнопку greet_button вызывается метод self.greet, который печатает «Greetings!».

Заметьте как связана кнопка close_button и закрытие всего окна.

Можно положиться на метод pack(), который упакует виджеты один за другим в родительский контейнер, сверху вниз. Удобно для простейших окон.

Можно указать в pack параметр side. Чуть более сложное расположение виджетов. Но окно еще простое.

Дополнительная информация (пропустить при первом чтении):

При изменении размеров окна в меньшую сторону первым исчезнет последний добавленный виджет. Так что порядок добавления виджетов имеет значение.

Порядок прикрепления имеет значение и при распределения занимаемой области:

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

Тут метку создали (в коде!) между кнопок:

Добавим expand и fill

Чтобы при увеличении окна увеличивались все лежащие в нем компоненты, нужно сделать их контейнер расширяемым.

Виджеты расширяются за пределы своего начального положения, только если расширяются все их родители.

Добавим anchor вместо растягивания:

Для сложных окон используйте grid().

Выравнивание в параметре sticky идет по сторонам света: N, S, W, E.

По умолчанию выравнивание по центру (по горизонтали и по вертикали).

W+E означает «растянуть слева направо».

Можно указать комбинацию NE, SW и так далее.

Кроме columnspan есть rowspan (на скольких столбцах или строках расположен виджет).

Не смешивайте в одном контейнере pack и grid! Положите несколько виджетов в разные Frame и компонуйте дальше эти Frame другим layout manager.

Custom Events

Рассмотрим изменение примера, где Label меняет свой текст по клику мыши.

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

Событие однозначно идентифицируются по имени последовательности в виде строки на мини-языке, который не является специфичным для python. Вот несколько примеров обычных событий:

Заметьте, что обработчику событий cycle_label_text(self, event) передается объект event, в котором описана дополнительная информация о событии.

Можно назначит один и тот же обработчик на разные события.

Калькулятор

Напишем калькулятор, который умеет только складывать и вычитать введенные числа. Кнопка reset должна обнулять результат.

Если введены плохие данные, то нужно научиться проверять данные и реагировать на плохой ввод.

ООП с наследованием

Напишем программу в настоящем ООП стиле с наследованием.

Будем наследоваться от класса, который представляет отдельное окно.

От кого наследовать главное окно приложения? tkinter.Toplevel или tkinter.ttk.Frame.

Лутц, Программирование на Python, главы 7-11

Добавление пользовательских обработчиков событий (event handler)

lambda-функции

Хитрость: в lambda-функции может быть только 1 выражение, поэтому мы пишем print и exit в одно выражение, связывая их через or.

Отложенные вызовы

Иногда нужно в обработчик событий передать дополнительные данные.

Обычно функции как обработчики событий указываются без аргументов:

Что делать, если нужно передать в функцию-обработчик аргумент?

Ошибка! Функция hi будет вызвана не в момент нажатия кнопки, а при ее создании.

Вариант 1: пишем функцию-обертку и вызываем обертку.

Вариант 2: отложенный вызов.

Этот вариант вы уже видели в калькуляторе.

Цитата: Вызов фактического обработчика откладывается, благодаря чему мы получаем возможность добавлять необходимые аргументы. В данном случае значение глобальной переменной X и строка «spam» будут переданы в аргументах A и B даже при том, что библиотека tkinter вызывает функции обратного вызова без аргументов. Таким образом, инструкция lambda может использоваться для отображения вызова без аргументов в вызов с аргументами, которые поставляются самим lambda-выражением.

из «плохо» делаем «хорошо» без lambda:

Проблемы с областями видимости для обработчиков

Как передавать данные в функции-обработчики?

Глобальные переменные

Тогда можно написать функцию handler без аргументов, а X и name сделать глобальными переменными.

Передача значений из объемлющей области видимости при помощи аргументов со значением по умолчанию

Х теперь не глобальная, а лежит в объемлющей области видимости. Все работает, как мы хотим:

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

Значения по умолчанию вычисляются при создании, а не при вызове функции. Поэтому тут явно гарантируется значение 42 (которое вычисляеся при выполнении lambda-выражения). Позже библиотекой будет вызвана lambda-функция без аргументов, поэтому все ее аргументы получат значения по умолчанию.

Передача значений из объемлющей области видимости с помощью автоматических ссылок

Оба примера выше в результате делают одно и то же. Но внутри lambda-выражения ссылки на переменную из объемлющей области видимости разрешаются в момет вызова этой функции, а не в момет ее создания.

С одной стороны получаем плюс, можно написать значение переменной после написания lambda-выражения.

Переменная до lambda-выражения. Все работает, как ожидается.

Переменная после lambda-выражения. Тоже работает, потому что поиск значения переменной начинается только при ее вызове.

Видно, что в момент создания вложенной функции action переменная spam даже не была определена. Разрешение имени spam происходит во время вызова функции action.

То же справедливо и для lambda-выражений.

и это тоже работает:

Чуть подробнее о связывании:

В GUI часто виджеты (и их обработчики) создаются в цикле. При этом можем получить:

В этом случае поможет передача значения по умолчанию:

То же правило действует, если объемлющей областью является модуль, а не другая функция:

Вывод: используем ссылки на переменные в объемлющей функции видимости, если переменные не будут изменяться, иначе передаем их значениями по умолчанию

Использовать ссылку на внешнюю переменную цикла внутри вложенной функции неразумно. Тогда передаем значение этой переменной как значение по умолчанию.

Связанные методы класса как обработчики событий

Хоть вызывается метод quit без аргументов, но на самом деле он получает аргумент self.

Если мы заходим вызвать метод по имени класса command=HelloClass.quit, то произойдет ошибка «quit() missing 1 required positional argument: ‘self'»

Заметим, что фактически в методе quit мы нигде не пользовались, что это метод объекта класса (т.е. не использовали self). Если мы напишем обработчик как статический метод quit2, то его можно будет вызвать и по self.quit2 и по имени класса HelloClass.quit2.

Перепишем handler с X=42 и name=’spam’ в виде класса:

Объекты вызываемых классов как обработчики событий

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

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

Связывание событий

Покажем, как нажатие на кнопку можно связать не через параметр command, а через функцию bind()

Tkinter в Python: руководство по использованию

Tkinter — графическая библиотека Python, которая предназначена для создания программ с оконным интерфейсом. Она кроссплатформенная, то есть с ее помощью можно писать приложения для Windows, Linux, macOS.

«Купи мне истребитель». Сбор средств для Воздушных Сил ВСУ

Как я поделился своими чувствами, что познал вселенную Tkinter

Tkinter в Python

Tkinter — это интерфейс Tcl/Tk. На английском его обычно называют «тикль-ток», на русском — «так-тикль».

Tcl — это скриптовый язык. Tk — кроссплатформенная графическая библиотека.

Область применения Tcl/Tk — быстрое прототипирование. С его помощью создают графические интерфейсы, встраивают новые сценарии в программы, тестируют.

Чтобы работать с Tcl/Tk на Python, используется библиотека Tkinter. Чтобы узнать больше о том, как с ней взаимодействовать, изучите документацию.

В результате должно запуститься окно, в котором указана версия Tcl/Tk, а также две кнопки — Click me и Quit.

Создание простого GUI приложения на Tkinter

В этом руководстве мы будем писать первое приложение на Tkinter в среде Windows. В качестве IDE используем Visual Studio Code. Подразумевается, что вы владеете основами Python. Все примеры кода написаны на Python 3.9.

Установка Tk

Прежде чем использовать библиотеку Tkinter, нужно убедиться, что в системе стоит последняя версия Tk. В противном случае могут возникнуть ошибки при компиляции.

Вам нужна версия 8.6 и выше. Если в системе установлена версия 8.4 или 8.5, нужно ее обновить. Самый простой способ сделать это — установить одну из последних версий Python. Начиная с версии 3.7 в ядре Python предустановлен Tcl/Tk версии 8.6.

После завершения установки запустите консоль и проверьте, какая версия Python используется по умолчанию. Должна быть 3.7 и выше. Если версия отличается, переключитесь на установленную ранее.

Hello, World!

Начнем традиционно — поздороваемся с миром. Для этого сделаем простое окно, у которого будет только заголовок.

Откроется окно вашей первой программы с заголовком Hello, World !

Особенность Tkinter в том, что библиотека автоматически подстраивает внешний вид окна под стиль операционной системы. Так окно выглядит на Windows. На Linux и macOS оно будет другим, соответствующим стилю системы.

Источник изображения: python-scripts.com/tkinter

Базовые виджеты

Виджеты — это основа библиотеки Tkinter. Через них пользователи взаимодействуют с программой.

Каждый виджет определен классом. Вот основные семь:

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

Управление геометрией

Например, вот так просто можно разместить три кнопки в ряд:

В grid() также можно гибко управлять размерами виджетов при расширении и уменьшении окна.

По умолчанию pack() размещает виджеты друг над другом и центрирует. Настроить расположение элементов можно с помощью ключевых аргументов. Например, вот так можно расширить виджет по горизонтали на всю ширину экрана:

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

Например, вот так можно развернуть наши виджеты налево:

Менеджер place() используется все реже. У него два недостатка:

Но в некоторых случаях place() подходит — например, если нужно создать интерфейс для географической карты и разместить виджеты на правильном расстоянии друг от друга.

У pack() тоже есть недостаток. Так как расположение виджетов зависит от порядка вызова метода, приложения сложно модифицировать без полного понимания кода. В grid() эти проблемы решены, поэтому он сейчас используется чаще, чем другие менеджеры геометрии. Больше полезной информации о менеджере grid() вы найдете в документации.

Примеры использования виджетов

Чтобы лучше понять концепцию создания и размещения виджетов, давайте разберем несколько примеров.

Здесь мы добавляем текст с помощью виджета Label и кнопку с помощью виджета Button :

Получаем вот такой результат:

Теперь после нажатия на кнопку текст Label будет меняться на тот, который мы указали внутри функции:

Теперь добавим в свою программу чекбоксы:

Мы получим такой результат:

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

Пишем простой калькулятор

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

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

Теперь создадим все кнопки, которые нужны нашему калькулятору. Цифры от 1 до 0, знаки сложения, вычитания, деления, умножения, кнопки вывода результата и очистки строки:

Теперь нужно расположить кнопки в интерфейсе, используя менеджер геометрии grid :

Осталось определить логику для каждого действия пользователя : нажатия на цифру, знаки математических операций:

Это очень простой калькулятор. Но он уже работает так, как нужно. Его можно усовершенствовать — добавить дополнительные функции, изменить внешний вид, настроить ввод с клавиатуры.

Полный код приложения:

Заключение

Чтобы потренироваться с Tkinter, создайте еще несколько простых приложений. В качестве руководства можно использовать это видео от freeCodeCamp. Это мини-курс по Tkinter, в рамках которого вы создадите программу для просмотра картинок. Это будет минималистическое приложение для погоды.

А с этого видео начинается курс по Trinter на русском языке. В нем 28 уроков, вторая половина которых посвящена созданию игры «Сапер» на Python.

PyQt6 — полное руководство для новичков

К старту курса по разработке на Python делимся детальным руководством по работе с современным PyQt. Чтобы читать было удобнее, мы объединили несколько статей в одну:

За подробностями приглашаем под кат.

Простое приложение Hello World! на Python и Qt6

PyQt — это библиотека Python для создания приложений с графическим интерфейсом с помощью инструментария Qt. Созданная в Riverbank Computing, PyQt является свободным ПО (по лицензии GPL) и разрабатывается с 1999 года. Последняя версия PyQt6 — на основе Qt 6 — выпущена в 2021 году, и библиотека продолжает обновляться. Это руководство можно также использовать для PySide2, PySide6 и PyQt5.

Сегодня используются две основные версии: PyQt5 на основе Qt5 и PyQt6 на основе Qt6. Обе почти полностью совместимы, за исключением импорта и отсутствия поддержки некоторых продвинутых модулей из Qt6. В PyQt6 вносятся изменения в работу пространств имён и флагов, но ими легко управлять. В этом руководстве мы узнаем, как использовать PyQt6 для создания настольных приложений.

Сначала создадим несколько простых окон на рабочем столе, чтобы убедиться, что PyQt работает, и разберём базовые понятия. Затем кратко изучим цикл событий и то, как он связан с программированием графического интерфейса на Python. В заключение поговорим о QMainWindow с полезными элементами интерфейса, такими как панели инструментов и меню. Подробно я расскажу о них в следующих руководствах.

Создание приложения

Сначала создадим новый файл Python с любым названием (например app.py) и сохраним его. Исходный код приложения показан ниже. Введите его полностью и постарайтесь не ошибиться. Если что-то напутаете, Python укажет, что именно:

Запускаем приложение из командной строки, как и любой скрипт Python:

Выполнив его, мы увидим окно. В Qt автоматически создаётся окно с обычным оформлением, возможностью его перетаскивать и менять размер. То, что вы увидите, зависит от платформы, где этот пример выполняется. Вот как отображается это окно на Windows, macOS и Linux (Ubuntu):

Окно на Windows, macOS и Linux

Разбор кода

Пройдём код построчно, чтобы понять, что именно происходит. Сначала мы импортируем классы PyQt для приложения: здесь это обработчик приложения QApplication и базовый пустой виджет графического интерфейса QWidget (оба из модуля QtWidgets):

Основные модули для Qt: QtWidgets, QtGui и QtCore.

Если не будете использовать аргументы командной строки для управления Qt, передайте пустой список:

Затем создаём экземпляр QWidget, используя имя переменной window:

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

В окне находится пользовательский интерфейс приложения. У каждого приложения он как минимум один. Приложение (по умолчанию) завершает работу при закрытии последнего окна.

Наконец, вызываем app.exec(), чтобы запустить цикл события.

Что такое «цикл событий»?

Прежде чем вывести окно на экран, разберём ключевые понятия, касающиеся организации приложений в мире Qt. Если вам уже знакомы циклы событий, можете пропустить эту часть статьи.

Основной элемент всех приложений в Qt — класс QApplication. Для работы каждому приложению нужен один — и только один — объект QApplication, который содержит цикл событий приложения. Это основной цикл, управляющий всем взаимодействием пользователя с графическим интерфейсом:

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

Класс QApplication содержит цикл событий Qt (нужен один экземпляр QApplication). Приложение ждёт в цикле событий новое событие, которое будет сгенерировано при выполнении действия. Всегда выполняется только один цикл событий.

QMainWindow

Итак, в Qt любые виджеты могут быть окнами. Например, если заменить QtWidget на QPushButton. В этом примере получается окно с одной нажимаемой кнопкой:

Классно, но не очень полезно на самом деле: редко когда нужен пользовательский интерфейс, состоящий только из одного элемента управления. Зато возможность с помощью макетов вкладывать одни виджеты в другие позволяет создавать сложные пользовательские интерфейсы внутри пустого QWidget.

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

Запускаем и видим главное окно. Точно такое же, как и раньше.

QMainWindow пока не очень интересный. Добавим контент. Чтобы сделать настраиваемое окно, лучше создать подкласс QMainWindow, а затем настроить окно в блоке __init__. Так окно станет независимым в плане поведения. Итак, добавляем подкласс QMainWindow — MainWindow:

При создании подкласса из класса Qt, чтобы разрешить Qt настраивать объект, всегда нужно вызывать функцию super __init__.

Запускаем и снова видим окно, но на этот раз с виджетом QPushButton в центре. Нажатие кнопки ничего не даст — с этим мы разберёмся после:

QMainWindow с одной кнопкой QPushButton на Windows, macOS и Linux

Скоро мы подробно рассмотрим другие виджеты, но, если вам не терпится и хочется забежать вперёд, можете заглянуть в документацию QWidget. Попробуйте добавить различные виджеты в окно.

Изменение размеров окон и виджетов

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

В Qt размеры определяются с помощью объекта QSize. Он принимает параметры ширины и высоты. Например, так создаётся окно фиксированного размера 400 x 300 пикселей:

Запускаем и видим окно фиксированного размера. Поменять его размер не получится.

Окно фиксированного размера

Элемент управления maximize отключён на Windows и Linux. На macOS можно развернуть приложение на весь экран, но размер центрального виджета не изменится.

А ещё вы можете приобрести книгу автора этих уроков или продолжить чтение.

Слоты и сигналы

Ранее мы рассмотрели классы QApplication и QMainWindow, цикл событий и добавили в окно простой виджет. А теперь изучим механизмы Qt для взаимодействия виджетов и окон друг с другом. В статью внесены изменения, связанные с PyQt6.

Мы создали окно и добавили в него простой виджет push button, но кнопка пока бесполезна. Нужно связать действие нажатия кнопки с происходящим. В Qt это делается с помощью сигналов и слотов или событий.

Сигналы — это уведомления, отправляемые виджетами, когда что-то происходит. Этим «чем-то» может быть что угодно — нажатие кнопки, изменение текста в поле ввода или изменение текста в окне. Многие сигналы инициируются в ответ на действия пользователя, но не только: в сигналах могут отправляться данные с дополнительным контекстом произошедшего.

Можно также писать собственные сигналы, их мы рассмотрим позже.

Слоты в Qt — это приёмники сигналов. Слотом в приложении на Python можно сделать любую функцию (или метод), просто подключив к нему сигнал. Принимающая функция получает данные, отправляемые ей в сигнале. У многих виджетов Qt есть встроенные слоты, а значит, виджеты можно подключать друг к другу напрямую.

Рассмотрим основные сигналы Qt и их использование для подключения виджетов в приложениях. Сохраните эту заготовку приложения в файле app.py:

Сигналы QPushButton

Сейчас у нас есть QMainWindow с центральным виджетом QPushButton. Подключим эту кнопку к пользовательскому методу Python. Создадим простой настраиваемый слот the_button_was_clicked, принимающий сигнал clicked от QPushButton:

Запускаем. Если нажать на кнопку, в консоли появится текст Clicked! («Нажата!»):

Получение данных

Запускаем! Если нажать на кнопку, она подсветится и станет checked («Нажатой»). Чтобы отключить её, нажимаем ещё раз. Найдите состояние нажатия в консоли:

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

Хранение данных

Текущее состояние виджета на Python часто хранят в переменной, что позволяет работать со значениями без доступа к исходному виджету. Причём для их хранения используются отдельные переменные или словарь. В следующем примере сохраняем значение кнопки checked («Нажата») в переменной button_is_checked в self:

Сначала устанавливаем переменной значение по умолчанию True, а затем используем это значение, чтобы установить исходное состояние виджета. Когда состояние виджета меняется, получаем сигнал и соответственно обновляем переменную.

Эта же схема применима к любым виджетам PyQt. Если в виджете нет сигнала, которым отправляется текущее состояние, нужно получить значение из виджета прямо в обработчике. Например, здесь мы проверяем состояние checked («Нажата») в нажатом обработчике:

Сохраним ссылку на кнопку в self, чтобы получить к ней доступ в слоте.

Изменение интерфейса

Мы уже видели, как принимаются сигналы и выводятся на консоль результаты. Но что происходит с интерфейсом, когда нажимают на кнопку? Обновим метод слота, чтобы изменить кнопку, поменяв текст, отключив её и сделав её недоступной. И отключим пока состояние, допускающее нажатие:

В методах слота можно не только менять кнопку, которая активирует сигнал, но и делать всё что угодно. Например, поменять заголовок окна, добавив в метод the_button_was_clicked эту строку:

При нажатии на кнопку заголовок окна случайным образом изменится. Если новый заголовок окна изменится на Something went wrong («Что-то пошло не так»), кнопка отключится.

Запускаем! Нажимайте на кнопку, пока заголовок не изменится на Something went wrong. В этом примере стоит обратить внимание вот на что:

Сигнал windowTitleChanged при установке заголовка окна выдаётся не всегда. Он срабатывает, только если новый заголовок отличается от предыдущего: если один и тот же заголовок устанавливается несколько раз, сигнал срабатывает только в первый раз. Чтобы избежать неожиданностей, важно перепроверять условия срабатывания сигналов при их использовании в приложении.

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

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

Подключение виджетов друг к другу напрямую

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

Внимание: чтобы подключить входные данные к метке, нужно определить и эти данные, и метку. В этом коде в макет добавляются два виджета и устанавливаются в окне. Подробно рассмотрим макеты позже, а пока не обращайте на них внимания.

Введите текст в верхнем поле — он сразу появится в виде метки.

У большинства виджетов Qt есть доступные слоты, к которым подключается любой сигнал, возврощающий тот же тип, что он принимает. В документации по виджетам, в разделе Public Slots («Общедоступные слоты»), имеются слоты для каждого виджета. Посмотрите документацию для QLabel.

События

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

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

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

Курс по библиотеке Tkinter языка Python

Содержание

Введение

Этой библиотеке посвящено мало внимания, и найти в рунете курс, книгу или FAQ по ней довольно-таки сложно. Стоит отметить, что здесь отражены только основы этой библиотеки, и надеюсь, что более опытные люди дополнят эту статью.

Что такое Tkinter?

Так как Tkinter является достаточно прозрачным интерфейсом к tcl/tk, то основным источником информации для неё являются man-страницы tcl/tk. Эти страницы имеются в любой Unix-системе (в разделе n или 3tk). Также они доступны онлайн на сайте http://tcl.tk. Основные:

Начиная с версии python-3.0 библиотека переименована в соответствии с PEP 8 в tkinter (с маленькой буквы).

Импортируется она как и любая другая библиотека:

Класс Tk

Tk является базовым классом любого Tkinter приложения. При создании объекта этого класса запускается интерпретатор tcl/tk и создаётся базовое окно приложения.

Tkinter является событийно-ориентированной библиотекой. В приложениях такого типа имеется главный цикл обработки событий. В Tkinter такой цикл запускается методом mainloop. Для явного выхода из интерпретатора и завершения цикла обработки событий используется метод quit.

Таким образом минимальное приложение на Tkinter будет таким:

В приложении можно использовать несколько интерпретаторов tcl/tk. Так как после вызова метода mainloop дальнейшие команды python исполняться не будут до выхода из цикла обработки событий, необходимо метод mainloop всех интерпретаторов кроме последнего осуществлять в фоновом режиме. Пример запуска двух интерпретаторов:

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

Общее для всех виджетов

Все виджеты в Tkinter обладают некоторыми общими свойствами. Опишем их, перед тем как перейти к рассмотрению конкретных виджетов. Виджеты создаются вызовом конструктора соответствующего класса. Первый аргумент (как правило неименованный, но можно использовать имя master) это родительский виджет, в который будет упакован (помещён) наш виджет. Родительский виджет можно не указывать, в таком случае будет использовано главное окно приложения. Далее следуют именованные аргументы, конфигурирующие виджет. Это может быть используемый шрифт (font=. ), цвет виджета (bg=. ), команда, выполняющаяся при активации виджета (command=. ) и т.д. Полный список всех аргументов можно посмотреть в man options и man-странице соответствующего виджета (например man button, см. разделы «STANDARD OPTIONS» и «WIDGET-SPECIFIC OPTIONS»). Пример кода:

Памятуя о Zen Python (явное лучше неявного) указываю: данный код написан и работает для Python v 2. В случае использования Python v 3 код немного изменится. 1. tkinter с маленькой буквы. 2. print в круглых скобках () и без u.

Методы виджетов

Виджеты могут быть сконфигурированы во время создания, но иногда необходимо изменить конфигурацию виджета во время исполнения программы. Для этого используется метод configure (или его синоним config). Также можно использовать квадратные скобки (widget[‘option’] = new_value). Пример, программа выводит текущее время, после клика по кнопке:

В этом коде функция button_clicked вызывается каждый раз, когда пользователь кликает по кнопке.

Метод cget является обратным к методу configure. Он предназначен для получения информации о конфигурации виджета. Здесь как и в случае с configure можно использовать квадратные скобки (value = widget[‘option’]). Пример, после клика на кнопку программа показывает цвет кнопки и меняет его на другой:

Уничтожение виджета и всех его потомков. Стоит отметить, что если необходимо только на время спрятать какой-либо виджет, то лучше пользоваться упаковщиком grid и методом grid_remove:

Использование grid_remove позволяет сохранять взаимное расположение виджетов.

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

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

Методы семейства focus_ используются для управления фокусом ввода с клавиатуры. Виджет, имеющий фокус, получает все события с клавиатуры.

«Системные» методы

Эти методы не являются виджет-специфичными, т.е. хотя они являются методами виджетов они влияют на работу интерпретатора tcl/tk.

after, after_idle и after_cancel [3]

Таймеры. С помощью этих методов вы можете отложить выполнение какого-нибудь кода на определённое время.

update и update_idletasks [4]

Две функции, для работы с очередью задач. Их выполнение вызывает обработку отложенных задач.

update_idletasks выполняет задачи, обычно откладываемые «на потом», когда приложение будет простаивать. Это приводит к прорисовке всех виджетов, расчёту их расположения и т.д. Обычно эта функция используется если были внесены изменения в состояние приложения, и вы хотите, чтобы эти изменения были отображены на экране немедленно, не дожидаясь завершения сценария.

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

eval и evalfile

Основные виджеты

Toplevel

Эти же методы могут быть использованы для корневого (root) окна.

Таким способом можно предотвратить закрытие окна (например, если закрытие окна приведёт к потере введённых пользователем данных).

Button

Далее, нашу кнопку необходимо разместить на окне. Для этого, в Tkinter используются специальные упаковщики( pack(), place(), grid() ). Поподробнее об упаковщиках узнаем позже. Пока, чтобы разместить несколько виджетов на окне, будем применять самый простой упаковщик pack(). В конце программы, нужно использовать функцию mainloop (см. пример), иначе окно не будет создано.

Label

Entry

Listbox

Стоит заметить, что в этой библиотеке для того, чтобы использовать русские буквы в строках, нужно использовать Unicode-строки. В Python 2.x для этого нужно перед строкой поставить букву u, в Python 3.x этого делать вообще не требуется, т.к. все строки в нем изначально Unicode. Кроме того в первой или второй строке файла необходимо указать кодировку файла (в комментарии): coding: utf-8. Чаще всего используется формат в стиле текстового редактора emacs:

В Python 3.x кодировку файла можно не указывать, в этом случае по умолчанию предполагается utf-8.

Frame

Виджет Frame (рамка) предназначен для организации виджетов внутри окна. Рассмотрим пример:

Свойство bd отвечает за толщину края рамки.

Checkbutton

Radiobutton

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

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

Scale

Здесь используется специальный метод get(), который позволяет снять с виджета определенное значение, и используется не только в Scale.

Scrollbar

Этот виджет даёт возможность пользователю «прокрутить» другой виджет (например текстовое поле) и часто бывает полезен. Использование этого виджета достаточно нетривиально. Необходимо сделать две привязки: command полосы прокрутки привязываем к методу xview/yview виджета, а xscrollcommand/yscrollcommand виджета привязываем к методу set полосы прокрутки.

Рассмотрим на примере:

Упаковщики

Упаковщик (менеджер геометрии, менеджер расположения) это специальный механизм, который размещает (упаковывает) виджеты на окне. В Tkinter есть три упаковщика: pack, place, grid. Обратите внимание, что в одном виджете можно использовать только один тип упаковки, при смешивании разных типов упаковки программа, скорее всего, не будет работать.

Разберем каждый из них по порядку:

pack() [6]

Упаковщик pack() является самым интеллектуальным (и самым непредсказуемым). При использовании этого упаковщика с помощью свойства side нужно указать к какой стороне родительского виджета он должен примыкать. Как правило этот упаковщик используют для размещения виджетов друг за другом (слева направо или сверху вниз). Пример:

Результат работы можно увидеть на скриншоте справа.

Для создания сложной структуры с использованием этого упаковщика обычно используют Frame, вложенные друг в друга.

При применении этого упаковщика можно указать следующие аргументы:

Кроме основной функции у виджетов есть дополнительные методы для работы с упаковщиками.

grid() [8]

Этот упаковщик представляет собой таблицу с ячейками, в которые помещаются виджеты.

Для каждого виджета указываем, в какой он находится строке, и в каком столбце. Если нужно, указываем, сколько ячеек он занимает (если, например, нам нужно разместить три виджета под одним, необходимо «растянуть» верхний на три ячейки). Пример:

Пример, текстовый виджет с двумя полосами прокрутки:

place() [10]

place представляет собой простой упаковщик, позволяющий размещать виджет в фиксированном месте с фиксированным размером. Также он позволяет указывать координаты размещения в относительных единицах для реализации «резинового» размещения. При использовании этого упаковщика, нам необходимо указывать координаты каждого виджета. Например:

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

Привязка событий

command

Для большинства виджетов, реагирующих на действие пользователя, активацию виджета (например нажатие кнопки) можно привязать с использованием опции command. К таким виджетам относятся: Button, Checkbutton, Radiobutton, Spinbox, Scrollbar, Scale. Выше мы уже неоднократно пользовались этим способом:

Такой способ является предпочтительным и наиболее удобным способом привязки.

Метод bind[1] привязывает событие к какому-либо действию (нажатие кнопки мыши, нажатие клавиши на клавиатуре и т.д.). bind принимает три аргумента:

Метод bind возвращает идентификатор привязки, который может быть использован в функции unbind.

Обратите внимание, что если bind привязан к окну верхнего уровня, то Tkinter будет обрабатывать события всех виджетов этого окна (см. также bind_all ниже).

Функция, которая вызывается при наступлении события, должна принимать один аргумент. Это объект класса Event, в котором описано наступившее событие. Объект класса Event имеет следующие атрибуты (в скобках указаны события, для которых этот атрибут установлен):

Есть три формы названия событий. Самый простой случай это символ ASCII. Так описываются события нажатия клавиш на клавиатуре:

callback вызывается каждый раз, когда будет нажата клавиша «z».

Второй способ длиннее, но позволяет описать больше событий. Он имеет следующий синтаксис:

Название события заключено в угловые скобки. Внутри имеются ноль или более модификаторов, тип события и дополнительная информация (номер нажатой клавиши мыши или символ клавиатуры) Поля разделяются дефисом или пробелом. Пример (привязываем одновременное нажатие Ctrl+Shift+q):

(в данном примере KeyPress можно убрать).

Здесь перечислены все возможные типы событий, для самых часто используемых дано описание. Более подробно см. man bind.

- движение мышью с нажатой на клавиатуре клавишей Alt.

- нажатие любой клавиши на клавиатуре.

Пример, меняем порядок обработки привязок на обратный:

Изображения

BitmapImage

Конструктор класса принимает следующие аргументы:

PhotoImage

PhotoImage позволяет использовать полноцветное изображение. Кроме того у этого класса есть несколько (достаточно примитивных) методов для работы с изображениями. PhotoImage гарантированно понимает формат GIF.

ttk (themed tk) это расширение tcl/tk с новым набором виджетов. В ttk используется новый движок для создания виджетов. Этот движок обладает поддержкой тем и стилей оформления. Благодаря этому виджеты ttk выглядят более естественно в различных операционных системах.

Начиная с версий python 2.7 и 3.1.2 в Tkinter включён модуль для работы с ttk.

В ttk включены следующие виджеты, которые можно использовать вместо соответствующих виджетов tk: Button, Checkbutton, Entry, Frame, Label, LabelFrame, Menubutton, PanedWindow, Radiobutton, Scale и Scrollbar. Кроме того имеется несколько новых виджетов: Combobox, Notebook, Progressbar, Separator, Sizegrip и Treeview.

С точки зрения программиста главное отличие новых виджетов от старых заключается в том, что у виджетов ttk отсутствуют опции для конфигурирования его внешнего вида. Сравните, например, количество STANDARD OPTIONS для старого и нового виджета button. Конфигурация внешнего вида виджетов ttk осуществляется через темы и стили. В остальном использование виджетов ttk аналогично соответствующим виджетам tk.

Style

Style это класс для работы со стилями и темами. Именно этот класс надо использовать для конфигурирования внешнего вида виджетов. Основные методы класса:

Конфигурирование внешнего вида виджетов. В качестве аргументов принимает название стиля виджета (например "TButton") и список опций конфигурирования. Пример:

Конфигурирование внешнего вида виджетов в зависимости от их состояний (active, pressed, disabled и т.д.). В качестве аргументов принимает название стиля виджета и список опций конфигурирования, где опции представлены в виде списка. Пример:

Возвращает соответствующую опцию конфигурирования. Пример:

Изменяет layout (схему) виджета. Виджеты ttk состоят из отдельных элементов, опций конфигурирования и других вложенных layouts. Следующий пример иллюстрирует применение метода layout:

Создаёт новый элемент темы.

Возвращает список элементов текущей темы.

Возвращает список опций (конфигурацию), указанного в аргументе элемента.

Создаёт новую тему. Аргументы те же, что и в theme_settings.

Возвращает список доступных тем.

Изменяет текущую тему на указанную в аргументе.

Combobox

Виджет Combobox предназначен для отображения списка значений, их выбора или изменения пользователем. В версии tk ему подобен виджет Listbox. Разница заключается в том, что Combobox имеет возможность сворачиваться подобно свитку, а Listbox будет отображаться всегда открытым. Что бы отобразить Combobox с заранее заданными значениями в форме, достаточно сделать следующее:

Progressbar

Виджет отображает уровень загрузки.

Запускает бесконечный цикл загрузки. Шаг длиною 1 выполняется один раз в указанное время (в миллисекундах).

Останавливает цикл загрузки.

Продвигает загрузку на заданное количество шагов.

Графический пользовательский интерфейс в питон

Пользовательский графический интерфейс с Tkinter в Python Питон.

В этом уроке мы разберём создание простого графического пользовательского интерфейса (GUI) в Python Питон.
GUI расшифровывается как Graphical User Interface. На русском это означает пользовательский графический интерфейс. GUI используется во всех современных программах, он позволяет значительно облегчить работу с этими программами.
Для создания GUI в Python используется модуль tkinter. Импортируем этот модуль в нашу программу.
import tkinter as tk
Для создания GUI в Питоне нужно создать окно для него. Чтобы создать окно win, используйте команду tk.Tk()
win = tk.Tk()
В конце любой программы на tkinter в Питон нужно писать команду win.mainloop(), win это название окна для интерфейса. Команда mainloop() не позволяет окну закрываться сразу же при исполнении программы. Если не поместить эту команду в конец программы на Python, то окно для интерфейса закроется сразу же после запуска программы.
win.mainloop()
Изменим название окна для интерфейса Питон с помощью команды win.title(“”). В кавычках пишется текст, который будет отображаться в названии окна.
win.title("itrobo.ru")
Зададим окно размером 350×200 пикселей. Для этого в Python используется команда win.geometry(AxB), где A это ширина окна, B это высота окна. A и B пишутся в кавычках и разделяются символом “x”.
win.geometry("350x200")
Элементы в tkinter в Питоне создаются с помощью команды
элемент = tk.название_элемента(параметры_элемента)

Элемент метка label в Python

Пример программы на Python графический интерфейс метка

import tkinter as tk
win = tk.Tk()
win.title("itrobo.ru")
win.geometry("300x300")
res = tk.Label(win, text = "Привет")
res.grid(row = 3, column = 0)
win.mainloop()

Для изменения надписи на метке используется команда имя метки.configure(text="новый текст метки")
Например
res.configure(text="мою надпись поменяли")

Элемент Button кнопка в Python

Чтобы задать кнопку в графическом интерфейсе python необходимо использовать команду
название объекта кнопка = tk.Button(win, text = “надпись на кнопке”, сomand = имя функции при нажатии)
Например
button=tk.Button(win, text = “нажми меня”, comand =onclick)
создаст нкнопку с именем button надпись на кнопке Нажми меня, при нажатии будет вызываться процедура onclik
для вывода кнопки на экран мы используем разметку и команду
имя кнопки.grid(row = номер строки, column = номер столбца)
например
button.grid(row = 1, column = 1)
Приведем пример программы графический интерфейс на Python с кнопкой и меткой, при нажатии на кнпоку название метки меняется на Меня нажали
import tkinter as tk
win = tk.Tk()
win.title("itrobo.ru")
win.geometry("300x300")
res = tk.Label(win, text = "-")
res.grid(row = 3, column = 0)
def onclick():
res.configure(text = "меня нажали")
button = tk.Button(win, text = "нажми меня", command = onclick)
button.grid(row = 1, column = 1)
win.mainloop()

Элемент текстовое поле в графическом интерфейсе python

Для задания тектового поля в графическом пользовательском интерфейсе Python используется команда
имя текстового поля=tk.Entry(имя окна)
например команда
text1=tk.Entry(win)
cоздаст объект текстовое поле с именем text1 в окне win
для отображения в окне интерфейса python используется команда
имя элемента.grid(row=номер строки, column=номер столбца)
Например
text1.grid(row=1,column=1)
Чтобы получить данные из текстового поля в Python используется команда
имя поля.get()
Например
znach=float(text1.get())
записывает в переменную znach числовое значение поля text1

Пример программы с графическим пользовательским интерфейсом в Python простейший калькулятор

Сделаем программу калькулятор на Python. В двух текстовых полях пользователь вводит два числа. При нажатии на кнопку в метке будет показываться сумма этих чисел.
Введём два текстовых поля и метку. Первое поле назовём num1, второе num2, метку назовём res. Зададим кнопку button. Поля для ввода текста задаются с помощью команды tk.Entry(win)
num1 = tk.Entry(win)
num1.grid(row = 0, column = 0)
num2 = tk.Entry(win)
num2.grid(row = 2, column = 0)
res = tk.Label(win, text = "-")
res.grid(row = 3, column = 0)
Зададим кнопку button с помощью команды
button = tk.Button(win, text = “Сумма”)
button это название кнопки, win это окно, где отображается кнопка, text = “Сумма” это параметр, определяющий текст на кнопке.
Если вы просто зададите кнопку, запустите программу на Питоне и нажмёте на кнопку, ничего не произойдёт. Чтобы задать действие по нажатию кнопки, нужно использовать параметр кнопки command. Разберём процедуру нахождения суммы и нажатия кнопки.
При нажатии на кнопку в Python мы должны получить значения двух чисел в текстовых полях, сложить эти числа и вывести сумму в метку. Создадим для этого отдельную процедуру summation(). Подробно о процедурах в Python
Чтобы получить числа из текстовых полей в Питоне, используем команду num1.get() Обратите внимание, что текстовые поля всегда возвращают данные в виде строк, поэтому переведём их числа, используя команду float()
one = float(num1.get())
two = float(num2.get())
Теперь создадим переменную result, в которой будет храниться сумма полученных чисел.
result = one + two
После того, как мы задали метку res с результатом в Питон, нужно изменить текст в ней с “-” на результат. Это можно сделать с помощью команды res.configure(text) и форматированного вывода.
res.configure(text = "= %s" % result)
После того, как мы создали процедуру для вывода чисел в Python, назначим нажатие кнопки на неё. Это можно сделать, присвоив параметр command созданной процедуре.
button = tk.Button(win, text = "Сумма", command = summation)
button.grid(row = 1, column = 1)
Полный код программы на python с графическим пользовательским интерфейсом простейший калькулятор.
import tkinter as tk
win = tk.Tk()
win.title("itrobo.ru")
win.geometry("400x400")
num1 = tk.Entry(win)
num1.grid(row = 0, column = 0)
num2 = tk.Entry(win)
num2.grid(row = 2, column = 0)
res = tk.Label(win, text = "-")
res.grid(row = 3, column = 0)
def summation():
one = float(num1.get())
two = float(num2.get())
result = one + two
res.configure(text = "= %s" % result)
button = tk.Button(win, text = "Сумма", command = summation)
button.grid(row = 1, column = 1)
win.mainloop()

Быстрый, мощный интерфейс на Python

И минимум зависимостей

Dear PyGui принципиально отличается от других фреймворков GUI Python. Рендеринг на GPU, более 70 виджетов, встроенная поддержка асинхронности — это лишь некоторые возможности Dear PyGui. Руководством по работе с этим пакетом делимся к старту курса по разработке на Python.

Парадигма Retained Mode позволяет создавать чрезвычайно динамичные интерфейсы. Dear PyGui не использует нативные виджеты, а рисует с помощью видеокарты компьютера, как PyQt (используя API рендеринга DirectX11, Metal и Vulkan).

Почему Dear PyGui?

По сравнению с другими библиотеками Python GUI Dear PyGui уникален:

Простая встроенная поддержка асинхронных функций.

Полное управление темами и стилями.

Простое встроенное окно логирования.

70+ виджетов, сотни их комбинаций.

Подробная документация, примеры и беспрецедентная поддержка.

Основные моменты

Темы — 10 встроенных тем и система пользовательских тем.

Graphing — API для работы с графиками (обертка ImPlot).

Canvas — низкоуровневый API для рисования.

Logging — API логирования.

Виджеты — просто прокрутите вниз, чтобы увидеть их.

Установка

Убедитесь, что у вас установлен как минимум Python 3.7 (64 бит).

Зависимости

Начинаем писать GUI

Dear PyGui предоставляет разработчикам python простой способ создания быстрых и мощных графических интерфейсов для скриптов. Dear PyGui состоит из окна программы, окон и виджетов. Окно программы является главным окном вашей программы и создаётся в конце основного скрипта вызовом start_dearpygui().

Вывод

В приведённом ниже примере программы показано окно программы и ещё одно окно, в котором с помощью встроенной функции документации отображается документация:

Встроенная документация

Dear PyGui состоит из двух модулей: dearpygui.core и dearpygui.simple.

dearpygui.core содержит базовую функциональность Dear PyGUI. Через ядро можно делать всё. На самом деле это расширение на языке Си, просто обёрнутое в модуль.

dearpygui.simple содержит обёртки и утилиты уже из кода ядра для удобства работы с Dear PyGui.

Инструменты разработки

В Dear PyGui есть полезные инструменты разработки. Метод show_source() принимает имя входного файла Python.

Встроенное логирование

Мощный инструмент разработки — Logger, он вызывается методом show_logger(). Уровней логирования 6: Trace, Debug, Info, Warning, Error, Off. Логгер выведет установленный уровень и отфильтрует все уровни ниже.

Логирование

Уровень лога mvTRACE покажет все команды.

Пишем виджеты и контейнеры

Элементы библиотеки можно разделить на:

обычные предметы: поля ввода, кнопки;

контейнеры (окно, всплывающее окно, всплывающая подсказка, элемент-потомок);

элементы макета (группа, следующая колонка (next_column)).

Элементы добавляются командами с префиксом add_.

Виджеты

Каждый элемент должен иметь уникальное имя. По умолчанию, если это применимо, имя станет меткой элемента. При желании можно изменить метку:

Поставьте ## после имени (например displayed_name##unique_part). Всё после ## в отображаемом имени будет скрыто.

Ключевое слово label, которое отобразит метку вместо имени.

Некоторые имена элементов автоматически генерируются для элементов без аргументов имени в функции (т. е. same_line). Но у них есть необязательное ключевое слово name, и его можно заполнить, когда понадобится ссылка на элемент.

Контекстные менеджеры dearpygui.simple автоматизируют вызов функции end, позволяют сворачивать код и в самом коде показывают иерархию.

По умолчанию элементы создаются в порядке их описания в коде.

Но, указав контейнер parent, элементы можно добавлять не по порядку. parent вставляет виджет в конец списка дочерних элементов родителя. before в сочетании с ключевым словом parent помещает один элемент перед другим в списке элементов-потомков.

Виджеты

Каждый виджет ввода имеет значение, которое можно задать с помощью ключевого слова default_value при создании или во время выполнения команды set_value. Для доступа к значению виджета можно использовать команду get_value. Мы также можем передавать значение виджета непосредственно в переменную python и из неё.

Виджеты и обратные вызовы окна

Каждый элемент ввода имеет обратный вызов, который выполняется при взаимодействии с виджетом.

Обратные вызовы добавляют виджетам функциональность. Они могут присваиваться до или после создания элемента функцией set_item_callback, как в коде ниже.

Каждый обратный вызов должен принимать аргументы sender и data.

sender сообщает обратному вызову имя элемента, которым он вызывается.

Аргумент data применяется разными стандартными обратными вызовами для отправки дополнительных данных через определение callback_data.

Виджеты оконного типа имеют специальные обратные вызовы, которые срабатывают при таких событиях, как изменение размера или закрытие окна. Обратные вызовы для конкретных окон могут быть применены к виджету любого типа окна. on_close будет запускать обратный вызов, назначенный ключевому слову, при закрытии окна, а set_resize_callback() будет запускаться при каждом изменении размера контейнера и может быть установлен на любое конкретное окно ключевым словом handler, по умолчанию это MainWindow.

Если вы хотите, чтобы обратный вызов выполнялся на каждом фрейме, воспользуйтесь set_render_callback().

Добавляем и удаляем виджеты в рантайме

С помощью Dear PyGui вы можете динамически добавлять и удалять любые элементы во время выполнения программы. Это можно сделать, используя обратный вызов для выполнения команды add_* нужного элемента, указав родителя, к которому будет принадлежать элемент. По умолчанию, если не указан родительский элемент, виджет будет добавлен в MainWindow.Используя ключевое слово before при добавлении элемента, вы можете контролировать, перед каким элементом родительской группы будет находиться новый элемент. По умолчанию новый виджет помещается в конец.

Хранилище значений и данных

Когда новый виджет добавлен, в системное хранилище добавляется некое значение. По умолчанию идентификатор этого значения — имя виджета. Значения извлекаются из системы значений с помощью get_value("source name"). Меняются значения вручную, методом set_value("source name"). Чтобы виджеты разных типов значений могли использовать одно и то же значение в системе хранения, сначала должно быть создано большее значение.

Помните, что вы можете хранить любой объект Python в хранилище данных, даже пользовательские типы данных.

Вот так можно хранить отображение:

Очень важный виджет для функциональности GUI — это бар меню. Строки меню всегда отображаются в верхней части окна и состоят в основном из:

Лента главного меню.

Конкретные элементы меню.

Элементы меню добавляются слева направо, а элементы подменю — сверху вниз. Они могут быть вложенными, насколько это необходимо:

Диалоги выбора файлов и каталогов

Диалог выбора каталога вызывается select_directory_dialog(), которому необходим обратный вызов.

Файловые диалоги вызываются open_file_dialog(), которому должен быть задан обратный вызов. Аргумент data возвращаемого обратного вызова будет заполнен списком строк из пути к папке и к файлу. Расширения — это дополнительное ключевое слово к диалогу файлов, которое позволяет отфильтровать файлы в диалоге по расширениям.

Графики

В Dear PyGui есть «простые графики» и «графики», оба типа могут быть динамическими.

Графики

Простые графики берут список и строят данные по оси y в зависимости от количества элементов в списке. Это могут быть линейные графики или гистограммы.

В «графиках» используются координаты x и y. Вызывать их нужно командой add_plot(), затем данные могут быть добавлены в виде линейного или рассеянного ряда. Вот список возможностей:

Клик с перетаскиванием панорамирует график.

Клик с перетаскиванием по оси панорамирует график в одном направлении.

Двойной клик масштабирует данные.

Правый клик и перетаскивание увеличивают область.

Двойной правый клик открывает настройки.

Shift + правый клик и перетаскивание масштабирует область, заполняющую текущую ось.

Прокрутка колёсика позволяет рассмотреть детали.

Прокрутка колёсика по оси увеличивает только по этой оси.

Можно переключать и скрывать наборы данных на легенде.

Простые графики можно сделать динамическими, изменив значение вызова plot с помощью set_value().

Управление графиками

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

Представления графиков

Рисование и холст

В Dear PyGui есть низкоуровневый API, хорошо подходящий для рисования примитивов, пользовательских виджетов и даже динамических рисунков.

Рисунок запускается вызовом add_drawing(). Начало холста — в левом нижнем углу.

Хотя рисунки можно сделать динамичными, очищая и перерисовывая всё заново, предлагается метод эффективнее: чтобы сделать рисунок динамичным, мы должны использовать ключевое слово tag для обозначения элементов, которые хотим перерисовать. Затем нужно просто вызвать команду рисования, используя тот же тег. Это позволит удалить только один элемент и перерисовать его с помощью новой команды.

Дельта-время и внутренние часы

Dear PyGui имеет встроенные часы для проверки общего времени работы. get_total_time(), возвращается общее время работы в секундах.

Также с помощью команды get_delta_time() мы можем проверить время между кадрами рендеринга в секундах.

Таблицы

Dear PyGui имеет простой API таблиц, который хорошо подходит для статических и динамических таблиц.

Таблицы

Виджет таблицы запускается вызовом add_table(). Для редактирования виджета таблицы мы можем использовать методы add_row(), add_column(), которые добавят строку/столбец к последнему слоту таблицы.

В качестве альтернативы мы можем вставить строки/столбцы с помощью insert_row(), insert_column(). Столбцы и строки вставляются в соответствии с их индексным аргументом. Если указанный индекс уже существует, то выходящие столбцы/строки будут удалены, а новая строка/столбец будет вставлена по указанному индексу.

Кроме того, при добавлении или вставке строки/столбца неуказанные ячейки по умолчанию окажутся пустыми. Кроме того, заголовки и ячейки могут быть переименованы, а их значения изменены. Ячейки можно выбирать. Это означает, что мы можем применить обратный вызов к таблице и получить через отправителя данные о том, какая ячейка была выбрана, и даже получить текст внутри ячейки.

Опрос устройств ввода

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

Опрос устройств ввода Вот список функций опроса