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

Содержание

создаём простое приложение с 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 придётся устанавливать через терминал. Установить всё, что нам понадобится, одной командой можно, например, так:

# для Fedora:
$ sudo dnf install python3-qt5 qt-creator
# для Debian/Ubuntu:
$ sudo apt install python3-qt5 pyqt5-dev-tools qtcreator

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

$ pyuic5
Error: one input ui-file must be specified

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

Если вы используете Windows, то, скорее всего, путь C:\Python36\Scripts (измените 36 на вашу версию Python) не прописан в вашем PATH. Загляните в этот тред на Stack Overflow, чтобы узнать, как решить проблему.

Дизайн

Основы

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

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

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

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

Все элементы формы и их иерархия по умолчанию отображаются в правой части окна Qt Designer под названием Object Inspector

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

В итоге мы имеем почти пустую форму. Единственный оставшийся объект — centralwidget, но он нам понадобится, поэтому с ним мы ничего не будем делать.

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

Макеты

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

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

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

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

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

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

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

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

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

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

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

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

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

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

View.

Нажмите на кнопку, которую вы добавили в форму. Теперь в Property Editor вы должны видеть все свойства этого элемента. В данный момент нас интересуют objectName и text в разделе QAbstractButton. Вы можете сворачивать разделы в Property Editor нажатием по названию раздела.

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

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

Именем объекта списка является listWidget, что вполне подходит в данном случае.

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

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

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

.ui-файла в Python-файл, который мы потом сможем импортировать и использовать. Для этого мы используем команду pyuic5 из терминала/командной строки.

Чтобы конвертировать .ui-файл в Python-файл с названием design.py, используйте следующую команду:

$ pyuic5 path/to/design.ui -o output/path/to/design.py

Пишем код

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

Создайте файл main.py в папке, где находится design.py.

Другие интересные статьи по Python.

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

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

import sys  # sys нужен для передачи argv в QApplication
from PyQt5 import QtWidgets

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

import design  # Это наш конвертированный файл дизайна

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

class ExampleApp(QtWidgets.QMainWindow, design.Ui_MainWindow):
    def __init__(self):
        # Это здесь нужно для доступа к переменным, методам
        # и т.д. в файле design.py
        super().__init__()
        self.setupUi(self)  # Это нужно для инициализации нашего дизайна

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

def main():
    app = QtWidgets.QApplication(sys.argv)  # Новый экземпляр QApplication
    window = ExampleApp()  # Создаём объект класса ExampleApp
    window.show()  # Показываем окно
    app.exec_()  # и запускаем приложение

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

if __name__ == '__main__':  # Если мы запускаем файл напрямую, а не импортируем
    main()  # то запускаем функцию main()

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

import sys  # sys нужен для передачи argv в QApplication
from PyQt5 import QtWidgets
import design  # Это наш конвертированный файл дизайна

class ExampleApp(QtWidgets.QMainWindow, design.Ui_MainWindow):
    def __init__(self):
        # Это здесь нужно для доступа к переменным, методам
        # и т.д. в файле design.py
        super().__init__()
        self.setupUi(self)  # Это нужно для инициализации нашего дизайна

def main():
    app = QtWidgets.QApplication(sys.argv)  # Новый экземпляр QApplication
    window = ExampleApp()  # Создаём объект класса ExampleApp
    window.show()  # Показываем окно
    app.exec_()  # и запускаем приложение

if __name__ == '__main__':  # Если мы запускаем файл напрямую, а не импортируем
    main()  # то запускаем функцию main()

Если запустить этот код: $ python3 main.py, то наше приложение запустится!

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

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

Примечание Весь дальнейший код пишется внутри класса ExampleApp.

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

self.btnBrowse.clicked.connect(self.browse_folder)

Добавьте эту строку в метод __init__ класса ExampleApp, чтобы выполнить привязку при запуске приложения. А теперь взглянем на неё поближе:

  • self.btnBrowse
    : здесь btnBrowse — имя объекта, который мы определили в Qt Designer. self говорит само за себя и означает принадлежность к текущему классу;
  • clicked — событие, которое мы хотим привязать. У разных элементов разные события, например, у виджетов списка есть itemSelectionChanged и т.д.;
  • connect() — метод, который привязывает событие к вызову переданной функции;
  • self. browse_folder — просто функция (метод), которую мы описали в классе ExampleApp.

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

directory = QtWidgets.QFileDialog.getExistingDirectory(self, "Выберите папку")

Если пользователь выберет директорию, переменной directory присвоится абсолютный путь к выбранной директории, в противном случае она будет равна None. Чтобы не выполнять код дальше, если пользователь закроет диалог, мы используем команду if directory:.

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

import os

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

os.listdir(path)

Для добавления элементов в listWidget мы используем метод addItem(), а для удаления всех элементов у нас есть self. listWidget.clear().

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

def browse_folder(self):
    self.listWidget.clear()  # На случай, если в списке уже есть элементы
    directory = QtWidgets.QFileDialog.getExistingDirectory(self, "Выберите папку")
    # открыть диалог выбора директории и установить значение переменной
    # равной пути к выбранной директории

    if directory:  # не продолжать выполнение, если пользователь не выбрал директорию
        for file_name in os.listdir(directory):  # для каждого файла в директории
            self.listWidget.addItem(file_name)   # добавить файл в listWidget

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

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

import sys  # sys нужен для передачи argv в QApplication
import os  # Отсюда нам понадобятся методы для отображения содержимого директорий

from PyQt5 import QtWidgets

import design  # Это наш конвертированный файл дизайна

class ExampleApp(QtWidgets. QMainWindow, design.Ui_MainWindow):
    def __init__(self):
        # Это здесь нужно для доступа к переменным, методам
        # и т.д. в файле design.py
        super().__init__()
        self.setupUi(self)  # Это нужно для инициализации нашего дизайна
        self.btnBrowse.clicked.connect(self.browse_folder)  # Выполнить функцию browse_folder
                                                            # при нажатии кнопки

    def browse_folder(self):
        self.listWidget.clear()  # На случай, если в списке уже есть элементы
        directory = QtWidgets.QFileDialog.getExistingDirectory(self, "Выберите папку")
        # открыть диалог выбора директории и установить значение переменной
        # равной пути к выбранной директории

        if directory:  # не продолжать выполнение, если пользователь не выбрал директорию
            for file_name in os.listdir(directory):  # для каждого файла в директории
                self. listWidget.addItem(file_name)   # добавить файл в listWidget

def main():
    app = QtWidgets.QApplication(sys.argv)  # Новый экземпляр QApplication
    window = ExampleApp()  # Создаём объект класса ExampleApp
    window.show()  # Показываем окно
    app.exec_()  # и запускаем приложение

if __name__ == '__main__':  # Если мы запускаем файл напрямую, а не импортируем
    main()  # то запускаем функцию main()

 


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

Перевод статьи «PyQt: Getting started with PyQt and Qt Designer»

Автоматизация Windows GUI приложений на Python — база знаний

Доброго всем времени суток. Спешу познакомить вас с модулем pywinauto для python. Он распространяется под лицензией GNU Lesser GPL, так что абсолютно бесплатен, позволяет автоматизировать тестирование или просто рутинные процессы для Windows приложений со стандартными контролами.

Приведу пример кода:

import pywinauto

app = pywinauto.application.Application()
app.start_(“notepad.exe”)
app.Notepad.MenuSelect(“Help->About Notepad”)
app.AboutNotepad.OK.Click()
app.Notepad.Edit.TypeKeys (“pywinauto Works!”, with_spaces = True)

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

Достоинства:

  • pywinauto — нативный модуль python
  • простой интерфейс доступа к элементам графического интерфейса
  • встроенный инструментарий для автоматизации

Из первого пункта, на самом деле, выплывает множество приятных вещей: не нужно таскать лишние dllки, стиль кодирования привычный для любого укротителя питона. А также вся мощь языка (и всех доступных модулей) в одной коробке! Можно с легкостью реализовать любое функциональное тестирование через графический интерфейс.

Со вторым пунктом, я думаю, все понятно из примера. Под встроенным инструментарием я понимаю спектр функций Wait, необходимых для ожидания нового окна или конкретного состояния элемента UI а также возможность делать скриншот любого элемента и возможность сохранить целый диалог в xml.

Недостатки:

  • работа только со стандартными контролами
  • последнее обновление было в начале 2011 года

pywinauto работает только со стандартными (Windows API) контролами. На самом деле, этого вполне достаточно для подавляющего большинства десктоп приложений. Хотя, в принципе, pywinauto будет видеть окно с нестандартными контролами, но кликнуть можно будет лишь по координатам. А это можно и без pywinauto сделать.

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

Утилита SWAPY уже описана в разделе инструменты. Вкратце скажу, что это аналог UI Spy на pywinauto, еще она умеет генерировать python код и выполнять действия непосредственно из себя. Кстати, SWAPY сразу даст вам понять, подходит ли pywinauto для автоматизации Вашего приложения или нет.

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

До встречи.

Просмотрите каталог Windows GUI с помощью Python 2.7



Я использую Windows XP с Python 2.7.2 & Tkinter GUI комплектом. Я хочу построить простой GUI, который имеет текстовое поле и кнопку «Browse», которая будет выбирать файл через каталоги, такие как C:\ (точно так же, как Windows Explorer). Выбранный файл будет отображаться в текстовом поле GUI. Надеюсь, это достаточно описательно.

python
Поделиться Источник guiNachos     28 февраля 2012 в 23:04

3 ответа




8

У меня есть еще кое-что, что может тебе помочь.:

    ## {{{ http://code. activestate.com/recipes/438123/ (r1)
    # ======== Select a directory:

    import Tkinter, tkFileDialog

    root = Tkinter.Tk()
    dirname = tkFileDialog.askdirectory(parent=root,initialdir="/",title='Please select a directory')
    if len(dirname ) > 0:
        print "You chose %s" % dirname 


    # ======== Select a file for opening:
    import Tkinter,tkFileDialog

    root = Tkinter.Tk()
    file = tkFileDialog.askopenfile(parent=root,mode='rb',title='Choose a file')
    if file != None:
        data = file.read()
        file.close()
        print "I got %d bytes from this file." % len(data)


    # ======== "Save as" dialog:
    import Tkinter,tkFileDialog

    myFormats = [
        ('Windows Bitmap','*.bmp'),
        ('Portable Network Graphics','*.png'),
        ('JPEG / JFIF','*.jpg'),
        ('CompuServer GIF','*.gif'),
        ]

    root = Tkinter.Tk()
    fileName = tkFileDialog.asksaveasfilename(parent=root,filetypes=myFormats ,title="Save the image as...")
    if len(fileName ) > 0:
        print "Now saving under %s" % nomFichier
    ## end of http://code. activestate.com/recipes/438123/ }}}

Вот сайт, с которого я его получил: http:/ / code.activestate.com / рецепты / 438123-file-tkinter-dialogs/

Поделиться udpatil     29 февраля 2012 в 23:46



0

Взгляните на это (непроверенное): http:/ / www.java2s.com/Code/Python/GUI-Tk/SimpleEditor.htm возможно, Вам просто нужно добавить диалог ‘open’, но с помощью документации Tkinter это должно быть легко.

Поделиться ChristopheD     28 февраля 2012 в 23:06



0

Я предлагаю вам не использовать tkinter, а использовать wxwindows. Я использовал и то, и другое раньше с разным уровнем успеха (я просто возился с основами). Если вы все же решите использовать wxwindows, вот сайт, который действительно полезен: http:/ / www.wxpython. org/onlinedocs. php

Поделиться udpatil     28 февраля 2012 в 23:10


  • Как выключить windows 8 с помощью python 2.7 с помощью таймера

    Я делаю небольшой проект, чтобы узнать больше о python 2.7. Я делаю таймер выключения, у меня все настроено GUI, и мне просто нужна команда для выключения windows 8. Команда cmd: shutdown /t xxx. Я попробовал следующее: import subprocess time = 10 subprocess.call([shutdown.exe, /t, time]) import…

  • Python GUI — 2.7 для 3.5

    from tkinter import * #Create the window root = Tk() #Modify root window root.title(Simple GUI) root.geometry(200×50) app = frame(root) label = Label(app, text = This is a label) label.grid() #kick of the event loop root.mainloop() Я следую учебнику YouTube, чтобы узнать о Python tkinter GUI. Но…


Похожие вопросы:


Функциональность Readline на windows с python 2. 7

Мне нужно импортировать функциональность readline в программу, написанную на python. В настоящее время я использую версию 2.7, а сторонние пакеты, которые я видел, работают только до версии 2.6….


Запуск Scapy на Windows с Python 2.7

Мне нравится использовать Scapy с Python v2.7 под Windows 7. Как я могу установить необходимый модуль pypcap для Python 2.7? Можно ли будет сделать Python скриптов в зависимости от Scapy в…


Q: установите pyHook с pip для Python 2.7 на Windows

Мой компьютер работает на Windows 7 (x64), и я установил Anaconda 2 и Anaconda 3 как в 32-битной версии, чтобы иметь возможность использовать Python 2.7 или 3.5 в зависимости от моих проектов. Я…


Вызов приложения Windows, которое требует ввода через GUI с использованием скрипта Python 2.7: обработка ввода-вывода

Я пытаюсь автоматизировать приложение Windows, которое требует ввода через скрипт GUI с использованием скрипта Python 2. 7. Я вызываю exe через встроенные функции подпроцесса python следующим…


как скомпилировать libnet для python 2.7 на windows

У меня есть python 2.7 на windows xp, мне нужен libnet, но он не поддерживается для python 2.7 . Я попытался скомпилировать его с помощью cygwin, так как я не использую python на cygwin gnu, и я не…


Как выключить windows 8 с помощью python 2.7 с помощью таймера

Я делаю небольшой проект, чтобы узнать больше о python 2.7. Я делаю таймер выключения, у меня все настроено GUI, и мне просто нужна команда для выключения windows 8. Команда cmd: shutdown /t xxx. Я…


Python GUI — 2.7 для 3.5

from tkinter import * #Create the window root = Tk() #Modify root window root.title(Simple GUI) root.geometry(200×50) app = frame(root) label = Label(app, text = This is a label) label.grid() #kick…


python 2.7 windows silent installer (. msi) — опция командной строки для установки пути?

При установке python 2. 7 на Windows с помощью silent installer (. msi) есть ли опция командной строки для добавления Python в переменную окружения path, например опция GUI? Установщик Python 3.5 по…


оранжевая python 2.7 установка

В настоящее время у меня есть Anaconda python 2.7, и я хочу добавить оранжевый GUI . Заранее прошу прощения, если это любительский вопрос. Когда я загружаю установщик для Orange 2.7, он говорит, что…


Установка tensorflow CPU с windows 10 anaconda python 2.7

Я использую anaconda, python 2.7, windows 10. Я хотел бы установить tensorflow с помощью conda. Однако у меня есть эта ошибка: (tensorflow) C:\Users\cenk>conda install -c conda-forge tensorflow…

как подружиться c MS UI Automation

Python библиотека pywinauto — это open source проект по автоматизации десктопных GUI приложений на Windows. За последние два года в ней появились новые крупные фичи:

  • Поддержка технологии MS UI Automation. Интерфейс прежний, и теперь поддерживаются: WinForms, WPF, Qt5, Windows Store (UWP) и так далее — почти все, что есть на Windows.
  • Система бэкендов/плагинов (сейчас их двое под капотом: дефолтный "win32" и новый "uia"). Дальше плавно двигаемся в сторону кросс-платформенности.
  • Win32 хуки для мыши и клавиатуры (hot keys в духе pyHook).

Также сделаем небольшой обзор того, что есть в open source для десктопной автоматизации (без претензий на серьезное сравнение).

Эта статья — частично расшифровка доклада с конференции SQA Days 20 в Минске (видеозапись и слайды), частично русская версия Getting Started Guide для pywinauto.

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

Координатный метод

Хардкодим точки кликов, надеемся на удачные попадания.
[+] Кросс-платформенный, легко реализуемый.
[+] Легко сделать «record-replay» запись тестов.
[-] Самый нестабильный к изменению разрешения экрана, темы, шрифтов, размеров окон и т.п.
[-] Нужны огромные усилия на поддержку, часто проще перегенерить тесты с нуля или тестировать вручную.
[-] Автоматизирует только действия, для верификации и извлечения данных есть другие методы.

Инструменты (кросс-платформенные): autopy, PyAutoGUI, PyUserInput и многие другие. Как правило, более сложные инструменты включают в себя эту функциональность (не всегда кросс-платформенно).

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

Другой вариант: выделять для тестов только одну машину со стабильными настройками (не кросс-платформенно, но в каких-то случаях годится).

Распознавание эталонных изображений

[+] Кросс-платформенный
[+-] Относительно надежный (лучше, чем координатный метод), но всё же требует хитростей.
[-+] Относительно медленный, т.к. требует ресурсов CPU для алгоритмов распознавания.
[-] О распознавании текста (OCR), как правило, речи не идёт => нельзя достать текстовые данные. Насколько мне известно, существующие OCR решения не слишком надежны для этого типа задач, и широкого применения не имеют (welcome в комменты, если это уже не так).

Инструменты: Sikuli, Lackey (Sikuli-совместимый, на чистом Python), PyAutoGUI.

Accessibility технологии

[+] Самый надежный метод, т.к. позволяет искать по тексту, независимо от того, как он отрисован системой или фреймворком.
[+] Позволяет извлекать текстовые данные => проще верифицировать результаты тестов.
[+] Как правило, самый быстрый, т.к. почти не расходует ресурсы CPU.
[-] Тяжело сделать кросс-платформенный инструмент: абсолютно все open-source библиотеки поддерживают одну-две accessibility технологии. Windows/Linux/MacOS целиком не поддерживает никто, кроме платных типа TestComplete, UFT или Squish.
[-] Не всегда такая технология в принципе доступна. Например, тестирование загрузочного экрана внутри VirtualBox’а — тут без распознавания изображений не обойтись. Но во многих классических случаях все-таки accessibility подход применим. О нем дальше и пойдет речь.

Инструменты: TestStack.White на C#, Winium.Desktop на C# (Selenium совместимый), MS WinAppDriver на C# (Appium совместимый), pywinauto, pyatom (совместим с LDTP), Python-UIAutomation-for-Windows, RAutomation на Ruby, LDTP (Linux Desktop Testing Project) и его Windows версия Cobra.

LDTP — пожалуй, единственный кросс-платформенный open-source инструмент (точнее семейство библиотек) на основе accessibility технологий. Однако он не слишком популярен. Сам не пользовался им, но по отзывам интерфейс у него не самый удобный. Если есть позитивные отзывы, прошу поделиться в комментах.

Тестовый backdoor (a.k.a. внутренний велосипед)

Для кросс-платформенных приложений сами разработчики часто делают внутренний механизм для обеспечения testability. Например, создают служебный TCP сервер в приложении, тесты к нему подключаются и посылают текстовые команды: на что нажать, откуда взять данные и т.п. Надежно, но не универсально.

Основные десктопные accessibility технологии

Старый добрый Win32 API

Большинство Windows приложений, написанных до выхода WPF и затем Windows Store, построены так или иначе на Win32 API. А именно, MFC, WTL, C++ Builder, Delphi, VB6 — все эти инструменты используют Win32 API. Даже Windows Forms — в значительной степени Win32 API совместимые.

Инструменты: AutoIt (похож на VB) и Python обертка pyautoit, AutoHotkey (собственный язык, есть IDispatch COM интерфейс), pywinauto (Python), RAutomation (Ruby), win32-autogui (Ruby).

Microsoft UI Automation

Главный плюс: технология MS UI Automation поддерживает подавляющее большинство GUI приложений на Windows за редкими исключениями. Проблема: она не сильно легче в изучении, чем Win32 API. Иначе никто бы не делал оберток над ней.

Фактически это набор custom COM интерфейсов (в основном, UIAutomationCore.dll), а также имеет .NET оболочку в виде namespace System.Windows.Automation. Она, кстати, имеет привнесенный баг, из-за которого некоторые UI элементы могут быть пропущены. Поэтому лучше использовать UIAutomationCore.dll напрямую (если слышали про UiaComWrapper на C#, то это оно).

Разновидности COM интерфейсов:

(1) Базовый IUknown — «the root of all evil». Самый низкоуровневый, ни разу не user-friendly.
(2) IDispatch и производные (например, Excel.Application), которые можно использовать в Python с помощью пакета win32com.client (входит в pyWin32). Самый удобный и красивый вариант.
(3) Custom интерфейсы, с которыми умеет работать сторонний Python пакет comtypes.

Инструменты: TestStack.White на C#, pywinauto 0.6.0+, Winium.Desktop на C#, Python-UIAutomation-for-Windows (у них исходный код сишных оберток над UIAutomationCore.dll не раскрыт), RAutomation на Ruby.

AT-SPI

Несмотря на то, что почти все оси семейства Linux построены на X Window System (в Fedora 25 «иксы» поменяли на Wayland), «иксы» позволяют оперировать только окнами верхнего уровня и мышью/клавиатурой. Для детального разбора по кнопкам, лист боксам и так далее — существует технология AT-SPI. У самых популярных оконных менеджеров есть так называемый AT-SPI registry демон, который и обеспечивает для приложений автоматизируемый GUI (как минимум поддерживаются Qt и GTK).

Инструменты: pyatspi2.

pyatspi2, на мой взгляд, содержит слишком много зависимостей типа того же PyGObject. Сама технология доступна в виде обычной динамической библиотеки libatspi.so. К ней имеется Reference Manual. Для библиотеки pywinauto планируем реализовать поддержку AT-SPI имеено так: через загрузку libatspi.so и модуль ctypes. Есть небольшая проблема только в использовании нужной версии, ведь для GTK+ и Qt приложений они немного разные. Вероятный выпуск pywinauto 0.7.0 с полноценной поддержкой Linux можно ожидать в первой половине 2018-го.

Apple Accessibility API

На MacOS есть собственный язык автоматизации AppleScript. Для реализации чего-то подобного на Python, разумеется, нужно использовать функции из ObjectiveC. Начиная, кажется, еще с MacOS 10.6 в предустановленный питон включается пакет pyobjc. Это также облегчит список зависимостей для будущей поддержки в pywinauto.

Инструменты: Кроме языка Apple Script, стоит обратить внимание на ATOMac, он же pyatom. Он совместим по интерфейсу с LDTP, но также является самостоятельной библиотекой. На нем есть пример автоматизации iTunes на macOs, написанный моим студентом. Есть известная проблема: не работают гибкие тайминги (методы waitFor*). Но, в целом, неплохая вещь.


Как начать работать с pywinauto

Первым делом стоит вооружиться инспектором GUI объектов (то, что называют Spy tool). Он поможет изучить приложение изнутри: как устроена иерархия элементов, какие свойства доступны. Самые известные инспекторы объектов:

  • Spy++ — входит в поставку Visual Studio, включая Express или Community Edition. Использует Win32 API. Также известен его клон AutoIt Window Info.
  • Inspect.exe — входит в Windows SDK. Если он у вас установлен, то на 64-битной Windows можно найти его в папке C:\Program Files (x86)\Windows Kits\<winver>\bin\x64. В самом инспекторе нужно выбрать режим UI Automation вместо MS AA (Active Accessibility, предок UI Automation).

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

  • backend=»win32″ — пока используется по умолчанию, хорошо работает с MFC, WTL, VB6 и другими legacy приложениями.
  • backend=»uia» — новый бэкенд для MS UI Automation: идеально работает с WPF и WinForms; также хорош для Delphi и Windows Store приложений; работает с Qt5 и некоторыми Java приложениями. И вообще, если Inspect.exe видит элементы и их свойства, значит этот бэкенд подходит. В принципе, большинство браузеров тоже поддерживает UI Automation (Mozilla по умолчанию, а Хрому при запуске нужно скормить ключ командной строки --force-renderer-accessibility, чтобы увидеть элементы на страницах в Inspect.exe). Конечно, конкуренция с Selenium в этой области навряд ли возможна. Просто еще один способ работать с браузером (может пригодиться для кросс-продуктового сценария).

Входные точки для автоматизации

Приложение достаточно изучено. Пора создать объект Application и запустить его или присоединиться к уже запущенному. Это не просто клон стандартного класса subprocess.Popen, а именно вводный объект, который ограничивает все ваши действия границами процесса. Это очень полезно, если запущено несколько экземпляров приложения, а остальные трогать не хочется.

from pywinauto.application import Application
app = Application(backend="uia").start('notepad.exe')

# Опишем окно, которое хотим найти в процессе Notepad.exe
dlg_spec = app. UntitledNotepad
# ждем пока окно реально появится
actionable_dlg = dlg_spec.wait('visible')

Если хочется управлять сразу несколькими приложениями, вам поможет класс Desktop. Например, в калькуляторе на Win10 иерархия элементов размазана аж по нескольким процессам (не только calc.exe). Так что без объекта Desktop не обойтись.

from subprocess import Popen
from pywinauto import Desktop

Popen('calc.exe', shell=True)
dlg = Desktop(backend="uia").Calculator
dlg.wait('visible')

Корневой объект (Application или Desktop) — это единственное место, где нужно указывать бэкенд. Все остальное прозрачно ложится в концепцию «спецификация->враппер», о которой дальше.

Спецификации окон/элементов

Это основная концепция, на которой строится интерфейс pywinauto. Вы можете описать окно/элемент приближенно или более детально, даже если оно еще не существует или уже закрыто. Спецификация окна (объект WindowSpecification) хранит в себе критерии, по которым нужно искать реальное окно или элемент.

Пример детальной спецификации окна:

>>> dlg_spec = app.window(title='Untitled - Notepad')

>>> dlg_spec
<pywinauto.application.WindowSpecification object at 0x0568B790>

>>> dlg_spec.wrapper_object()
<pywinauto.controls.win32_controls.DialogWrapper object at 0x05639B70>

Сам поиск окна происходит по вызову метода .wrapper_object(). Он возвращает некий «враппер» для реального окна/элемента или кидает ElementNotFoundError (иногда ElementAmbiguousError, если найдено несколько элементов, то есть требуется уточнить критерий поиска). Этот «враппер» уже умеет делать какие-то действия с элементом или получать данные из него.

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

dlg_spec.wrapper_object().minimize() # debugging
dlg_spec. minimize() # production

Есть множество критериев поиска для спецификации окна. Вот лишь несколько примеров:

# могут иметь несколько уровней
app.window(title_re='.* - Notepad$').window(class_name='Edit')

# можно комбинировать критерии (как AND) и не ограничиваться одним процессом приложения
dlg = Desktop(backend="uia").Calculator
dlg.window(auto_id='num8Button', control_type='Button')

Список всех возможных критериев есть в доках функции pywinauto.findwindows.find_elements(…).

Магия доступа по атрибуту и по ключу

Python упрощает создание спецификаций окна и распознает атрибуты объекта динамически (внутри переопределен метод __getattribute__). Разумеется, на имя атрибута накладываются такие же ограничения, как и на имя любой переменной (нельзя вставлять пробелы, запятые и прочие спецсимволы). К счастью, pywinauto использует так называемый «best match» алгоритм поиска, который устойчив к опечаткам и небольшим вариациям.

app.UntitledNotepad
# то же самое, что
app.window(best_match='UntitledNotepad')

Если все-таки нужны Unicode строки (например, для русского языка), пробелы и т.п., можно делать доступ по ключу (как будто это обычный словарь):

app['Untitled - Notepad']
# то же самое, что
app.window(best_match='Untitled - Notepad')

Пять правил для магических имен

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

  1. По заголовку (текст, имя): app.Properties.OK.click()
  2. По тексту и по типу элемента: app.Properties.OKButton.click()
  3. По типу и по номеру: app.Properties.Button3.click() (имена Button0 и Button1 привязаны к первому найденному элементу, Button2 — ко второму, и дальше уже по порядку — так исторически сложилось)
  4. По статическому тексту (слева или сверху) и по типу: app. OpenDialog.FileNameEdit.set_text("") (полезно для элементов с динамическим текстом)
  5. По типу и по тексту внутри: app.Properties.TabControlSharing.select("General")

Обычно два-три правила применяются одновременно, редко больше. Чтобы проверить, какие конкретно имена доступны для каждого элемента, можно использовать метод print_control_identifiers(). Он может печатать дерево элементов как на экран, так и в файл. Для каждого элемента печатаются его эталонные магические имена. Также можно скопипастить оттуда более детальные спецификации дочерних элементов. Результат в скрипте будет выглядеть так:

app.Properties.child_window(title="Contains:", auto_id="13087", control_type="Edit")
Само дерево элементов — обычно довольно большая портянка.
>>> app.Properties.print_control_identifiers()

Control Identifiers:

Dialog - 'Windows NT Properties'    (L688, T518, R1065, B1006)
[u'Windows NT PropertiesDialog', u'Dialog', u'Windows NT Properties']
child_window(title="Windows NT Properties", control_type="Window")
   |
   | Image - ''    (L717, T589, R749, B622)
   | [u'', u'0', u'Image1', u'Image0', 'Image', u'1']
   | child_window(auto_id="13057", control_type="Image")
   |
   | Image - ''    (L717, T630, R1035, B632)
   | ['Image2', u'2']
   | child_window(auto_id="13095", control_type="Image")
   |
   | Edit - 'Folder name:'    (L790, T596, R1036, B619)
   | [u'3', 'Edit', u'Edit1', u'Edit0']
   | child_window(title="Folder name:", auto_id="13156", control_type="Edit")
   |
   | Static - 'Type:'    (L717, T643, R780, B658)
   | [u'Type:Static', u'Static', u'Static1', u'Static0', u'Type:']
   | child_window(title="Type:", auto_id="13080", control_type="Text")
   |
   | Edit - 'Type:'    (L790, T643, R1036, B666)
   | [u'4', 'Edit2', u'Type:Edit']
   | child_window(title="Type:", auto_id="13059", control_type="Edit")
   |
   | Static - 'Location:'    (L717, T669, R780, B684)
   | [u'Location:Static', u'Location:', u'Static2']
   | child_window(title="Location:", auto_id="13089", control_type="Text")
   |
   | Edit - 'Location:'    (L790, T669, R1036, B692)
   | ['Edit3', u'Location:Edit', u'5']
   | child_window(title="Location:", auto_id="13065", control_type="Edit")
   |
   | Static - 'Size:'    (L717, T695, R780, B710)
   | [u'Size:Static', u'Size:', u'Static3']
   | child_window(title="Size:", auto_id="13081", control_type="Text")
   |
   | Edit - 'Size:'    (L790, T695, R1036, B718)
   | ['Edit4', u'6', u'Size:Edit']
   | child_window(title="Size:", auto_id="13064", control_type="Edit")
   |
   | Static - 'Size on disk:'    (L717, T721, R780, B736)
   | [u'Size on disk:', u'Size on disk:Static', u'Static4']
   | child_window(title="Size on disk:", auto_id="13107", control_type="Text")
   |
   | Edit - 'Size on disk:'    (L790, T721, R1036, B744)
   | ['Edit5', u'7', u'Size on disk:Edit']
   | child_window(title="Size on disk:", auto_id="13106", control_type="Edit")
   |
   | Static - 'Contains:'    (L717, T747, R780, B762)
   | [u'Contains:1', u'Contains:0', u'Contains:Static', u'Static5', u'Contains:']
   | child_window(title="Contains:", auto_id="13088", control_type="Text")
   |
   | Edit - 'Contains:'    (L790, T747, R1036, B770)
   | [u'8', 'Edit6', u'Contains:Edit']
   | child_window(title="Contains:", auto_id="13087", control_type="Edit")
   |
   | Image - 'Contains:'    (L717, T773, R1035, B775)
   | [u'Contains:Image', 'Image3', u'Contains:2']
   | child_window(title="Contains:", auto_id="13096", control_type="Image")
   |
   | Static - 'Created:'    (L717, T786, R780, B801)
   | [u'Created:', u'Created:Static', u'Static6', u'Created:1', u'Created:0']
   | child_window(title="Created:", auto_id="13092", control_type="Text")
   |
   | Edit - 'Created:'    (L790, T786, R1036, B809)
   | [u'Created:Edit', 'Edit7', u'9']
   | child_window(title="Created:", auto_id="13072", control_type="Edit")
   |
   | Image - 'Created:'    (L717, T812, R1035, B814)
   | [u'Created:Image', 'Image4', u'Created:2']
   | child_window(title="Created:", auto_id="13097", control_type="Image")
   |
   | Static - 'Attributes:'    (L717, T825, R780, B840)
   | [u'Attributes:Static', u'Static7', u'Attributes:']
   | child_window(title="Attributes:", auto_id="13091", control_type="Text")
   |
   | CheckBox - 'Read-only (Only applies to files in folder)'    (L790, T825, R1035, B841)
   | [u'CheckBox0', u'CheckBox1', 'CheckBox', u'Read-only (Only applies to files in folder)CheckBox', u'Read-only (Only applies to files in folder)']
   | child_window(title="Read-only (Only applies to files in folder)", auto_id="13075", control_type="CheckBox")
   |
   | CheckBox - 'Hidden'    (L790, T848, R865, B864)
   | ['CheckBox2', u'HiddenCheckBox', u'Hidden']
   | child_window(title="Hidden", auto_id="13076", control_type="CheckBox")
   |
   | Button - 'Advanced. ..'    (L930, T845, R1035, B868)
   | [u'Advanced...', u'Advanced...Button', 'Button', u'Button1', u'Button0']
   | child_window(title="Advanced...", auto_id="13154", control_type="Button")
   |
   | Button - 'OK'    (L814, T968, R889, B991)
   | ['Button2', u'OK', u'OKButton']
   | child_window(title="OK", auto_id="1", control_type="Button")
   |
   | Button - 'Cancel'    (L895, T968, R970, B991)
   | ['Button3', u'CancelButton', u'Cancel']
   | child_window(title="Cancel", auto_id="2", control_type="Button")
   |
   | Button - 'Apply'    (L976, T968, R1051, B991)
   | ['Button4', u'ApplyButton', u'Apply']
   | child_window(title="Apply", auto_id="12321", control_type="Button")
   |
   | TabControl - ''    (L702, T556, R1051, B962)
   | [u'10', u'TabControlSharing', u'TabControlPrevious Versions', u'TabControlSecurity', u'TabControl', u'TabControlCustomize']
   | child_window(auto_id="12320", control_type="Tab")
   |    |
   |    | TabItem - 'General'    (L704, T558, R753, B576)
   |    | [u'GeneralTabItem', 'TabItem', u'General', u'TabItem0', u'TabItem1']
   |    | child_window(title="General", control_type="TabItem")
   |    |
   |    | TabItem - 'Sharing'    (L753, T558, R801, B576)
   |    | [u'Sharing', u'SharingTabItem', 'TabItem2']
   |    | child_window(title="Sharing", control_type="TabItem")
   |    |
   |    | TabItem - 'Security'    (L801, T558, R851, B576)
   |    | [u'Security', 'TabItem3', u'SecurityTabItem']
   |    | child_window(title="Security", control_type="TabItem")
   |    |
   |    | TabItem - 'Previous Versions'    (L851, T558, R947, B576)
   |    | [u'Previous VersionsTabItem', u'Previous Versions', 'TabItem4']
   |    | child_window(title="Previous Versions", control_type="TabItem")
   |    |
   |    | TabItem - 'Customize'    (L947, T558, R1007, B576)
   |    | [u'CustomizeTabItem', 'TabItem5', u'Customize']
   |    | child_window(title="Customize", control_type="TabItem")
   |
   | TitleBar - 'None'    (L712, T521, R1057, B549)
   | ['TitleBar', u'11']
   |    |
   |    | Menu - 'System'    (L696, T526, R718, B548)
   |    | [u'System0', u'System', u'System1', u'Menu', u'SystemMenu']
   |    | child_window(title="System", auto_id="MenuBar", control_type="MenuBar")
   |    |    |
   |    |    | MenuItem - 'System'    (L696, T526, R718, B548)
   |    |    | [u'System2', u'MenuItem', u'SystemMenuItem']
   |    |    | child_window(title="System", control_type="MenuItem")
   |    |
   |    | Button - 'Close'    (L1024, T519, R1058, B549)
   |    | [u'CloseButton', u'Close', 'Button5']
   |    | child_window(title="Close", control_type="Button")

В некоторых случаях печать всего дерева может тормозить (например, в iTunes на одной вкладке аж три тысячи элементов!), но можно использовать параметр depth (глубина): depth=1 — сам элемент, depth=2 — только непосредственные дети, и так далее. Его же можно указывать в спецификациях при создании child_window.

Примеры

Мы постоянно пополняем список примеров в репозитории. Из свежих стоит отметить автоматизацию сетевого анализатора WireShark (это хороший пример Qt5 приложения; хотя эту задачу можно решать и без GUI, ведь есть scapy.Sniffer из питоновского пакета scapy). Также есть пример автоматизации MS Paint с его Ribbon тулбаром.

Еще один отличный пример, написанный моим студентом: перетаскивание файла из explorer.exe на Chrome страницу для Google Drive (он перекочует в главный репозиторий чуть позже).

И, конечно, пример подписки на события клавиатуры (hot keys) и мыши:
hook_and_listen.py.

Благодарности

Отдельное спасибо — тем, кто постоянно помогает развивать проект. Для меня и Валентина это постоянное хобби. Двое моих студентов из ННГУ недавно защитили дипломы бакалавра по этой теме. Александр внес большой вклад в поддержку MS UI Automation и недавно начал делать автоматический генератор кода по принципу «запись-воспроизведение» на основе текстовых свойств (это самая сложная фича), пока только для «uia» бэкенда. Иван разрабатывает новый бэкенд под Linux на основе AT-SPI (модули mouse и keyboard на основе python-xlib — уже в релизах 0.6.x).

Поскольку я довольно давно читаю спецкурс по автоматизации на Python, часть студентов-магистров выполняют домашние задания, реализуя небольшие фичи или примеры автоматизации. Некоторые ключевые вещи на стадии исследований тоже когда-то раскопали именно студенты. Хотя иногда за качеством кода приходится строго следить. В этом сильно помогают статические анализаторы (QuantifiedCode, Codacy и Landscape) и автоматические тесты в облаке (сервис AppVeyor) с покрытием кода в районе 95%.

Также спасибо всем, кто оставляет отзывы, заводит баги и присылает пулл реквесты!

Дополнительные ресурсы

За вопросами мы следим по тегу на StackOverflow (недавно появился тег в русской версии SO) и по ключевому слову на Тостере. Есть русскоязычный чат в Gitter’е.

Каждый месяц обновляем рейтинг open-source библиотек для GUI тестирования. По количеству звезд на гитхабе быстрее растут только Autohotkey (у них очень большое сообщество и длинная история) и PyAutoGUI (во многом благодаря популярности книг ее автора Al Sweigart: «Automate the Boring Stuff with Python» и других).

Программирование GUI на Python с помощью Tkinter. Tkinter Text

Tkinter — графическая библиотека для Python, которая используется для разработки графического интерфейса на Python (начиная с Python 3.0, Tkinter переименована в tkinter). Tkinter является интерфейсом к tcl/tk и расшифровывается как Tk interface. Эта библиотека кроссплатформенна и может применяться в многих распространённых ОС: Linux, Mac OS X, Windows. Кроме того, Tkinter включена в стандартный дистрибутив Python.

Так как библиотека Tkinter — это достаточно прозрачный интерфейс к tcl/tk, то основной источник информации для неё — man-страницы tcl/tk. Данные страницы есть в любой Unix-системе и доступны онлайн.

Импорт

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

# для python 2. 7 и ниже
import Tkinter

# для python 3.0 и выше
import tkinter

Либо так:

# для python 2.7 и ниже
from Tkinter import *

# для python 3.0 и выше
from tkinter import *

В Tkinter визуальные контроллы называют виджетами (widget — стандартизированный компонент графического интерфейса, с которым пользователь осуществляет взаимодействие).

Text в Tkinter

Text представляет собой виджет, позволяющий пользователю вводить любое количество текста. Text имеет дополнительное свойство wrap, которое отвечает за перенос (чтобы переносить по словам, используют значение WORD).

Пример:

from Tkinter import *
root=Tk()
text1=Text(root,height=7,width=7,font='Arial 14',wrap=WORD)
text1.pack()
root.mainloop()

В нашем случае методы insert, get и delete выполняют добавление, извлечение и удаление текcта. Первый аргумент является местом вставки в виде ‘x.y’, где x является строкой, а y – столбцом.

Пример:

text1.insert(1.0,'Добавим Текст\n\ в начало 1-й строки')
text1.delete('1.0', END)   # Удалим всё
text1.get('1.0', END)      # Извлечем всё

Таким образом, с помощью Text в Tkinter мы можем запрограммировать многострочное текстовое поле. К слову, такой виджет нередко используется при заполнении web-форм. По умолчанию его размер составляет 80 знакомест по горизонтали и 24 по вертикали.

Но данные свойства мы можем поменять, используя опции width и height. Также можно конфигурировать шрифт, цвет и пр.

from tkinter import *
root = Tk()

text = Text(width=25, height=5, bg="darkgreen", fg='white', wrap=WORD)

text.pack()
root.mainloop()

Text и Scrollbar

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

В Tkinter скроллеры производятся с помощью класса Scrollbar. В этом случае объект-скроллер связывается с виджетом, которому он нужен. И речь сейчас идёт не обязательно о многострочном текстовом поле. Нередко полосы прокрутки используются и в списках.

from tkinter import *
root = Tk()

text = Text(width=20, height=7)
text.pack(side=LEFT)

scroll = Scrollbar(command=text.yview)
scroll.pack(side=LEFT, fill=Y)

text.config(yscrollcommand=scroll.set)

root.mainloop()

В примере мы создаём скроллер, к которому через опцию command привязываем прокрутку текстового поля по оси y – text.yview. Далее, в свою очередь, текстовому полю устанавливаем ранее созданный скроллер – scroll.set, используя для этого опцию yscrollcommand.

Методы Text

Главные методы у Text мы уже упоминали – get(), insert(), delete(). Но если в случае с однострочным текстовым полем достаточно указать один индекс элемента при его вставке либо удалении, то, когда речь идёт о многострочном поле, нужно указывать два – как номер строки, так и номер символа в данной строке (иными словами, номер столбца). Также стоит отметить, что нумерация строк здесь начинается с единицы, а нумерация столбцов – с нуля.

from tkinter import *

def insertText():
    s = "Hello World"
    text.insert(1.0, s)

def getText():
    s = text.get(1.0, END)
    label['text'] = s

def deleteText():
    text.delete(1.0, END)

root = Tk()

text = Text(width=25, height=5)
text.pack()

frame = Frame()
frame.pack()

b_insert = Button(frame, text="Вставить", command=insertText)
b_insert.pack(side=LEFT)

b_get = Button(frame, text="Взять", command=getText)
b_get.pack(side=LEFT)

b_delete = Button(frame, text="Удалить", command=deleteText)
b_delete.pack(side=LEFT)

label = Label()
label.pack()

root.mainloop()

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

Теги

Особенность текстового поля библиотеки Tkinter — возможность форматировать текст непосредственно в нём, придавая разным его частям различное оформление. Реализуется это посредством методов tag_add() и tag_config(). Первый указанный метод добавляет тег, но нужно указывать его произвольное имя и отрезок текста, для которого он будет применяться. Что касается второго метода tag_config(), то он настраивает тегу стили оформления.

from tkinter import *
root = Tk()

text = Text(width=50, height=10)
text.pack()
text.insert(1.0, "Hello world!\nline two")

text.tag_add('title', 1.0, '1.end')
text.tag_config('title', font=("Verdana", 24, 'bold'), justify=CENTER)

root.mainloop()

Вставка виджетов в текстовое поле

В Text мы можем вставлять и другие виджеты, используя метод window_creat(). Потребности особой в этом нет, но иногда может пригодиться с объектами типа Canvas. В нижеследующем примере мы вставляем метку в текущую (INSERT) позицию курсора:

from tkinter import *

def smile():
    label = Label(text=":)", bg="yellow")
    text.window_create(INSERT, window=label)

root = Tk()

text = Text(width=50, height=10)
text. pack()

button = Button(text=":)", command=smile)
button.pack()

root.mainloop()

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

Подробнее о Tkinter и программировании GUI на Python читайте в официальной документации или на обучающих сайтах. Также мы рекомендуем пройти углубленный курс Python-разработки от опытных IT-специалистов:

.

Простой способ создания графического интерфейса с помощью Python — Настоящий Python

Создание простого графического пользовательского интерфейса (GUI), работающего на нескольких платформах, может быть сложной задачей. Но так быть не должно. Вы можете использовать Python и пакет PySimpleGUI для создания красивых пользовательских интерфейсов, которые понравятся вам и вашим пользователям! PySimpleGUI — это новая библиотека графического интерфейса пользователя Python, которая в последнее время вызывает большой интерес.

Из этого руководства вы узнаете, как:

  • Установите пакет PySimpleGUI
  • Создание базовых элементов пользовательского интерфейса с помощью PySimpleGUI
  • Создание приложений, таких как средство просмотра изображений PySimpleGUI
  • Интеграция PySimpleGUI с Matplotlib
  • Использование компьютерного зрения в PySimpleGUI
  • Упакуйте приложение PySimpleGUI для Windows

А теперь пора начинать!

Начало работы с PySimpleGUI

PySimpleGUI был запущен в 2018 году, поэтому это относительно новый пакет по сравнению с подобными wxPython или PyQt.

PySimpleGUI имеет четыре порта:

  1. Ткинтер
  2. PyQt
  3. wxPython
  4. Реми

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

PySimpleGUI является оберткой для Tkinter, который поставляется с Python. PySimpleGUI обернул большую часть PySide2, но только небольшую часть wxPython. Когда вы устанавливаете PySimpleGUI, по умолчанию вы получаете вариант Tkinter .Дополнительные сведения о Tkinter см. В статье Программирование графического интерфейса Python с помощью Tkinter.

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

Установка PySimpleGUI

Установить PySimpleGUI легко, если вы используете pip. В этом руководстве вы узнаете, как установить обычный порт PySimpleGUI, который является вариантом Tkinter.

Вот как это сделать:

  $ python -m pip install pysimplegui
  

Это установит PySimpleGUI на любой установленный Python в вашей системе. Вы также можете установить PySimpleGUI в виртуальную среду Python. Если вы не знакомы с виртуальными средами Python, вам следует прочитать Python Virtual Environments: A Primer.

Если вы предпочитаете попробовать вариант PyQt, то вместо этого вы можете использовать pip install PySimpleGUIQt . Теперь, когда у вас установлен PySimpleGUI, пришло время узнать, как его использовать!

Создание базовых элементов пользовательского интерфейса в PySimpleGUI

Если вы когда-либо использовали инструментарий GUI раньше, то, возможно, слышали термин виджеты .Виджет — это общий термин, используемый для описания элементов, составляющих пользовательский интерфейс (UI), таких как кнопки, метки, окна и т. Д. В PySimpleGUI виджеты обозначаются как , элементы , которые иногда можно увидеть в другом месте с заглавной буквы как Elements .

Одним из основных строительных блоков PySimpleGUI является окно Window () . Чтобы создать Окно () , вы можете сделать следующее:

  # hello_world.py

импортировать PySimpleGUI как sg

sg.Window (title = "Hello World", layout = [[]], margins = (100, 50)). Read ()
  

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

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

Когда вы запустите этот код, вы должны увидеть что-то вроде этого:

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

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

Создайте новый файл с именем hello_psg.py и добавьте этот код:

  # hello_psg.ру

импортировать PySimpleGUI как sg

layout = [[sg.Text ("Привет от PySimpleGUI")], [sg.Button ("OK")]]

# Создаем окно
window = sg.Window ("Демо", макет)

# Создать цикл событий
в то время как True:
    событие, значения = window.read ()
    # Завершить программу, если пользователь закрывает окно или
    # нажимает кнопку ОК
    если событие == "ОК" или событие == sg.WIN_CLOSED:
        перемена

window.close ()
  

Большинство наборов инструментов графического интерфейса пользователя позволяют размещать элементы, используя абсолютное позиционирование или позволяя графическому интерфейсу размещать их динамически .Например, wxPython использует Sizers для динамической компоновки элементов. Если вы хотите узнать больше о wxPython, ознакомьтесь с разделом «Как создать приложение Python с графическим интерфейсом пользователя с помощью wxPython».

PySimpleGUI использует вложенные списки Python для размещения своих элементов. В этом случае вы добавляете элемент Text () и элемент Button () . Затем вы создаете окно и передаете свой собственный макет .

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

Когда вы используете PySimpleGUI, вы создаете цикл событий, создавая бесконечный цикл и , который считывает события из объекта окна . Если пользователь нажимает кнопку OK, или кнопку «Выход», вы хотите, чтобы программа завершилась.Для этого нужно вывести из цикла, а закрыть () окно .

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

Теперь вы готовы создать реальное приложение!

Создание простых приложений

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

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

Создание средства просмотра изображений PySimpleGUI

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

Чтобы упростить задачу, вы будете использовать встроенный в PySimpleGUI элемент Image () для просмотра изображений. К сожалению, элемент Image () может отображать только форматы PNG и GIF в обычной версии PySimpleGUI.

Если вы хотите иметь возможность открывать другие типы файлов изображений, вы можете загрузить Pillow, который поддерживает форматы TIFF, JPG и BMP. Просмотрите демонстрационную папку PySimpleGUI на GitHub, чтобы увидеть, как это сделать.

С другой стороны, если вы установите порт PySimpleGUIQt, то вы обнаружите, что Qt из коробки поддерживает больше форматов изображений, чем Tkinter.

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

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

Вы можете создать файл с именем img_viewer.py в любом редакторе Python. Затем добавьте следующий код:

  1 # img_viewer.py
 2
 3импортируйте PySimpleGUI как sg
 4import os.path
 5
 6 # Сначала макет окна в 2 столбца
 7
 8file_list_column = [
 9 [
10 сг.Текст («Папка с изображениями»),
11 sg.In (size = (25, 1), enable_events = True, key = "- FOLDER-"),
12 sg.FolderBrowse (),
13],
14 [
15 sg.Listbox (
16 значений = [], enable_events = True, size = (40, 20), key = "- СПИСОК ФАЙЛОВ-"
17)
18],
19]
20
21 # Пока будет отображаться только имя выбранного файла
22image_viewer_column = [
23 [sg.Text ("Выберите изображение из списка слева:")],
24 [sg.Text (size = (40, 1), key = "- TOUT-")],
25 [sg.Image (key = "- IMAGE-")],
26]
27
28 # ----- Полный макет -----
29layout = [
30 [
31 sg.Столбец (file_list_column),
32 sg.VSeperator (),
33 sg.Column (image_viewer_column),
34]
35]
36
37window = sg.Window ("Средство просмотра изображений", макет)
38
39 # Запуск цикла событий
40 пока Верно:
41 событие, values ​​= window. read ()
42, если событие == "Выход" или событие == sg.WIN_CLOSED:
43 перерыв
44 # Имя папки было заполнено, составьте список файлов в папке
45, если event == "-FOLDER-":
46 папка = значения ["- FOLDER-"]
47 попыток:
48 # Получить список файлов в папке
49 список_файлов = os.listdir (папка)
50 кроме:
51 file_list = []
52
53 fnames = [
54 ж
55 для f в file_list
56, если os.path.isfile (os.path.join (папка, f))
57 и f.lower () .ndswith ((". Png", ".gif"))
58]
59 окно ["- СПИСОК ФАЙЛОВ -"]. Update (fnames)
60 elif event == "-FILE LIST-": ​​# Файл был выбран из списка
61 попытка:
62 filename = os.path.join (
63 значения ["- ПАПКА-"], значения ["- СПИСОК ФАЙЛОВ -"] [0]
64)
65 окно ["- TOUT-"].обновление (имя файла)
66 окно ["- ИЗОБРАЖЕНИЕ -"]. Update (filename = filename)
67
68, кроме:
69 чел.
70
71window.close ()
  

Уф! Это довольно много строк кода! Давайте рассмотрим это по частям.

Вот несколько первых строк:

  1 # img_viewer.py
 2
 3импортируйте PySimpleGUI как sg
 4import os. path
 5
 6 # Сначала макет окна в 2 столбца
 7
 8file_list_column = [
 9 [
10 sg.Text («Папка изображений»),
11 sg.In (size = (25, 1), enable_events = True, key = "- FOLDER-"),
12 сг.FolderBrowse (),
13],
14 [
15 sg.Listbox (
16 значений = [], enable_events = True, size = (40, 20), key = "- СПИСОК ФАЙЛОВ-"
17)
18],
19]
  

Здесь, в строках 3 и 4 , вы импортируете PySimpleGUI и модуль os Python. Затем в строках с 8 по 19 вы создаете вложенный список элементов, представляющих вертикальный столбец пользовательского интерфейса. Это создаст кнопку «Обзор», которую вы будете использовать, чтобы найти папку с изображениями.

Ключ , параметр важен. Это то, что вы используете для идентификации определенного элемента в вашем графическом интерфейсе. Для элемента управления вводом текста In () вы присваиваете ему идентификатор "-FOLDER-" . Вы будете использовать это позже, чтобы получить доступ к содержимому элемента. Вы можете включить или выключить события для каждого элемента с помощью параметра enable_events .

Элемент Listbox () отобразит список путей к изображениям, которые вы затем можете выбрать для отображения.Вы можете предварительно заполнить Listbox () значениями, передав список строк.

Когда вы впервые загружаете свой пользовательский интерфейс, вы хотите, чтобы Listbox () был пустым, поэтому вы передаете ему пустой список. Вы включаете события для этого элемента, устанавливаете его размер и присваиваете ему уникальный идентификатор, как вы сделали с элементом input.

Теперь вы можете посмотреть на правую колонку элементов:

  21 # Пока будет отображаться только имя выбранного файла
22image_viewer_column = [
23 [sg.Текст ("Выберите изображение из списка слева:")],
24 [sg.Text (size = (40, 1), key = "- TOUT-")],
25 [sg.Image (key = "- IMAGE-")],
26]
  

Список списков в строках с 22 по 26 создает три элемента. Первый элемент сообщает пользователю, что он должен выбрать изображение для отображения. Второй элемент отображает имя выбранного файла. Третий отображает изображение () .

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

Следующий фрагмент кода определяет ваш макет:

  28 # ----- Полный макет -----
29layout = [
30 [
31 sg.Column (столбец_файлов),
32 sg.VSeperator (),
33 sg.Column (image_viewer_column),
34]
35]
  

Последний список, в строках с 29 по 35 , содержит код, который управляет расположением элементов на экране. Этот код содержит два элемента Column () с VSeperator () между ними. VSeperator () — это псевдоним для VerticalSeparator () . Вы можете узнать больше о том, как работают Column () и VSeperator () , прочитав соответствующие страницы документации.

Чтобы добавить макет в окно , вы можете сделать это:

  37window = sg.Window («Средство просмотра изображений», макет)
  

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

  39 при этом True:
40 событие, значения = окно.читать()
41, если событие == "Выход" или событие == sg.WIN_CLOSED:
42 перерыв
  

Цикл событий содержит логику вашей программы. Здесь вы извлекаете события и значения из окна . Событие будет строкой ключа любого элемента, с которым взаимодействует пользователь. Переменная values ​​ содержит словарь Python, который сопоставляет ключ элемента со значением. Например, если пользователь выбирает папку, то «-FOLDER-» будет отображаться на путь к папке.

Условные операторы используются для управления происходящим. Если событие равно «Выход», или пользователь закрывает окно , то вы выходите из цикла.

Теперь вы можете взглянуть на первую часть следующего условного оператора в цикле:

  44 # Имя папки заполнено, составить список файлов в папке
45if event == "-FOLDER-":
46 папка = значения ["- FOLDER-"]
47 попыток:
48 # Получить список файлов в папке
49 список_файлов = os.listdir (папка)
50 кроме:
51 file_list = []
52
53 fnames = [
54 ж
55 для f в file_list
56, если os.path.isfile (os.path.join (папка, f))
57 и f.lower () .ndswith ((". Png", ".gif"))
58]
59 окно ["- СПИСОК ФАЙЛОВ -"]. Update (fnames)
  

На этот раз вы сравните событие с ключом «-FOLDER-» , который ссылается на элемент In () , который вы создали ранее. Если событие существует, значит, вы знаете, что пользователь выбрал папку, и вы используете os.listdir () , чтобы получить список файлов. Затем вы фильтруете этот список до файлов с расширением ".png" или ".gif" .

Примечание: Как упоминалось ранее, вы можете избежать сужения типов файлов изображений, используя вместо этого Pillow или PySimpleGUIQt.

Теперь вы можете взглянуть на следующую часть условного оператора:

  60elif event == "-FILE LIST-": ​​# Файл был выбран из списка
61 попытка:
62 имя_файла = os.path.join (
63 значения ["- ПАПКА-"], значения ["- СПИСОК ФАЙЛОВ -"] [0]
64)
65 окно ["- TOUT -"]. Update (имя файла)
66 окно ["- ИЗОБРАЖЕНИЕ -"]. Update (filename = filename)
67, кроме:
68 чел.
  

Если событие равно "-FILE LIST-" , то вы знаете, что пользователь выбрал файл в списке Listbox () , и вы хотите обновить элемент Image () , а также Элемент Text () , который показывает выбранное имя файла справа.

Последний бит кода - это то, как вы завершаете программу:

Когда пользователь нажимает кнопку «Выход», приложение должно закрыться. Для этого вы можете использовать window.close () .

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

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

Вы можете использовать кнопку «Обзор», чтобы найти на вашем компьютере папку с изображениями, чтобы вы могли опробовать этот код.Или вы можете скопировать и вставить путь к файлу в элемент Text () .

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

Интеграция Matplotlib с PySimpleGUI

Создание графиков - отличный способ поделиться информацией с коллегами. Один из самых популярных пакетов для построения графиков для Python - Matplotlib. Matplotlib может создавать самые разные графики. Если вы хотите узнать об этом больше, ознакомьтесь с Python Plotting With Matplotlib (Guide).

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

Если у вас не установлен Matplotlib, вы можете сделать это с помощью pip :

  $ python -m pip install matplotlib
  

В этом примере вы используете одну из демонстраций PySimpleGUI. Matplotlib использует NumPy, поэтому вы также захотите установить его:

  $ python -m pip install numpy
  

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

Демо-код немного длинный, поэтому вы добавляете код частями, начиная с этого:

  импортировать numpy как np
из matplotlib.backends.backend_tkagg импортировать FigureCanvasTkAgg
импортировать PySimpleGUI как sg
импортировать matplotlib

fig = matplotlib. figure.Figure (figsize = (5, 4), dpi = 100)
t = np.arange (0, 3, .01)
fig.add_subplot (111) .plot (t, 2 * np.sin (2 * np.pi * t))
  

Это импорт, который вам понадобится для работы вашего кода. Этот код также устанавливает Matplotlib Figure () и добавляет график с использованием add_subplot () .Для получения дополнительной информации вы можете обратиться к документации. Порт PySimpleGUIQt в настоящее время не работает таким же образом, но над этим мы работаем для будущего выпуска.

И в PySimpleGUI, и в Tkinter для рисования используется элемент Canvas () . Подробнее об этом элементе можно прочитать в документации.

Теперь вы можете создать вспомогательную функцию для рисования фигуры в PySimpleGUI Canvas () . Вспомогательная функция - это повторяющийся код, который не нужно писать несколько раз.Взгляните:

  matplotlib.use («TkAgg»)

def draw_figure (холст, рисунок):
    figure_canvas_agg = FigureCanvasTkAgg (рисунок, холст)
    figure_canvas_agg. draw ()
    figure_canvas_agg.get_tk_widget (). pack (side = "top", fill = "both", expand = 1)
    вернуть figure_canvas_agg
  

Вы будете использовать figure_canvas_agg.draw () , чтобы нарисовать графики для элемента PySimpleGUI Canvas () .

Чтобы использовать PySimpleGUI Canvas () , вам необходимо передать его в FigureCanvasTkAgg () вместе с объектом Figure Matplotlib . FigureCanvasTkAgg () происходит из Matplotlib и используется Tkinter для встраивания графиков в PySimpleGUI. Это работало бы по-другому, если бы вы использовали PySimpleGUIQt.

Последний шаг - написать пользовательский интерфейс с PySimpleGUI:

  # Определить макет окна
layout = [
    [sg.Text («Тест сюжета»)],
    [sg.Canvas (key = "- CANVAS-")],
    [sg.Button ("Хорошо")],
]

# Создать форму и показать ее без сюжета
окно = sg.Window (
    "Единый граф Matplotlib",
    макет,
    расположение = (0, 0),
    finalize = True,
    element_justification = "центр",
    font = "Helvetica 18",
)

# Добавляем сюжет в окно
draw_figure (окно ["- CANVAS-"]. TKCanvas, рис)

событие, значения = window.read ()

window.close ()
  

Для создания пользовательского интерфейса все, что вам нужно, это элемент Text () , элемент Canvas () и элемент Button () . Затем вы добавляете все это в Window () и вызываете вспомогательную функцию draw_figure () для рисования графика.

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

Вот как будет выглядеть график:

В PySimpleGUI есть и другие демонстрации Matplotlib, которые вам следует проверить.

Теперь вы можете узнать, как использовать OpenCV с PySimpleGUI.

Интеграция OpenCV с PySimpleGUI

Компьютерное зрение сейчас является горячей темой. Python позволяет вам войти в компьютерное зрение с помощью пакета opencv-python, который представляет собой оболочку для популярного приложения OpenCV . Если вы хотите узнать больше о компьютерном зрении, ознакомьтесь с разделом «Распознавание лиц с помощью Python» в разделе «До 25 строк кода».

PySimpleGUI имеет прямую интеграцию с библиотекой OpenCV.Однако сначала вам нужно установить OpenCV, используя pip :

  $ python -m pip установить opencv-python
  

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

Вы увидите еще одну демонстрацию PySimpleGUI, которая использует OpenCV и веб-камеру вашего компьютера. Это приложение позволит вам применять некоторые общие фильтры к вашему видео в реальном времени.

Код этого примера длинный, но беспокоиться не о чем. Позже это будет объяснено более мелкими фрагментами.Создайте файл с именем psg_opencv.py и добавьте следующий код:

  1импортировать PySimpleGUI как SG
  2импорт cv2
  3импорт numpy как np
  4
  5def main ():
  6 sg.theme ("Светло-зеленый")
  7
  8 # Определить макет окна
  9 layout = [
 10 [sg. Text ("OpenCV Demo", size = (60, 1), justification = "center")],
 11 [sg.Image (filename = "", key = "- IMAGE-")],
 12 [sg.Radio ("Нет", "Радио", True, size = (10, 1))],
 13 [
 14 шт.Radio ("порог", "Radio", size = (10, 1), key = "- THRESH-"),
 15 sg. Слайдер (
 16 (0, 255),
 17 128,
 18 1,
 19 ориентация = "h",
 20 размер = (40, 15),
 21 клавиша = "- ПОРОГОВЫЙ СЛАЙДЕР-",
 22),
 23],
 24 [
 25 sg.Radio ("canny", "Radio", size = (10, 1), key = "- CANNY-"),
 26 sg. Слайдер (
 27 (0, 255),
 28 128,
 29 1,
 30 ориентация = "ч",
 31 размер = (20, 15),
 32 key = "- CANNY SLIDER A-",
 33),
 34 sg.Слайдер (
 35 (0, 255),
 36 128,
 37 1,
 38 ориентация = "h",
 39 размер = (20, 15),
 40 key = "- CANNY SLIDER B-",
 41),
 42],
 43 [
 44 sg.Radio ("размытие", "Радио", size = (10, 1), key = "- BLUR-"),
 45 sg. Слайдер (
 46 (1, 11),
 47 1,
 48 1,
 49 ориентация = "h",
 50 размер = (40, 15),
 51 key = "- BLUR SLIDER-",
 52),
 53],
 54 [
 55 сг.Radio ("оттенок", "Радио", size = (10, 1), key = "- HUE-"),
 56 sg.  Слайдер (
 57 (0, 225),
 58 0,
 59 1,
 60 ориентация = "ч",
 61 размер = (40, 15),
 62 key = "- СЛАЙДЕР ОТТЕНОК-",
 63),
 64],
 65 [
 66 sg.Radio ("улучшить", "Радио", size = (10, 1), key = "- ENHANCE-"),
 67 sg. Слайдер (
 68 (1, 255),
 69 128,
 70 1,
 71 ориентация = "h",
 72 размер = (40, 15),
 73 key = "- УЛУЧШЕНИЕ СЛАЙДЕРА-",
 74),
 75],
 76 [sg.Кнопка ("Выход", size = (10, 1))],
 77]
 78
 79 # Создайте окно и покажите его без сюжета
 80 window = sg.Window ("Интеграция OpenCV", layout, location = (800, 400))
 81 год
 82 cap = cv2.VideoCapture (0)
 83
 84, пока True:
 85 событие, значения = window.read (тайм-аут = 20)
 86, если событие == "Выход" или событие == sg.WIN_CLOSED:
 87 перерыв
 88
 89 рет, frame = cap.read ()
 90
 91, если значения ["- THRESH-"]:
 92 frame = cv2.cvtColor (frame, cv2.COLOR_BGR2LAB) [:,:, 0]
 93 кадр = cv2.порог(
 94 кадр, значения ["- THRESH SLIDER-"], 255, cv2.THRESH_BINARY
 95) [1]
 96 значений elif ["- CANNY-"]:
 97 кадр = cv2.Canny (
 Кадр 98, значения ["- CANNY SLIDER A-"], значения ["- CANNY SLIDER B-"]
 99)
100 значений elif ["- BLUR-"]:
101 кадр = cv2. GaussianBlur (кадр, (21, 21), значения ["- СЛАЙДЕР РАЗМЫШЛЕНИЯ-"])
102 значения elif ["- HUE-"]:
103 кадр = cv2.cvtColor (кадр, cv2.COLOR_BGR2HSV)
104 frame [:,:, 0] + = int (values ​​["- HUE SLIDER-"])
105 кадров = cv2.cvtColor (кадр, cv2.COLOR_HSV2BGR)
106 значений elif ["- ENHANCE-"]:
107 enh_val = values ​​["- СЛАЙДЕР УЛУЧШЕНИЯ-"] / 40
108 clahe = cv2.createCLAHE (clipLimit = enh_val, tileGridSize = (8, 8))
109 lab = cv2.cvtColor (рамка, cv2.COLOR_BGR2LAB)
110 lab [:,:, 0] = clahe.apply (lab [:,:, 0])
111 frame = cv2.cvtColor (lab, cv2.COLOR_LAB2BGR)
112
113 imgbytes = cv2.imencode (". Png", frame) [1] .tobytes ()
114 окно ["- ИЗОБРАЖЕНИЕ -"]. Update (data = imgbytes)
115
116 окно.Закрыть()
117
118 основной ()
  

Это длинный фрагмент кода! Давайте рассмотрим пример по частям:

  1импортировать PySimpleGUI как SG
 2импорт cv2
 3импорт numpy как np
 4
 5def main ():
 6 sg.theme ("Светло-зеленый")
 7
 8 # Определить макет окна
 9 layout = [
10 [sg.Text ("OpenCV Demo", size = (60, 1), justification = "center")],
11 [sg. Image (filename = "", key = "- IMAGE-")],
12 [sg.Radio ("Нет", "Радио", True, size = (10, 1))],
13 [
14 шт.Radio ("порог", "Radio", size = (10, 1), key = "- THRESH-"),
15 sg. Слайдер (
16 (0, 255),
17 128,
18 1,
19 ориентация = "h",
20 размер = (40, 15),
21 клавиша = "- ПОРОГОВЫЙ СЛАЙДЕР-",
22),
23],
  

Строки с 1 по 3 - это импорт для необходимых вам библиотек Python. Затем вы устанавливаете тему на строке 6 .

Следующим шагом, начиная со строки , является создание макета для всех элементов графического интерфейса.Первый набор элементов включает в себя элемент Text (), , элемент Image (), и элемент Radio () . Вы устанавливаете ключ идентификатора для элемента Image на "-IMAGE-" . Вы также вкладываете элемент Radio () и элемент Slider () и устанавливаете их ключи идентификатора на "-THRESH-" и "-THRESH SLIDER-" соответственно.

Теперь вы добавите еще несколько элементов в макет :

  24 [
25 сг.Radio ("canny", "Radio", size = (10, 1), key = "- CANNY-"),
26 sg. Слайдер (
27 (0, 255),
28 128,
29 1,
30 ориентация = "ч",
31 размер = (20, 15),
32 key = "- CANNY SLIDER A-",
33),
34 sg. Слайдер (
35 (0, 255),
36 128,
37 1,
38 ориентация = "h",
39 размер = (20, 15),
40 key = "- CANNY SLIDER B-",
41),
42],
  

В строках с 24 по 42 вы добавляете еще один элемент Radio () и два элемента Slider () для управления обнаружением четких краев с помощью пользовательского интерфейса.Вы также правильно установите идентификаторы.

Теперь вы добавите способ размытия изображений:

  43 [
44 sg.Radio ("размытие", "Радио", size = (10, 1), key = "- BLUR-"),
45 sg. Слайдер (
46 (1, 11),
47 1,
48 1,
49 ориентация = "h",
50 размер = (40, 15),
51 key = "- BLUR SLIDER-",
52),
53],
  

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

Вам нужно добавить еще два набора элементов управления. Далее вы добавите элементы управления оттенком:

  54 [
55 sg.Radio ("оттенок", "Радио", size = (10, 1), key = "- HUE-"),
56 sg. Слайдер (
57 (0, 225),
58 0,
59 1,
60 ориентация = "ч",
61 размер = (40, 15),
62 key = "- СЛАЙДЕР ОТТЕНОК-",
63),
64],
  

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

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

  65 [
66 sg.Radio ("улучшить", "Радио", size = (10, 1), key = "- ENHANCE-"),
67 sg. Слайдер (
68 (1, 255),
69 128,
70 1,
71 ориентация = "h",
72 размер = (40, 15),
73 key = "- УЛУЧШЕНИЕ СЛАЙДЕРА-",
74),
75],
76 [sg.Кнопка ("Выход", size = (10, 1))],
77]
78
79 # Создать окно и показать его без сюжета
80window = sg. Window ("Интеграция OpenCV", макет, расположение = (800, 400))
81 год
82cap = cv2.VideoCapture (0)
  

Эти последние несколько элементов позволят вам повысить контрастность видеопотока с помощью алгоритма адаптивного выравнивания гистограммы с ограничением контраста.

На этом макет завершен. . Затем вы передаете свой макет в окно () , чтобы вы могли видеть свой пользовательский интерфейс на экране.

Наконец, вы используете cv2.VideoCapture (0) для доступа к веб-камере на вашем компьютере. Вы можете увидеть всплывающее окно с запросом разрешения на использование камеры. Если вы это сделаете, вам нужно будет предоставить разрешение, иначе этот код не будет работать.

Теперь посмотрим на остальную часть кода:

.
  84 пока True:
 85 событие, значения = window.read (тайм-аут = 20)
 86, если событие == "Выход" или событие == sg.WIN_CLOSED:
 87 перерыв
 88
 89 рет, рамка = кап.читать()
 90
 91, если значения ["- THRESH-"]:
 92 frame = cv2. cvtColor (frame, cv2.COLOR_BGR2LAB) [:,:, 0]
 93 кадр = cv2.threshold (
 94 кадр, значения ["- THRESH SLIDER-"], 255, cv2.THRESH_BINARY
 95) [1]
 96 значений elif ["- CANNY-"]:
 97 кадр = cv2.Canny (
 Кадр 98, значения ["- CANNY SLIDER A-"], значения ["- CANNY SLIDER B-"]
 99)
100 значений elif ["- BLUR-"]:
101 кадр = cv2.GaussianBlur (кадр, (21, 21), значения ["- СЛАЙДЕР РАЗМЫШЛЕНИЯ-"])
102 значения elif ["- HUE-"]:
103 кадр = cv2.cvtColor (кадр, cv2.COLOR_BGR2HSV)
104 frame [:,:, 0] + = int (values ​​["- HUE SLIDER-"])
105 кадр = cv2.cvtColor (кадр, cv2.COLOR_HSV2BGR)
106 значений elif ["- ENHANCE-"]:
107 enh_val = values ​​["- СЛАЙДЕР УЛУЧШЕНИЯ-"] / 40
108 clahe = cv2.createCLAHE (clipLimit = enh_val, tileGridSize = (8, 8))
109 lab = cv2.cvtColor (рамка, cv2.COLOR_BGR2LAB)
110 lab [:,:, 0] = clahe.apply (lab [:,:, 0])
111 frame = cv2.cvtColor (lab, cv2.COLOR_LAB2BGR)
112
113 imgbytes = cv2.imencode (". png", frame) [1] .tobytes ()
114 окно ["- ИЗОБРАЖЕНИЕ -"]. Update (data = imgbytes)
115
116 window. close ()
117
118 основной ()
  

Это цикл событий для вашего интерфейса PySimpleGUI. Когда вы меняете ползунок в своем пользовательском интерфейсе, PySimpleGUI захватывает событие и значения и использует их, чтобы определить, какую функцию OpenCV применить к потоку веб-камеры.

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

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

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

Упаковка вашего приложения PySimpleGUI для Windows

Существует множество различных пакетов Python, которые можно использовать для преобразования кода Python в исполняемый файл для Windows. Один из самых популярных - PyInstaller.

Вы можете установить PyInstaller, используя pip :

  $ python -m pip установить pyinstaller
  

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

Вы будете использовать PyInstaller для преобразования созданного вами ранее приложения просмотра изображений в исполняемый файл.

  $ pyinstaller img_viewer.py
  

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

  177 ИНФОРМАЦИЯ: PyInstaller: 3.6
178 ИНФОРМАЦИЯ: Python: 3.8.2
179 ИНФОРМАЦИЯ: Платформа: Windows-10-10.0.10586-SP0
186 ИНФОРМАЦИЯ: написал C: \ Users \ mike \ OneDrive \ Documents \ image_viewer_psg.spec
192 ИНФОРМАЦИЯ: UPX недоступен.
221 ИНФОРМАЦИЯ: Расширение PYTHONPATH путями
---- вывод обрезан ----
13476 ИНФОРМАЦИЯ: Сборка COLLECT, поскольку COLLECT-00.toc не существует
13479 ИНФОРМАЦИЯ: Здание COLLECT COLLECT-00. toc
25851 ИНФОРМАЦИЯ: Сборка COLLECT COLLECT-00.toc завершена успешно.
  

Этот вывод сокращен, поскольку PyInstaller довольно подробный.Когда это будет сделано, у вас будет подпапка с именем dist в той же папке, которая содержит img_viewer.py . Вы можете зайти в папку dist , найти img_viewer.exe и попробовать запустить его.

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

Если вы предпочитаете иметь только один исполняемый файл, вы можете повторно запустить команду, используя флаг --onefile :

  $ pyinstaller --onefile img_viewer.ру
  

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

Примечание. Защитник Windows может пометить ваш исполняемый файл как имеющий вирус, если вы используете флаг --onefile . Если это так, то вам нужно будет добавить исключение в Windows Security, чтобы запустить его. Это связано с тем, что исполняемые файлы Windows должны быть подписаны в Windows 10.

Когда вы запустите исполняемый файл, вы увидите окно консоли в дополнение к вашему пользовательскому интерфейсу.Чтобы удалить консоль, вы можете использовать флаг --noconsole или --windowed при запуске PyInstaller.

Заключение

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

В этом руководстве вы узнали, как:

  • Установите пакет PySimpleGUI
  • Создание базовых элементов пользовательского интерфейса с PySimpleGUI
  • Создайте несколько приложений , например средство просмотра изображений , с PySimpleGUI
  • Интеграция PySimpleGUI с Matplotlib
  • Использование компьютерного зрения в PySimpleGUI
  • Упакуйте приложение PySimpleGUI для Windows

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

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

Если вы хотите узнать больше о PySimpleGUI, вы можете воспользоваться любым из следующих ресурсов:

PySimpleGUI · PyPI

Графический интерфейс Python для людей

Преобразует фреймворки графического интерфейса пользователя tkinter, Qt, WxPython и Remi (на основе браузера) в более простой интерфейс.Определение окна упрощено за счет использования основных типов данных Python, понятных новичкам (списки и словари). Дальнейшее упрощение происходит за счет изменения обработки событий с модели, основанной на обратном вызове, на модель передачи сообщений.

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

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

Японская версия этого ридми.


PyPI устанавливает

tkinter tkinter 2.7
Qt WxPython Сеть (Реми)

GitHub

Самая последняя версия PyPI

tkinter Qt Интернет WxPython


PySimpleGUI - это пакет Python, который позволяет программистам Python всех уровней создавать графические интерфейсы. Вы указываете свое окно графического интерфейса пользователя, используя «макет», который содержит виджеты (в PySimpleGUI они называются «элементами»). Ваш макет используется для создания окна с использованием одной из 4 поддерживаемых платформ для отображения и взаимодействия с вашим окном. Поддерживаемые фреймворки включают tkinter, Qt, WxPython или Remi. Термин «обертка» иногда используется для такого рода пакетов.

Ваш код PySimpleGUI проще и короче, чем писать напрямую с использованием базовой инфраструктуры, потому что PySimpleGUI реализует большую часть «шаблонного кода» за вас.Кроме того, интерфейсы упрощены: для получения желаемого результата требуется как можно меньше кода. В зависимости от используемой программы и фреймворка программе PySimpleGUI может потребоваться от 1/2 до 1/10 объема кода для создания идентичного окна с использованием одной из фреймворков напрямую.

Хотя цель состоит в том, чтобы инкапсулировать / скрыть определенные объекты и код, используемые фреймворком GUI, поверх которого вы работаете, при необходимости вы можете напрямую получить доступ к зависимым виджетам и окнам фреймворка. Если параметр или функция еще не предоставлены или недоступны с помощью API-интерфейсов PySimpleGUI, вы не изолированы от платформы.Вы можете расширить возможности, не изменяя непосредственно сам пакет PySimpleGUI.

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

Python привлек большое количество людей в сообщество программистов. Количество программ и диапазон затрагиваемых областей поражают воображение. Но чаще всего эти технологии и технологии недоступны для всех, кроме горстки людей. Большинство программ Python основаны на «командной строке». Это не проблема для программистов, поскольку все мы привыкли взаимодействовать с компьютерами через текстовый интерфейс.Хотя у программистов нет проблем с интерфейсами командной строки, у большинства «нормальных людей» есть проблемы. Это создает цифровой разрыв, «разрыв графического интерфейса».

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


Привет! Я Майк. Вы найдете меня прямо здесь, на PySimpleGUI GitHub, где я решаю проблемы и постоянно продвигаю PySimpleGUI.Я посвятил свои дни, ночи и выходные проекту и пользователям PySimpleGUI. В конечном итоге наши успехи разделяют. Я успешен, когда ты успешен.

Я относительный новичок в Python, но пишу программное обеспечение с 70-х годов. Большую часть своей карьеры я посвятил созданию продуктов в Кремниевой долине. Я привношу в PySimpleGUI тот же профессионализм и преданность делу, что и при разработке корпоративных продуктов. Теперь вы мои клиенты.

Цели проекта: goal_net:

Две из наиболее важных целей проекта PySimpleGUI:

Fun как цель в серьезном проекте звучит странно, но это серьезная цель. Я считаю, что писать эти программы с графическим интерфейсом очень весело. Одна из причин заключается в том, как мало времени нужно для написания полного решения. Если нам не нравится процесс, тогда кто-то сдастся.

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

Ваш успех - это общая цель. PySimpleGUI был создан для разработчиков.Вы мои взгляды. Было неожиданной наградой увидеть результаты совместных усилий пользователей и PySimpleGUI. Используйте документацию и другие материалы для создания своего приложения. Если у вас возникнут проблемы, помощь можно получить, открыв вопрос на сайте PySimpleGUI GitHub. Взгляните на раздел поддержки ниже.


www.PySimpleGUI.org легко запомнить, и именно там находится документация. Вверху вы найдете вкладки, которые представляют несколько разных документов.Документация находится в разделе «Прочитать документацию», поэтому для каждого документа есть оглавление, и по ним легко искать.

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

Пример 1 - Окно One-Shot

Этот тип программы называется «одноразовым» окном, потому что окно отображается один раз, значения собираются, а затем оно закрывается.Он не остается открытым долгое время, как в текстовом редакторе.

Анатомия простой программы PySimpleGUI

В программе PySimpleGUI 5 разделов

 импортирует PySimpleGUI как sg # Часть 1 - Импорт

# Определить содержимое окна
layout = [[sg.Text ("Как вас зовут?")], # Часть 2 - Макет
            [sg. Input ()],
            [sg.Button ('Хорошо')]]

# Создаем окно
window = sg.Window ('Заголовок окна', макет) # Часть 3 - Определение окна

# Отображение и взаимодействие с окном
событие, значения = окно.read () # Часть 4 - Цикл событий или вызов Window.read

# Сделайте что-нибудь с собранной информацией
print ('Hello', values ​​[0], "! Спасибо, что попробовали PySimpleGUI")

# В конце удалите с экрана
window.close () # Часть 5 - Закройте окно
 

Код создает это окно


Пример 2 - Интерактивное окно

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

 импортировать PySimpleGUI как sg

# Определить содержимое окна
layout = [[sg. Text ("Как вас зовут?")],
          [sg.Input (key = '- INPUT-')],
          [sg.Text (size = (40,1), key = '- OUTPUT-')],
          [sg.Button ('Хорошо'), sg.Button ('Выйти')]]

# Создаем окно
окно = sg.Окно ('Заголовок окна', макет)

# Отображение окна и взаимодействие с ним с помощью цикла событий
в то время как True:
    событие, значения = window.read ()
    # Посмотрите, хочет ли пользователь выйти или окно было закрыто
    если event == sg.WINDOW_CLOSED или event == 'Quit':
        перемена
    # Вывести сообщение в окно
    window ['- OUTPUT -']. update ('Hello' + values ​​['- INPUT-'] + "! Спасибо за попытку PySimpleGUI")

# В конце удалите с экрана
window.close ()
 

Это окно, созданное в примере 2.

А вот как это выглядит после того, как вы введете значение в поле ввода и нажмете кнопку ОК.

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

Во-первых, вы заметите различия в компоновке. В особенности важны два изменения. Одним из них является добавление параметра key к элементу Input и одному из элементов Text . Ключ похож на имя элемента.Или, говоря языком Python, это как ключ словаря. Ключ элемента Input будет использоваться в качестве ключа словаря позже в коде.

Еще одно отличие заключается в добавлении этого элемента Text :

 [sg.Text (size = (40,1), key = '- OUTPUT-')],
 

Есть 2 параметра, ключ , который мы уже рассмотрели. Параметр size определяет размер элемента в символах. В этом случае мы указываем, что этот элемент Text имеет ширину 40 символов и высоту 1 символ.Обратите внимание, что текстовая строка не указана, что означает, что она будет пустой. Вы можете легко увидеть эту пустую строку в созданном окне.

Еще мы добавили кнопку «Выйти».

Цикл событий имеет наш знакомый вызов window. read () .

После прочтения следует следующий оператор if:

, если event == sg.WINDOW_CLOSED или event == 'Quit':
        перемена
 

Этот код проверяет, закрыл ли пользователь окно, щелкнув «X», или он нажал кнопку «Выйти».Если что-то из этого произойдет, код выйдет из цикла обработки событий.

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

.
 window ['- OUTPUT -']. Update ('Hello' + values ​​['- INPUT-'] + "! Спасибо за попытку PySimpleGUI")
 

Этот оператор обновляет элемент Text , который имеет ключ -OUTPUT- со строкой. window ['- OUTPUT-'] находит элемент с ключом -OUTPUT- . Этот ключ принадлежит нашему пустому элементу Text . Как только этот элемент возвращается из поиска, вызывается его метод update . Почти все элементы имеют метод обновления . Этот метод используется для изменения значения элемента или для изменения некоторой конфигурации элемента.

Если мы хотим, чтобы текст был желтым, это можно сделать, добавив параметр text_color в метод update , чтобы он читался так:

Окно
 ['- ВЫХОД-'].update ('Hello' + values ​​['- INPUT-'] + "! Спасибо, что попробовали PySimpleGUI",
                              text_color = 'желтый')
 

После добавления параметра text_color это наше новое результирующее окно:

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

Как видите, для элемента Text можно изменить несколько вещей. Справочная документация по вызовам - ценный ресурс, который сделает программирование в PySimpleGUI, ммм, простым.


Макеты смешные LOL! : смеясь:

Макет вашего окна представляет собой «список списков» (LOL). Окна разбиты на «ряды». Каждая строка в вашем окне становится списком в вашем макете. Соедините вместе все списки, и вы получите макет ... список списков.

Вот тот же макет, что и раньше, с дополнительным элементом Text , добавленным в каждую строку, чтобы вам было легче увидеть, как определены строки:

 layout = [[sg.Text ('Row 1'), sg.Text ("Как тебя зовут?")],
            [sg.Text ('Строка 2'), sg.Input ()],
            [sg.Text ('Row 3'), sg.Button ('Ok')]]
 

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

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

Эти 3 строки кода:

 импортировать PySimpleGUI как sg

layout = [[sg.Button (f '{row}, {col}') для столбца в диапазоне (4)] для строки в диапазоне (4)]

event, values ​​= sg.Window ('Составление списка', макет) .read (close = True)
 

создает это окно с сеткой кнопок 4 x 4:

Напомним, как «развлечься» - одна из целей проекта. Приятно напрямую применять мощные базовые возможности Python для решения проблем с графическим интерфейсом. Вместо страниц кода для создания графического интерфейса это несколько (а часто и 1) строк кода.

Сворачивающийся код

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

Событие
, values ​​= sg.Window ('Заголовок окна', [[sg.Text («Как тебя зовут?»)], [Sg.Input ()], [sg. Button ('Ok')]]). читать (закрыть = True)
 

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

Используя сокращенные псевдонимы, вы можете сэкономить еще больше места в своем коде, используя меньше символов. Все элементы имеют одно или несколько более коротких имен, которые можно использовать. Например, элемент Text можно записать просто как T .Элемент Input может быть записан как I , а Button - как B . Таким образом, ваш однострочный код окна становится:

Событие
, values ​​= sg.Window ('Заголовок окна', [[sg.T («Как тебя зовут?»)], [Sg. I ()], [sg.B ('Хорошо')]]). читать (закрыть = True)
 

Переносимость кода

PySimpleGUI в настоящее время может работать на 4-х Python GUI Framework. Используемая структура указывается с помощью оператора импорта. Измените импорт, и вы измените базовую структуру графического интерфейса.Для некоторых программ не требуется никаких других изменений, кроме оператора импорта для запуска в другой среде графического интерфейса. В приведенном выше примере изменение импорта с PySimpleGUI на PySimpleGUIQt , PySimpleGUIWx , PySimpleGUIWeb изменит структуру.

Заявление об импорте Окно результатов
PySimpleGUI
PySimpleGUIQt
PySimpleGUIWx
PySimpleGUIWeb

Перенос кода графического интерфейса пользователя с одной платформы на другую (например,грамм. перенос кода с tkinter на Qt) обычно требует переписывания кода. PySimpleGUI разработан, чтобы вы могли легко перемещаться между фреймворками. Иногда от вас требуются некоторые изменения, но ваша цель - получить легко переносимый код с минимальными изменениями.

Некоторые функции, например значок на панели задач, доступны не на всех портах. Функция значка на панели задач доступна на портах Qt и WxPython. Смоделированная версия доступна на tkinter. Значок на панели задач в порту PySimpleGUIWeb не поддерживается.

Среды выполнения

Окружающая среда Поддерживается
Python Python 3.4+
Операционные системы Windows, Linux, Mac
Оборудование Настольные ПК, ноутбуки, Raspberry Pi, устройства Android под управлением PyDroid3
Онлайн repli.it, Trinket.com (оба запускают tkinter в браузере)
Фреймворки графического интерфейса tkinter, pyside2, WxPython, Remi

Интеграции

Среди более чем 200 «демонстрационных программ» вы найдете примеры того, как интегрировать многие популярные пакеты Python в ваш графический интерфейс.

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

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

Упаковка Описание
Matplotlib Многие типы графиков и графиков
OpenCV Компьютерное зрение (часто используется для ИИ)
VLC Воспроизведение видео
пимун Физический двигатель
psutil Статистика системной среды
креветки Reddit API
json PySimpleGUI является оболочкой специального API для хранения «Пользовательских настроек»
погода Интегрируется с несколькими погодными API для создания погодных приложений
мидо Воспроизведение MIDI
красивый суп Веб-парсинг (пример наблюдателя проблем GitHub)

Два распространенных способа установки PySimpleGUI:

  1. pip для установки из PyPI
  2. Загрузите файл PySimpleGUI. py и поместите в папку вашего приложения

Установка и обновление трубопровода

Текущий предлагаемый способ вызова команды pip - запускать ее как модуль с использованием Python. Ранее команда pip или pip3 была непосредственно в командной строке / оболочке. Предлагаемый способ

Первоначальная установка для Windows:

python -m pip install PySimpleGUI

Первоначальная установка для Linux и MacOS:

python3 -m pip install PySimpleGUI

Для обновления с использованием pip вам просто нужно указать 2 параметра в строке --upgrade --no-cache-dir .

Установка обновления в Windows:

python -m pip install --upgrade --no-cache-dir PySimpleGUI

Обновление для Linux и MacOS:

python3 -m pip install --upgrade --no-cache-dir PySimpleGUI

Установка одного файла

PySimpleGUI был создан как единый файл . py, поэтому вам было бы очень легко установить его даже в системах, которые не подключены к Интернету, как Raspberry Pi. Это так же просто, как разместить PySimpleGUI.py в ту же папку, что и ваше приложение, которое его импортирует. Python будет использовать вашу локальную копию при выполнении импорта.

При установке с использованием только файла .py, вы можете получить его либо из PyPI, либо, если вы хотите запустить самую последнюю невыпущенную версию, загрузите ее с GitHub.

Для установки из PyPI загрузите либо колесо, либо файл .gz и распакуйте файл. Если вы переименуете файл .whl в .zip, вы сможете открыть его, как любой обычный zip-файл. Вы найдете PySimpleGUI.py файл в одной из папок. Скопируйте этот файл в папку вашего приложения, и все готово.

Ссылка PyPI для версии PySimpleGUI для tkinter: https://pypi.org/project/PySimpleGUI/#files

Последнюю версию репозитория GitHub можно найти здесь: https://raw.githubusercontent.com/PySimpleGUI/PySimpleGUI/master/PySimpleGUI. py

Теперь некоторые из вас думают: «Да, но подождите, иметь один огромный исходный файл - ужасная идея». И да, иногда это может быть ужасная идея.В этом случае преимущества значительно перевесили обратную сторону. Многие концепции информатики являются компромиссными или субъективными. Как бы некоторые ни хотели, не все черное и белое. Часто ответ на вопрос - это зависит от обстоятельств.

Галереи: art:

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

Галерея, размещенная пользователем

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

Массивные скопированные образы GitHub

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


В следующих разделах показана часть использования PySimpleGUI. Только на GitHub существует более 1000 проектов, использующих PySimpleGUI. Поистине удивительные возможности, которые открылись для стольких людей. Многие пользователи говорили о том, что ранее пытались создать графический интерфейс на Python и терпели неудачу, но наконец достигли своей мечты, когда попробовали PySimpleGUI.

Ваш первый графический интерфейс

Конечно, одно из лучших применений PySimpleGUI - это научить вас создавать графические интерфейсы для ваших проектов Python. Вы можете начать с простого запроса имени файла. Для этого вам нужно всего лишь один раз вызвать одну из «высокоуровневых функций» под названием popup . Всплывающие окна бывают всевозможные, некоторые собирают информацию.

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

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

 импортировать PySimpleGUI как sg

filename = sg.popup_get_file ('Введите файл, который вы хотите обработать')
sg.popup ('Вы вошли', имя файла)
 

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

Другое окно выведет то, что собрано.


Окна в стиле Rainmeter

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

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

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

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

Изменение вызова создания окна в примере 1 на эту строку кода дает аналогичное полупрозрачное окно:

 окно = sg.Окно ('Мое окно', layout, no_titlebar = True, alpha_channel = 0.5)
 

Игры

Хотя PySimpleGUI специально не написан как SDK для разработки игр, он значительно упрощает разработку некоторых игр.

Эта программа Chess не только играет в шахматы, но и интегрируется с ИИ игры в шахматы Stockfish.

Пользователи выпустили несколько вариантов Minesweeper.

Карточные игры хорошо работают с PySimpleGUI, так как манипулировать изображениями просто при использовании элемента PySimpleGUI Graph .

Хотя PySimpleGUI специально не написан как SDK для разработки игр, он значительно упрощает разработку некоторых игр.

Захват и воспроизведение мультимедиа

Захват и отображение видео с веб-камеры в графическом интерфейсе пользователя - это 4 строки кода PySimpleGUI. Еще более впечатляющим является то, что эти 4 строки кода работают с портами tkinter, Qt и Web. Вы можете отображать свою веб-камеру в реальном времени в браузере, используя тот же код, который отображает изображение с помощью tkinter.

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

Искусственный интеллект

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

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

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

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

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

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

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

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


Графики

Отображение данных и взаимодействие с ними в графическом интерфейсе очень просто с PySimpleGUI. У вас есть несколько вариантов.

Вы можете использовать встроенные возможности рисования / построения графиков для создания настраиваемых графиков. Этот монитор использования ЦП использует элемент Graph

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

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


Внешний вид

Упомянутый ранее "промежуток в графическом интерфейсе" можно легко решить с помощью PySimpleGUI.Вам даже не нужно иметь исходный код программы, в которую вы хотите добавить графический интерфейс. «Интерфейсный» графический интерфейс - это тот, который собирает информацию, которая затем передается в приложение командной строки.

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

Этот пример представляет собой интерфейс для программы под названием «Jump Cutter». Параметры собираются через графический интерфейс, с использованием этих параметров создается командная строка, а затем команда выполняется с выводом из программы командной строки, направляемой в интерфейс графического интерфейса. В этом примере желтым цветом отображается команда, которая была выполнена.


Raspberry Pi

Поскольку PySimpleGUI обратно совместим с Python 3.4, он может создавать графический интерфейс для ваших проектов Raspberry Pi.Особенно хорошо он работает в сочетании с сенсорным экраном. Вы также можете использовать PySimpleGUIWeb для управления своим Pi, если к нему не подключен монитор.


Простой доступ к расширенным функциям

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

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

Невероятно, но это окно использует tkinter для создания чего-то вроде заставки.

В Windows tkinter может полностью удалить фон из вашего приложения. И снова PySimpleGUI делает доступ к этим возможностям тривиальным. Создание прозрачного окна требует добавления одного параметра к вызову, который создает ваше окно Window . Одно изменение параметра может привести к простому применению с таким эффектом:

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


Устали от серого графического интерфейса по умолчанию? PySimpleGUI упрощает внешний вид вашего окна, сделав один вызов функции темы . На ваш выбор доступно более 150 различных цветовых тем:

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

Для использования темы вызовите функцию theme с именем темы перед созданием окна.Вы можете добавить пробелы для удобства чтения. Чтобы установить тему «Темно-серый 9»:

 импортировать PySimpleGUI как sg

sg.theme ('темно-серый 9')
 

Эта единственная строка кода полностью меняет внешний вид окна:

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


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

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

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

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

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

Создание

PySimpleGUI было не из дешевых. Это был труд любви, но очень кропотливый. Требуется более 2 лет работы 7 дней в неделю, чтобы довести программное обеспечение и документацию до уровня, который вы видите сегодня.

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

Купи мне кофе

Buy Me a Coffee - отличный способ публично поддержать разработчиков. Это быстро, легко, и ваш вклад записывается, чтобы другие могли видеть, что вы поддерживаете PySimpleGUI. Вы также можете сделать свое пожертвование приватным.

Спонсорство GitHub

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

Мы будем очень признательны за вашу помощь в финансовом вкладе в проект. Быть разработчиком с открытым исходным кодом сложно с финансовой точки зрения. Создатели видео на YouTube могут зарабатывать на жизнь созданием видеороликов. Для разработчиков с открытым исходным кодом это еще не так просто.

Здесь нужна откровенная дискуссия. Тонкие не сработали.

Финансовая часть разработки с открытым исходным кодом не часто открыто обсуждается. Как разработчик с открытым исходным кодом, не существует автоматической формы входящих событий, особенно с Python, где исходный код по существу должен быть предоставлен.Создание коммерческой лицензии и управление ею обходятся дорого. Превратить проект из лицензии с открытым исходным кодом в коммерческую лицензию - большое препятствие. Адвокаты, с которыми я разговаривал, не слышали, чтобы это происходило успешно. Итак, лицензирование - не практичный вариант.

Работать с активным проектом с открытым исходным кодом - дорого. Труд огромен. Как за это платят? Ну это от разработчика исходит как. Создатели YouTube несут расходы на оборудование для камеры и время на создание своего контента и нуждаются в поддержке для работы, и разработчики с открытым исходным кодом тоже.

PySimpleGUI нуждается в вашей помощи. Без какого-либо финансирования этот проект закончится, скорее всего, раньше, чем позже. Лица с наибольшей способностью делать финансовый вклад - это корпоративные пользователи. Сделать пожертвование PySimpleGUI не так уж сложно и не представляет финансовых трудностей для кого-то, кто работает в компании. Вы тратите чужие деньги. Если вы получаете зарплату от корпорации и используете PySimpleGUI, вы «корпоративный пользователь». Не имеет значения, поставляется ли PySimpleGUI в продукте, который вы продаете.Ваша компания получает выгоду от использования PySimpleGUI. Если бы это было не так, вы бы не использовали его. Человек в вашей компании, который может помочь усилиям PySimpleGUI, - это вы, пользователь. Ваш финансовый директор не собирается производить платеж автоматически. Ваша юридическая команда не ищет помощи в проектах с открытым исходным кодом. Я не заключал лицензионных соглашений ни с вашей компанией, ни с какой-либо другой. Это вы, конечный пользователь, то есть человек в вашей компании, которому нужно будет принять меры и который может помочь продолжить проект.

Это программное обеспечение PySimpleGUI не является продуктом AI-бота. Нет и поддержки пользователей, которые его используют. Есть разработчик программного обеспечения (с помощью очень добрых, дружелюбных, щедрых людей), который выполняет всю эту работу. Я делаю это, потому что мне нравится создавать и давать людям возможность делать крутые вещи. Но эта любовь не оплачивает счета. Энергия, вложенная в проект, не создает электричество. Я делаю вещи, электричество к их числу не относится.

Patreon хорошо работает на YouTube. Обычно это терпит неудачу для разработчиков. Но доступно несколько механизмов, включая PayPal, спонсорство GitHub и BuyMeACoffee. Все они работают очень хорошо и занимают 2 минуты, если что. Единственное, что для этого требуется, - это действие со стороны пользователя PySimpleGUI. Если вы не можете позволить себе помочь, ничего страшного. Используйте программу бесплатно. Делайте крутые штуки. Сделайте мир лучше, проще в использовании. Если вы можете позволить себе помочь, рассмотрите возможность пожертвования на проект. Это по уважительной причине.

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

Хотя PySimpleGUI в настоящее время находится под лицензией с открытым исходным кодом, сам проект структурирован как закрытый продукт. Запросы на вытягивание не принимаются.

Один из лучших способов внести свой вклад в код - это писать и публиковать приложения. Пользователи вдохновляются тем, что создают другие пользователи. Создайте репозиторий GitHub, опубликуйте код и включите снимок экрана в файл readme репо.

Если отсутствует какая-либо функция, которая вам нужна, или у вас есть возможность предложить улучшение, откройте проблему

.

Эта версия Readme PySimpleGUI не смогла бы появиться без помощи @ M4cs. Он фантастический разработчик и поддерживает PySimpleGUI с момента запуска проекта. @ israel-сушилка является еще одним давним сторонником и написал несколько программ PySimpleGUI, которые расширили возможности пакета. Уникальный тральщик, использующий изображение для доски, был создан Израилем[email protected] jason9

удивил многих, когда он опубликовал первую карточную игру с использованием PySimpleGUI, которую вы видите на картинке выше, а также первую игру про саперов, созданную с помощью PySimpleGUI. Японская версия readme была значительно улучшена с помощью @ okajun35.

Более 1 200 репозиториев GitHub, использующих PySimpleGUI, также заслуживают благодарности, потому что именно вы вдохновили движок этого проекта.

Зарубежные пользователи, которые оставляют сообщения в Твиттере в одночасье, - это искра, с которой начинается дневная работа над PySimpleGUI.Они были источником положительной энергии, которая запускала движок разработки и заставляла его работать каждый день. В знак признательности этот файл readme был переведен на японский язык.

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

© Авторское право 2020 PySimpleGUI.org

10 лучших фреймворков Python для разработчиков | Клэр Д. Коста

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

Пакет PyQt построен на основе Qt framework, , который представляет собой кросс-платформенный фреймворк, используемый для создания множества приложений для различных платформ. Пакет PyQt5 включает подробный набор привязок для Python, основанный на последней версии v5 фреймворка приложений Qt.

Подобно фреймворку Qt5, PyQt5 также полностью кроссплатформенный .Используя возможности PyQt5, разработчики могут создавать приложения для таких платформ, как Windows, Mac, Linux, iOS, Android и другие.

Когда дело доходит до создания графических интерфейсов, арсенал PyQt5 предлагает впечатляющий QtGui и модуль QtDesigner , , которые предоставляют многочисленные визуальные элементы, которые разработчик может реализовать простым перетаскиванием. Конечно, существует возможность создания этих элементов с помощью кода, что позволяет с легкостью создавать как мелкомасштабные, так и крупномасштабные приложения. Модульность Python переходит в PyQt5 в виде расширений, предоставляя вам гораздо больше возможностей, чем просто создание графического интерфейса. Если вам нравится то, что вы видите здесь, вы можете попробовать PyQt5 с помощью команды «pip install PyQt5».

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

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

● Рамка: для предоставления структуры вашему приложению

● Кнопки: используются для ввода данных от пользователя

● Контрольные кнопки: используются для выбора

● Ярлыки: для отображения текстовая информация

● Файловые диалоговые окна: для загрузки или выгрузки файлов в / из приложения

● Холст: предоставляет пространство для рисования / раскрашивания таких вещей, как графики и графики

Написано с использованием Python и Cython , Kivy - это среда графического интерфейса с открытым исходным кодом для создания некоторых из наиболее интуитивно понятных пользовательских интерфейсов, охватывающих мультисенсорные приложения , которые реализуют естественный пользовательский интерфейс (NUI) .

NUI - это своего рода интерфейс, в котором пользователь естественным образом узнает о различных взаимодействиях, обеспечиваемых пользовательским интерфейсом, хотя они обычно остаются невидимыми.

С помощью Kivy дизайнеры интерфейсов могут кодировать один раз и развертывать на нескольких платформах , в то время как встроенная поддержка OpenGL ES 2 позволяет им использовать современные и мощные методы графики и дизайна. Наиболее частое использование инфраструктуры графического интерфейса Kivy в реальном мире можно увидеть в наших приложениях для Android и iOS.Другие широко распространенные реализации фреймворка можно увидеть в пользовательских интерфейсах устройств Linux, Windows, Raspberry Pi и Mac OS . Вы можете легко добавить эту структуру в свою среду, следуя инструкциям по установке, представленным на их веб-сайте.

wxPython - это, по сути, модуль расширения Python, который действует как оболочка для API wxWidgets. wxPython позволяет разработчикам Python создавать собственные пользовательские интерфейсы , которые не добавляют дополнительных накладных расходов к приложению.Кроссплатформенные возможности wxPython позволяют развертывать его на таких платформах, как Windows, Mac OS, Linux и системы на основе Unix, практически без изменений.

Дуэт разработчиков позже выпустил Project Phoenix в качестве преемника wxPython с поддержкой Python 3 . Он был создан с нуля, чтобы предложить более чистую реализацию Python набора инструментов wxWidgets. Если вы хотите попробовать этот фреймворк, вы будете рады узнать, что последнее обновление v4.1.1 добавил его в указатель пакетов Python. С добавлением PyPI загрузка стала более плавной с помощью команды «pip install wxPython == 4.1.1».

Написано на C ++ Ульрихом фон Задоу, среда графического интерфейса пользователя L ibavg с открытым исходным кодом использует Python в качестве языка сценариев выбора и служит одной из лучших сред для разработки пользовательских интерфейсов для современных сенсорных устройств . Обработка графических элементов, таких как декодирование видео, визуальные эффекты и композитинг, осуществляется за счет аппаратного ускорения, достигаемого с помощью шейдеров OpenGL и графического процессора, что обеспечивает плавные и насыщенные графикой визуальные эффекты.

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

Созданный с использованием C ++ для обеспечения невероятно быстрого времени выполнения, разработчики, которые хотят получить от своего приложения максимальную производительность, не будут разочарованы libavg.Вы можете найти инструкции по установке на странице загрузок их веб-сайта.

Разве название этого фреймворка не является явной демонстрацией того, для чего он предназначен? Возвращаясь к теме, те, кто только начинает заниматься разработкой приложений Python, могут поначалу найти много фреймворков Python GUI устрашающими. Майк Б. создал PySimpleGUI в 2018 году. облегчают новичкам Python в разработке графического интерфейса , не тратя слишком много времени на изучение тонкостей более продвинутых доступных вариантов разработки графического интерфейса.

PySimpleGUI использует 4 широко распространенных графических интерфейса Python, включая Qt, Tkinter, WxPython и Remi , и снижает их сложность на несколько ступеней за счет реализации большей части стандартного кода. Результат?

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

Среда графического интерфейса пользователя PyForms - это программный уровень Python, лежащий в основе широко известной Windows Forms , которая позволяет разработчикам создавать удивительных и очень интерактивных пользовательских интерфейсов. Кросс-платформенные возможности PyForms облегчают разработчикам создание приложений для нескольких платформ с небольшими изменениями кода, устраняя ненужные замедления. PyForms предоставляет экземпляры нескольких популярных графических библиотек, таких как PyQt, OpenGL, , , и других, чтобы помочь разработчикам создавать пользовательские интерфейсы для своих приложений.

Библиотека PyForms разделена на 3 различных раздела, включая PyForms-GUI, PyForms-Web и PyForms-Terminal. Каждый из этих уровней позволяет выполнять приложение PyForms в Интернете, в терминале и в графическом интерфейсе Windows. Ориентируясь на модульность, PyForms идеально подходит для быстрого создания прототипов, а также может быстро выполнить обслуживание на более поздних этапах приложения. Установка выполняется с помощью команды «pip install pyforms», которая добавляет все три библиотеки, или, если вы хотите использовать библиотеки по отдельности, это тоже возможно.

Помните фреймворк под названием wxPython, который мы обсуждали несколько указателей назад? Подобно тому, как wxPython был оболочкой для набора инструментов графического интерфейса пользователя wxWidgets, среда графического интерфейса пользователя воск является более удобной для разработчиков оболочкой wxPython. Как и другие популярные фреймворки, воск также реализован как модуль расширения для Python. А для тех, кому интересно, да, воск поддерживает создание кроссплатформенных приложений.

Идея воска состоит в том, чтобы предложить разработчикам приложений более простой доступ к элементам и объектам Python для создания графического интерфейса пользователя, удалив низкоуровневые аспекты wxPython.Поскольку базовая платформа wxWindows сама по себе чрезвычайно эффективна, структура графического интерфейса пользователя Wax работает на том же уровне эффективности и скорости, что и собственные виджеты, предоставляемые платформой.

PySide2 - это , созданный той же компанией , которая предоставила нам широко популярный фреймворк для разработки приложений Qt. Присмотревшись, вы встретите термин «Qt для проекта Python», , который является не чем иным, как задачей переноса PySide для поддержки Qt5, тогда как сама структура теперь называется PySide2.

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

PySide2 также предлагает мощную поддержку сообщества для разработчиков, которые ищут его. Раздел документации PySide2 был разделен на такие области, как учебные пособия , видеоруководства, примеры, документы API, и другие, чтобы широко охватить множество тем, включенных в структуру. AMD Radeon Control Software , развлекательные решения в кабине для Mercedes Mini Cooper и TomTom Navigation Systems - это лишь некоторые из высокотехнологичных и современных примеров, работающих на Qt.

Проект Python GUI , или инфраструктура PyGUI , как она более широко известна, представляет собой простой API, который позволяет разработчикам создавать пользовательские интерфейсы с использованием собственных элементов для приложений Python. Будучи довольно легким API , среда PyGUI добавляет очень мало дополнительного кода между приложением Python и целевой платформой. PyGUI в настоящее время поддерживает создание приложений для систем на базе Unix, компьютеров с Windows и устройств Mac OS.

Чтобы сделать разработку приложений еще проще для разработчиков, документация для всей библиотеки написана на Python, что избавляет от необходимости ссылаться на другие библиотеки графического интерфейса. PyGUI доступен для Python 2 и 3, и да, он поддерживает расширения, которые позволяют использовать OpenGL и GTK.

Приложения с графическим интерфейсом - Автостопом по Python

Алфавитный список приложений с графическим интерфейсом.

Какао

Примечание

Фреймворк Cocoa доступен только в OS X. Не выбирайте его, если вы пишете кроссплатформенное приложение!

GTk

Примечание

PyGTK предоставляет привязки Python для набора инструментов GTK +. Однако он был заменен PyGObject. PyGTK не следует использовать для новых проектов, а существующие проекты следует переносить в PyGObject.

PyGObject иначе (PyGi)

PyGObject предоставляет Python привязки, которые предоставляют доступ ко всей программной платформе GNOME.Это полностью совместим с GTK + 3. Вот руководство по началу работы с Python GTK + 3 Руководство.

Ссылка API

Киви

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

Kivy написан на Python, основан на OpenGL и поддерживает различные устройства ввода. такие как: мышь, двойная мышь, TUIO, WiiMote, WM_TOUCH, HIDtouch, продукты Apple, и так далее.

Kivy активно развивается сообществом и бесплатен. Он действует на всех основных платформах (Linux, OS X, Windows, Android).

Основной источник информации - сайт: http://kivy.org

PyObjC

Примечание

Доступно только в OS X. Не выбирайте этот вариант, если вы пишете кроссплатформенное приложение.

Pyjs Desktop (ранее Pyjamas Desktop)

Pyjs Desktop - это набор виджетов для настольных компьютеров и кроссплатформенных приложений. рамки.Это позволяет использовать тот же исходный код веб-приложения Python выполняется как отдельное настольное приложение.

Основной сайт: pyjs.

Qt

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

PySimpleGUI

PySimpleGUI - это оболочка для Tkinter и Qt (другие в пути). Количество кода, необходимого для реализации пользовательского Графические интерфейсы намного короче с использованием PySimpleGUI, чем если бы был написан тот же графический интерфейс. напрямую с помощью Tkinter или Qt.Код PySimpleGUI можно «портировать» между GUI. frameworks, изменив операторы импорта.

 $ pip install pysimplegui
 

PySimpleGUI содержится в одном файле PySimpleGUI. py. Должен пип установка будет невозможна, копирование файла PySimpleGUI.py в проект папка - это все, что требуется для импорта и начала использования.

Тога

Toga - это нативный Python, нативный ОС, кроссплатформенный инструментарий GUI. Toga состоит из библиотеки базовых компонентов с общий интерфейс для упрощения разработки графического интерфейса, не зависящего от платформы.

Toga доступен на macOS, Windows, Linux (GTK) и мобильных платформах, таких как Android и iOS.

Tk

Tkinter - это тонкий объектно-ориентированный слой поверх Tcl / Tk. Имеет преимущество включения в стандартную библиотеку Python, что делает ее наиболее удобный и совместимый инструментарий для программирования.

И Tk, и Tkinter доступны на большинстве платформ Unix, а также на Windows. и системы Macintosh. Начиная с версии 8.0, Tk предлагает собственный внешний вид и чувствовать себя на всех платформах.

В TkDocs есть хороший многоязычный учебник по Tk с примерами Python. Дополнительная информация доступно в Python Wiki.

wxPython

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

Установить (стабильную) wxPython перейдите по адресу https://www.wxpython.org/pages/downloads/ и загрузите соответствующий пакет для вашей ОС.

Создание пользовательского интерфейса с использованием Tkinter в Python

Современные компьютерные приложения удобны в использовании. Взаимодействие с пользователем не ограничивается вводом-выводом с консоли. У них более эргономичный графический интерфейс пользователя (GUI) благодаря высокоскоростным процессорам и мощному графическому оборудованию. Эти приложения могут получать ввод с помощью щелчков мыши и могут позволить пользователю выбирать из альтернатив с помощью переключателей, раскрывающихся списков и других элементов графического интерфейса (или виджетов).

Такие приложения разрабатываются с использованием одной из различных доступных графических библиотек. Графическая библиотека - это программный инструментарий, содержащий набор классов, определяющих функциональность различных элементов графического интерфейса. Эти графические библиотеки обычно написаны на C / C ++. Многие из них были перенесены на Python в виде импортируемых модулей. Некоторые из них перечислены ниже:

Tkinter - это порт Python для Tcl-Tk GUI toolkit , разработанный Фредриком Лундом.Этот модуль включен в стандартные дистрибутивы Python для всех платформ.

PyQtis, интерфейс Python для Qt, является очень популярной кроссплатформенной средой графического интерфейса.

PyGTK - это модуль, который переносит Python в другой популярный инструментарий виджетов с графическим интерфейсом под названием GTK.

WxPython - это оболочка Python для WxWidgets, еще одной кроссплатформенной графической библиотеки.

В этом руководстве объясняется использование Tkinter при разработке программ Python на основе графического интерфейса пользователя.

Базовое приложение с графическим интерфейсом

Элементы графического интерфейса и их функциональные возможности определены в модуле Tkinter. Следующий код демонстрирует шаги по созданию пользовательского интерфейса.

  из tkinter import *
окно = Tk ()
# добавьте сюда виджеты

окно.title ('Привет, Python')
window.geometry ("300x200 + 10 + 20")
window.mainloop ()
  

Прежде всего, импортируйте модуль TKinter. После импорта настройте объект приложения, вызвав функцию Tk () . Это создаст окно верхнего уровня (корень), имеющее фрейм со строкой заголовка, блок управления с кнопками свертывания и закрытия, а также клиентскую область для хранения других виджетов. Метод geometry () определяет ширину, высоту и координаты верхнего левого угла кадра, как показано ниже (все значения в пикселях): окно .геометрия ("ширина x высота + XPOS + YPOS") Затем объект приложения входит в цикл прослушивания событий, вызывая метод mainloop () . Приложение теперь постоянно ожидает любого события, генерируемого элементами в нем. Событие может быть текстом, введенным в текстовое поле, выбором из раскрывающегося списка или переключателем, однократным / двойным щелчком мыши и т. Д. Функциональность приложения включает выполнение соответствующих функций обратного вызова в ответ на события определенного типа. Мы обсудим обработку событий позже в этом руководстве. Цикл событий завершится, как только будет нажата кнопка закрытия в строке заголовка. Приведенный выше код создаст следующее окно:

Окно Python-Tkinter

Все классы виджетов Tkinter унаследованы от класса Widget. Добавим наиболее часто используемые виджеты.

Кнопка

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

Подпись: Кнопка (окно, атрибуты)

Для настройки кнопки можно установить следующие важные свойства:

  • текст: заголовок кнопки
  • bg: цвет фона
  • fg: цвет переднего плана
  • font: название и размер шрифта
  • изображение: для отображения вместо текста
  • команда: функция, вызываемая при нажатии
  из tkinter import *
окно = Tk ()
btn = Button (window, text = "Это виджет кнопки", fg = 'blue')
btn. место (x = 80, y = 100)
window.title ('Привет, Python')
window.geometry ("300x200 + 10 + 10")
window.mainloop ()
  

Этикетка

Ярлык можно создать в пользовательском интерфейсе Python с помощью класса Label. Конструктору Label требуются объект окна верхнего уровня и параметры параметров. Параметры опции аналогичны объекту Button.

Следующее добавляет метку в окно.

  из tkinter import *
окно = Tk ()
lbl = Label (window, text = "Это виджет Label", fg = 'red', font = ("Helvetica", 16))
фунт. место (x = 60, y = 50)
window.title ('Привет, Python')
window.geometry ("300x200 + 10 + 10")
window.mainloop ()
  

Здесь подпись метки будет отображаться красным цветом с использованием шрифта Helvetica размером 16 пунктов.

Запись

Этот виджет отображает однострочное текстовое поле для принятия пользовательского ввода. Для ввода многострочного текста используйте виджет «Текст». Помимо уже упомянутых свойств, конструктор класса Entry принимает следующее:

  • bd: размер границы текстового поля; по умолчанию - 2 пикселя.
  • show: для преобразования текстового поля в поле пароля установите для свойства show значение «*».

Следующий код добавляет текстовое поле.

txtfld = Entry (window, text = "Это виджет входа", bg = 'black', fg = 'white', bd = 5)

В следующем примере создается окно с кнопкой, меткой и полем ввода.

  из tkinter import *
окно = Tk ()
btn = Button (window, text = "Это виджет кнопки", fg = 'blue')
btn. место (x = 80, y = 100)
lbl = Label (window, text = "Это виджет Label", fg = 'red', font = ("Helvetica", 16))
фунт. место (x = 60, y = 50)
txtfld = Entry (window, text = "Это виджет входа", bd = 5)
txtfld.place (x = 80, y = 150)
window.title ('Привет, Python')
window.geometry ("300x200 + 10 + 10")
window.mainloop ()
  

В приведенном выше примере будет создано следующее окно.

Создание виджетов пользовательского интерфейса в Python-Tkinter

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

Radiobutton: Этот виджет отображает кнопку-переключатель, находящуюся в состоянии ВКЛ / ВЫКЛ.Может быть более одной кнопки, но только одна из них будет включена в данный момент.

Checkbutton: Это также кнопка переключения. Перед его заголовком появится прямоугольный флажок. Его состояние «ВКЛ.» Отображается галочкой в ​​поле, которое исчезает при нажатии на «ВЫКЛ. ».

Combobox: Этот класс определен в модуле ttk пакета tkinterpackage. Он заполняет раскрывающиеся данные из типа данных коллекции, такого как кортеж или список, в качестве параметра значений.

Listbox: В отличие от Combobox, этот виджет отображает всю коллекцию строковых элементов. Пользователь может выбрать один или несколько элементов.

В следующем примере демонстрируется окно с виджетами выбора: Radiobutton, Checkbutton, Listbox и Combobox:

  из tkinter import *
из tkinter.ttk import Combobox
окно = Tk ()
var = StringVar ()
var.set ("один")
data = ("один", "два", "три", "четыре")
cb = Combobox (окно, значения = данные)
cb.place (x = 60, y = 150)

lb = Listbox (окно, высота = 5, selectmode = 'multiple')
для числа в данных:
    lb.insert (КОНЕЦ, число)
фунт на место (x = 250, y = 150)

v0 = IntVar ()
v0. set (1)
r1 = Radiobutton (окно, текст = "мужской", переменная = v0, значение = 1)
r2 = Radiobutton (окно, текст = "женский", переменная = v0, значение = 2)
r1.place (x = 100, y = 50)
r2.место (x = 180, y = 50)
                
v1 = IntVar ()
v2 = IntVar ()
C1 = Checkbutton (window, text = "Cricket", variable = v1)
C2 = Checkbutton (window, text = "Tennis", variable = v2)
C1.место (x = 100, y = 100)
C2.место (x = 180, y = 100)

window.title ('Привет, Python')
window.geometry ("400x300 + 10 + 10")
window.mainloop ()
  
Создание пользовательского интерфейса в Python-Tkinter

Обработка событий

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

События выражаются в виде строк в формате <тип-модификатора>.

Многие события представлены только как квалификаторы.Тип определяет класс события.

В следующей таблице показано, как Tkinter распознает различные события:

Мероприятие Модификатор Тип Квалификатор Действие
<Кнопка 1> Кнопка 1 Щелчок левой кнопкой мыши.
<Кнопка 2> Кнопка 2 Щелчок средней кнопкой мыши.
<Уничтожить> Разрушать Окно разрушается.
<Двойная кнопка 1> Двойной Кнопка 1 Дважды щелкните первую кнопку мыши 1.
Войти Курсор входит в окно.
<Разоблачить> Разоблачать Окно полностью или частично открыто.
Нажатие клавиши а Нажата любая клавиша.
KeyRelease Отпущен любой ключ.
<Оставить> Покинуть Курсор покидает окно.
<Печать> Распечатать Нажата клавиша PRINT.
Сосредоточиться Виджет получает фокус.
FocusOut виджет теряет фокус.

Событие должно быть зарегистрировано с помощью одного или нескольких виджетов графического интерфейса в приложении.В противном случае он будет проигнорирован. В Tkinter есть два способа зарегистрировать событие с помощью виджета. Первый способ - использовать метод bind () , а второй - использовать параметр команды в конструкторе виджета.

Метод Bind ()

bind () Метод связывает событие с функцией обратного вызова, так что при возникновении четности функция вызывается.

 Виджет.привязать (событие, обратный вызов)
 

Например, чтобы вызвать функцию MyButtonClicked () при щелчке левой кнопкой мыши, используйте следующий код:

  из tkinter import *
окно = Tk ()
btn = Кнопка (окно, текст = 'ОК')
btn.bind ('', MyButtonClicked)
  

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

Параметр команды

Каждый виджет в первую очередь реагирует на определенный тип. Например, Button является источником события Button. Итак, он по умолчанию привязан к нему. У методов конструктора многих классов виджетов есть необязательный параметр, называемый командой. Этот параметр команды настроен на обратный вызов функции, которая будет вызываться всякий раз, когда происходит связанное с ней событие.Этот метод более удобен, чем метод bind () .

btn = Кнопка (окно, текст = 'ОК', команда = myEventHandlerFunction)

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

Первая кнопка (Добавить) настраивается с помощью параметра команды. Его значение - это метод add () в классе. Вторая кнопка использует метод bind () для регистрации щелчка левой кнопкой с помощью метода sub () . Оба метода читают содержимое текстовых полей с помощью метода get () виджета Entry, анализируют числа, выполняют сложение / вычитание и отображают результат в третьем текстовом поле с помощью метода insert () .

  из tkinter import *
класс MyWindow:
    def __init __ (self, win):
        self.lbl1 = Label (win, text = 'Первое число')
        self.lbl2 = Label (win, text = 'Второе число')
        self.lbl3 = Метка (победа, текст = 'Результат')
        self.t1 = Запись (bd = 3)
        self.t2 = Вход ()
        self.t3 = Вход ()
        self.btn1 = Кнопка (победа, текст = 'Добавить')
        self.btn2 = Кнопка (выигрыш, текст = 'Вычесть')
        себя.lbl1.place (x = 100, y = 50)
        self.t1.place (x = 200, y = 50)
        self.lbl2.place (x = 100, y = 100)
        self.t2.place (x = 200, y = 100)
        self.b1 = Кнопка (win, text = 'Добавить', command = self.add)
        self.b2 = Кнопка (выигрыш, текст = 'Вычесть')
        self.b2.bind ('<Кнопка-1>', self.sub)
        self.b1.place (x = 100, y = 150)
        self.b2.place (x = 200, y = 150)
        self.lbl3.place (x = 100, y = 200)
        self.t3.place (x = 200, y = 200)
    def add (self):
        себя.t3.delete (0, 'конец')
        num1 = int (self.t1.get ())
        число2 = интервал (self.t2.get ())
        результат = число1 + число2
        self.t3.insert (END, str (результат))
    def sub (себя, событие):
        self.t3.delete (0, 'конец')
        num1 = int (self.t1.get ())
        число2 = интервал (self.t2.get ())
        результат = число1-число2
        self.t3.insert (END, str (результат))

окно = Tk ()
mywin = MyWindow (окно)
window.title ('Привет, Python')
window.geometry ("400x300 + 10 + 10")
окно.mainloop ()
  

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

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

Таким образом, вы можете создать пользовательский интерфейс с помощью TKinter в Python.

Топ-5 лучших библиотек графического интерфейса Python

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

Что такое графический интерфейс?

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

Список лучших библиотек графического интерфейса Python

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

1. PyQT5

PyQT5 - это среда графического пользовательского интерфейса (GUI) для Python. Он очень популярен среди разработчиков, и графический интерфейс можно создать с помощью кода или дизайнера QT. Среда разработки QT - это визуальная среда, которая позволяет перетаскивать виджеты для создания пользовательских интерфейсов.

Это бесплатное программное обеспечение с открытым исходным кодом для привязки, реализованное для кросс-платформенной среды разработки приложений. Он используется в Windows, Mac, Android, Linux и Raspberry PI.

Для установки PyQT5 вы можете использовать следующую команду:

pip install pyqt5
 

Здесь показан простой код:

из PyQt5.QtWidgets import QApplication, QMainWindow
import sys

класс Window (QMainWindow):
   def __init __ (сам):
       супер().__в этом__()

       self.setGeometry (300, 300, 600, 400)
       self.setWindowTitle ("Окно PyQt5")
       self.show ()

app = QApplication (sys.argv)
window = Окно ()
sys.exit (app.exec_ ())

 

Вывод вышеуказанного кода выглядит следующим образом:

PyQt5

Команда ScienceSoft из разработчиков Python подчеркивает преимущества использования PyQt:

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

2. Python Tkinter

Другой фреймворк графического интерфейса называется Tkinter. Tkinter - одна из самых популярных библиотек графического интерфейса Python для разработки настольных приложений. Это сочетание стандартного графического интерфейса пользователя TK и Python.

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

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

из tkinter import *

класс Root (Tk):
    def __init __ (сам):
        super (корень, сам) .__ init __ ()

        self.title ("Python Tkinter")
        себя.миниатюрный (500 400)

корень = Корень ()
root.mainloop ()
 

Вывод приведенного выше кода показан ниже:

Ткинтер

3. PySide 2

Третья библиотека графического интерфейса Python, о которой мы собираемся поговорить, - это PySide2 или вы можете назвать ее QT для python. Qt для Python предлагает официальные привязки Python для Qt (PySide2), позволяющие использовать его API-интерфейсы в приложениях Python, а также инструмент генератора привязок (Shiboken2), который можно использовать для представления проектов C ++ в Python.

Qt для Python доступен под LGPLv3 / GPLv3 и коммерческой лицензией Qt.

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

pip установить PySide2
 

Вот пример настройки кадра графического интерфейса пользователя с помощью PySide2.

из PySide2.QtWidgets импортировать QtWidgets, QApplication
import sys

Окно класса (QtWidgets):
    def __init __ (сам):
        супер () .__ init __ ()

        self.setWindowTitle ("Окно Pyside2")
        self.setGeometry (300,300,500,400)


app = QApplication (sys.argv)
window = Окно ()
window.show ()
app.exec_ ()
 

Вывод приведенного выше кода показан ниже:

Писайд2

4. Киви

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

Kivy работает на Linux, Windows, OS X, Android, iOS и Raspberry Pi. Вы можете запустить один и тот же код на всех поддерживаемых платформах.Он может использовать большинство входов, протоколов и устройств, включая WM_Touch, WM_Pen, Mac OS X Trackpad и Magic Mouse, Mtdev, Linux Kernel HID.

Kivy на 100% бесплатен по лицензии MIT.

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

Графический движок Kivy построен на OpenGL ES 2 с использованием современного и быстрого графического конвейера.

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

Приступая к установке Kivy, вам необходимо установить зависимость «glew». Вы можете использовать команду pip, как показано ниже:

pip установить документы pygments pypiwin32 kivy.deps.sdl2 kivy.deps.glew
 

Введите эту команду и нажмите Enter, она будет установлена. После этого вам нужно ввести эту команду для установки Kivy:

pip install Kivy
 

Итак, после установки позвольте мне показать вам простой пример Kivy, чтобы показать, насколько это просто.

из приложения импорта kivy.app
из kivy.uix.button import Button

класс TestApp (приложение):
    def build (самостоятельно):
        Кнопка возврата (text = "Hello Kivy World")

TestApp (). Run ()
 

Вывод приведенного выше кода показан ниже:

Киви

5. wxPython

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

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

Подобно Python и wxWidgets, wxPython имеет открытый исходный код.

wxPython - кроссплатформенный инструментарий. Это означает, что одна и та же программа будет работать на нескольких платформах без изменений. В настоящее время поддерживаемыми платформами являются Microsoft Windows, Mac OS X и macOS, а также Linux.

Теперь я собираюсь показать вам процесс установки и создать простой пример.Поэтому для установки просто введите следующую команду:

pip установить wxPython
 

Вот пример:

импорт wx

класс MyFrame (wx.Frame):
    def __init __ (я, родитель, заголовок):
        super (MyFrame, self) .__ init __ (родительский, title = title, size = (400,300))


    self.panel = MyPanel (сам)


класс MyPanel (wx.Panel):
    def __init __ (я, родитель):
        super (MyPanel, self) .__ init __ (родитель)


класс MyApp (wx.App):
    def OnInit (self):
        self.frame = MyFrame (parent = None, title = "Окно wxPython")
        себя.frame.show ()
        вернуть True

app = MyApp ()
app.MainLoop ()
 

Вывод приведенного выше кода показан ниже:

WxPython

Заключение

Итак, теперь мы увидели 5 библиотек графического интерфейса Python, и, на мой взгляд, PySide2 и pyQt5 являются более мощными фреймворками графического интерфейса. Но они поставляются с коммерческой лицензией, и это объясняет, почему они многофункциональны. Tkinter, Kivy и wxPython - это бесплатные библиотеки графического интерфейса для Python.

Какая ваша любимая библиотека графического интерфейса в Python?

Python Desktop Application: лучшая среда Python для создания настольных приложений и графического интерфейса пользователя

Python - самый популярный язык программирования, используемый для объектно-ориентированного программирования.С помощью python вы можете запускать простой оператор снова и снова без необходимости компилировать целую программу, функциональность вывода которой превосходна.

Конечно, Python - это интерактивное программирование, которое имеет широкий спектр опций для среды GUI (Graphical User Interface) (помогает разработчикам создавать приложения с графическим интерфейсом простым и безопасным способом). В этой статье обсуждается лучший фреймворк Python для создания настольных приложений и графического интерфейса.

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

Давайте углубимся в диск

PyQT

PyQt - это набор инструментов для виджетов с графическим интерфейсом пользователя. Это один из самых мощных и популярных интерфейсов Python. Это комбинация библиотеки Qt (принадлежит Nokia) и языка программирования Python, которая оставляет разработчику право решать, создавать ли программу путем кодирования или создавать визуальные диалоги с помощью Qt Designer.

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

PyQt доступен в Windows, MacOSX, Linux, Android iOS и Raspberry Pi, а также в различных версиях Python от v2 до Qt v5.

Ткинтер

Tkinter - самый популярный программный пакет для графического пользовательского интерфейса или настольных приложений. Он назван так из-за своей простоты. Tkinter - это комбинация стандартного графического интерфейса пользователя Tk и Python.

TKinter поставляется с изобилием ресурсов кодов и справочников, что является главным достоинством выбора его в качестве пакета. Он предоставляет разнообразные виджеты, такие как метки, кнопки и текстовые поля, используемые в приложении с графическим пользовательским интерфейсом. Элемент управления Button, также называемый виджетами, используется для отображения кнопок в разработанном приложении, тогда как виджет Canvas используется для рисования фигур (линий, овалов, многоугольников ...) в вашем приложении.

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

Киви

Kivy в качестве ускоренной платформы OpenGL ES 2 для создания новых пользовательских интерфейсов дает вам возможность с легкостью написать код один раз и запустить его на разных платформах или операционных системах (Windows, MacOSX, Linux, Android iOS и Raspberry Pi).

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

WxPython

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

Как разработчик, вы можете разрабатывать традиционные приложения для Windows, Unix и Mac OS.

PyGUI

PyGUI - это самый простой и легкий из всех графических интерфейсов пользователя, поскольку он полностью синхронизирован с языком программирования Python.Это кроссплатформенная среда графических приложений для Windows, Mac OS и Unix.

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

Резюме

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

.

Добавить комментарий

Ваш адрес email не будет опубликован. Обязательные поля помечены *

Theme: Overlay by Kaira Extra Text
Cape Town, South Africa