Windows gui python: Графический интерфейс на Python за 5 минут / Блог компании Edison / Хабр

Графический интерфейс на Python за 5 минут / Блог компании Edison / Хабр

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

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

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

По сути, есть 3 большие библиотеки Python для графического интерфейса; Tkinter, wxPython и PyQT. Рассматривая их, я не нашел там ничего из того, что мне нравится в Python. Библиотеки Python, как правило, очень хорошо абстрагируются от супер-технических моментов. Если бы мне нужно было работать с объектно-ориентированным программированием, я мог бы с таким же успехом загрузить Java или .Net.

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

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

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

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

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

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

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

import PySimpleGUI as sg
layout = [
    [sg.Text('File 1'), sg.InputText(), sg.FileBrowse(),
     sg.Checkbox('MD5'), sg.Checkbox('SHA1')
     ],
    [sg.Text('File 2'), sg.InputText(), sg.FileBrowse(),
     sg.Checkbox('SHA256')
     ],
    [sg.Output(size=(88, 20))],
    [sg.Submit(), sg.Cancel()]
]
window = sg.Window('File Compare', layout)
while True:                             # The Event Loop
    event, values = window.read()
    # print(event, values) #debug
    if event in (None, 'Exit', 'Cancel'):
        break

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

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

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

import PySimpleGUI as sg
import re
import hashlib
def hash(fname, algo):
    if algo == 'MD5':
        hash = hashlib.md5()
    elif algo == 'SHA1':
        hash = hashlib.sha1()
    elif algo == 'SHA256':
        hash = hashlib.sha256()
    with open(fname) as handle: #opening the file one line at a time for memory considerations
        for line in handle:
            hash.update(line.encode(encoding = 'utf-8'))
    return(hash.hexdigest())
layout = [
    [sg.Text('File 1'), sg.InputText(), sg.FileBrowse(),
     sg.Checkbox('MD5'), sg.Checkbox('SHA1')
     ],
    [sg.Text('File 2'), sg.InputText(), sg.FileBrowse(),
     sg.Checkbox('SHA256')
     ],
    [sg.Output(size=(88, 20))],
    [sg.Submit(), sg.Cancel()]
]
window = sg.Window('File Compare', layout)
while True:                             # The Event Loop
    event, values = window.read()
    # print(event, values) #debug
    if event in (None, 'Exit', 'Cancel'):
        break
    if event == 'Submit':
        file1 = file2 = isitago = None
        # print(values[0],values[3])
        if values[0] and values[3]:
            file1 = re.findall('.+:\/.+\.+.', values[0])
            file2 = re.findall('.+:\/.+\.+.', values[3])
            isitago = 1
            if not file1 and file1 is not None:
                print('Error: File 1 path not valid.')
                isitago = 0
            elif not file2 and file2 is not None:
                print('Error: File 2 path not valid.')
                isitago = 0
            elif values[1] is not True and values[2] is not True and values[4] is not True:
                print('Error: Choose at least one type of Encryption Algorithm')
            elif isitago == 1:
                print('Info: Filepaths correctly defined.')
                algos = [] #algos to compare
                if values[1] == True: algos.append('MD5')
                if values[2] == True: algos.append('SHA1')
                if values[4] == True: algos.append('SHA256')
                filepaths = [] #files
                filepaths.append(values[0])
                filepaths.append(values[3])
                print('Info: File Comparison using:', algos)
                for algo in algos:
                    print(algo, ':')
                    print(filepaths[0], ':', hash(filepaths[0], algo))
                    print(filepaths[1], ':', hash(filepaths[1], algo))
                    if hash(filepaths[0],algo) == hash(filepaths[1],algo):
                        print('Files match for ', algo)
                    else:
                        print('Files do NOT match for ', algo)
        else:
            print('Please choose 2 files.')
window.close()

Он даст нам такой результат:

Заключительные мысли

Может это и не самый красивый пользовательский интерфейс, но PySimpleGUI позволяет вам быстро разворачивать простые пользовательские интерфейсы Python и делиться ими с кем угодно. Код, который вам нужен для этого, прост и легко читается. У вас все еще будет проблема запуска кода для получения пользовательского интерфейса. Из-за этого могут возникнуть сложности с совместным использованием кода. Советую скачать что-то вроде PyInstaller, который превратит ваш скрипт на python в .exe файл. Люди смогут запустить его просто нажав на него дважды.

Создание графического интерфейса на Python 3 с Tkinter ~ PythonRu

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

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

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

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

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

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

from tkinter import *


window = Tk()
window.title("Добро пожаловать в приложение PythonRu")
window.mainloop()

Результат будет выглядеть следующим образом:

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

В случае, если вы забудете вызвать функцию mainloop , для пользователя ничего не отобразится.

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

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

lbl = Label(window, text="Привет")

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

lbl.grid(column=0, row=0)

Подписывайтесь на телеграм каналы

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

from tkinter import *  
  
  
window = Tk()  
window.title("Добро пожаловать в приложение PythonRu")  
lbl = Label(window, text="Привет")  
lbl.grid(column=0, row=0)  
window.mainloop()

И вот как будет выглядеть результат:

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

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

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

lbl = Label(window, text="Привет", font=("Arial Bold", 50))

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

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

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

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

window.geometry('400x250')

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

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

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

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

btn = Button(window, text="Не нажимать!")
btn.grid(column=1, row=0)

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

from tkinter import *  
  

window = Tk()  
window.title("Добро пожаловать в приложение PythonRu")  
window.geometry('400x250')  
lbl = Label(window, text="Привет", font=("Arial Bold", 50))  
lbl.grid(column=0, row=0)  
btn = Button(window, text="Не нажимать!")  
btn.grid(column=1, row=0)  
window.mainloop()

Результат будет следующим:

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

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

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

btn = Button(window, text="Не нажимать!", bg="black", fg="red")

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

Кнопка Click

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

def clicked():
    lbl.configure(text="Я же просил...")

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

btn = Button(window, text="Не нажимать!", command=clicked)

Обратите внимание: мы пишем clicked, а не clicked()с круглыми скобками. Теперь полный код будет выглядеть так:

from tkinter import *  
  
  
def clicked():  
    lbl.configure(text="Я же просил...")  
  
  
window = Tk()  
window.title("Добро пожаловать в приложение PythonRu")  
window.geometry('400x250')  
lbl = Label(window, text="Привет", font=("Arial Bold", 50))  
lbl.grid(column=0, row=0)  
btn = Button(window, text="Не нажимать!", command=clicked)  
btn.grid(column=1, row=0)  
window.mainloop()

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

Круто!

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

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

txt = Entry(window, width=10)

Затем вы можете добавить его в окно, используя функцию grid.
Наше окно будет выглядеть так:

from tkinter import *  
  
  
def clicked():  
    lbl.configure(text="Я же просил...")  
  
  
window = Tk()  
window.title("Добро пожаловать в приложение PythonRu")  
window.geometry('400x250')  
lbl = Label(window, text="Привет")  
lbl.grid(column=0, row=0)  
txt = Entry(window,width=10)  
txt.grid(column=1, row=0)  
btn = Button(window, text="Не нажимать!", command=clicked)  
btn.grid(column=2, row=0)  
window.mainloop()

Полученный результат будет выглядеть так:

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

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

def clicked():
    res = "Привет {}".format(txt.get())
    lbl.configure(text=res)

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

from tkinter import *  
  
  
def clicked():  
    res = "Привет {}".format(txt.get())  
    lbl.configure(text=res)  
  
  
window = Tk()  
window.title("Добро пожаловать в приложение PythonRu")  
window.geometry('400x250')  
lbl = Label(window, text="Привет")  
lbl.grid(column=0, row=0)  
txt = Entry(window,width=10)  
txt.grid(column=1, row=0)  
btn = Button(window, text="Клик!", command=clicked)  
btn.grid(column=2, row=0)  
window.mainloop()

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

Прекрасно!

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

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

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

txt.focus()

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

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

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

txt = Entry(window,width=10, state='disabled')

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

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

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

from tkinter.ttk import Combobox


combo = Combobox(window)

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

from tkinter import *  
from tkinter.ttk import Combobox  
  
  
window = Tk()  
window.title("Добро пожаловать в приложение PythonRu")  
window.geometry('400x250')  
combo = Combobox(window)  
combo['values'] = (1, 2, 3, 4, 5, "Текст")  
combo.current(1)  
combo.grid(column=0, row=0)  
window.mainloop()

Как видите с примера, мы добавляем элементы combobox, используя значения tuple.
Чтобы установить выбранный элемент, вы можете передать индекс нужного элемента текущей функции.
Чтобы получить элемент select, вы можете использовать функцию get вот таким образом:

combo.get()

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

С целью создания виджета checkbutton, используйте класс Checkbutton:

from tkinter.ttk import Checkbutton


chk = Checkbutton(window, text='Выбрать')

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

from tkinter import *  
from tkinter.ttk import Checkbutton  
  
  
window = Tk()  
window.title("Добро пожаловать в приложение PythonRu")  
window.geometry('400x250')  
chk_state = BooleanVar()  
chk_state.set(True)  
chk = Checkbutton(window, text='Выбрать', var=chk_state)  
chk.grid(column=0, row=0)  
window.mainloop()

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

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

Здесь мы создаем переменную типа BooleanVar, которая не является стандартной переменной Python, это переменная Tkinter, затем передаем ее классу Checkbutton, чтобы установить состояние чекбокса как True в приведенном выше примере.

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

chk_state = IntVar()
chk_state.set(0) 
chk_state.set(1) 

Эти примеры дают тот же результат, что и BooleanVar.

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

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

rad1 = Radiobutton(window,text='Первый', value=1)

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

from tkinter import *  
from tkinter.ttk import Radiobutton  
  
  
window = Tk()  
window.title("Добро пожаловать в приложение PythonRu")  
window.geometry('400x250')  
rad1 = Radiobutton(window, text='Первый', value=1)  
rad2 = Radiobutton(window, text='Второй', value=2)  
rad3 = Radiobutton(window, text='Третий', value=3)  
rad1.grid(column=0, row=0)  
rad2.grid(column=1, row=0)  
rad3.grid(column=2, row=0)  
window.mainloop()

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

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

rad1 = Radiobutton(window,text='Первая', value=1, command=clicked)

def clicked():
    

Достаточно легко!

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

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

from tkinter import *  
from tkinter.ttk import Radiobutton  
  
  
def clicked():  
    lbl.configure(text=selected.get())  
  
  
window = Tk()  
window.title("Добро пожаловать в приложение PythonRu")  
window.geometry('400x250')  
selected = IntVar()  
rad1 = Radiobutton(window,text='Первый', value=1, variable=selected)  
rad2 = Radiobutton(window,text='Второй', value=2, variable=selected)  
rad3 = Radiobutton(window,text='Третий', value=3, variable=selected)  
btn = Button(window, text="Клик", command=clicked)  
lbl = Label(window)  
rad1.grid(column=0, row=0)  
rad2.grid(column=1, row=0)  
rad3.grid(column=2, row=0)  
btn.grid(column=3, row=0)  
lbl.grid(column=0, row=1)  
window.mainloop()

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

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

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

from tkinter import scrolledtext


txt = scrolledtext.ScrolledText(window,width=40,height=10)

Здесь нужно указать ширину и высоту ScrolledText, иначе он заполнит все окно.

from tkinter import *  
from tkinter import scrolledtext  
  
  
window = Tk()  
window.title("Добро пожаловать в приложение PythonRu")  
window.geometry('400x250')  
txt = scrolledtext.ScrolledText(window, width=40, height=10)  
txt.grid(column=0, row=0)  
window.mainloop()

Результат:

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

Используйте метод insert, чтобы настроить содержимое Scrolledtext:

txt.insert(INSERT, 'Текстовое поле')

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

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

txt.delete(1.0, END)  

Отлично!

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

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

from tkinter import messagebox


messagebox.showinfo('Заголовок', 'Текст')

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

from tkinter import *  
from tkinter import messagebox  
  
  
def clicked():  
    messagebox.showinfo('Заголовок', 'Текст')  
  
  
window = Tk()  
window.title("Добро пожаловать в приложение PythonRu")  
window.geometry('400x250')  
btn = Button(window, text='Клик', command=clicked)  
btn.grid(column=0, row=0)  
window.mainloop()

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

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

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

messagebox.showwarning('Заголовок', 'Текст')  
messagebox.showerror('Заголовок', 'Текст')  

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

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

from tkinter import messagebox


res = messagebox.askquestion('Заголовок', 'Текст')
res = messagebox.askyesno('Заголовок', 'Текст')
res = messagebox.askyesnocancel('Заголовок', 'Текст')
res = messagebox.askokcancel('Заголовок', 'Текст')
res = messagebox.askretrycancel('Заголовок', 'Текст')

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

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

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

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

spin = Spinbox(window, from_=0, to=100)

Таким образом, мы создаем виджет Spinbox, и передаем параметры from и to, чтобы указать диапазон номеров.
Кроме того, вы можете указать ширину виджета с помощью параметра width:

spin = Spinbox(window, from_=0, to=100, width=5)

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

from tkinter import *  
  
  
window = Tk()  
window.title("Добро пожаловать в приложение PythonRu")  
window.geometry('400x250')  
spin = Spinbox(window, from_=0, to=100, width=5)  
spin.grid(column=0, row=0)  
window.mainloop()

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

spin = Spinbox(window, values=(3, 8, 11), width=5)

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

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

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

var = IntVar()
var.set(36)
spin = Spinbox(window, from_=0, to=100, width=5, textvariable=var)

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

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

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

from tkinter.ttk import Progressbar


bar = Progressbar(window, length=200)

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

bar['value'] = 70

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

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

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

from tkinter import *  
from tkinter.ttk import Progressbar  
from tkinter import ttk  
  
  
window = Tk()  
window.title("Добро пожаловать в приложение PythonRu")  
window.geometry('400x250')  
style = ttk.Style()  
style.theme_use('default')  
style.configure("black.Horizontal.TProgressbar", background='black')  
bar = Progressbar(window, length=200,)  
bar['value'] = 70  
bar.grid(column=0, row=0)  
window.mainloop()

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

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

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

from tkinter import filedialog


file = filedialog.askopenfilename()

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

files = filedialog.askopenfilenames()

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

Возможность указания типа файлов доступна при использовании параметра filetypes, однако при этом важно указать расширение в tuples.

file = filedialog.askopenfilename(filetypes = (("Text files","*.txt"),("all files","*.*")))

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

dir = filedialog.askdirectory()

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

from os import path
file = filedialog.askopenfilename(initialdir= path.dirname(__file__))

Легко!

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

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

from tkinter import Menu


menu = Menu(window)
menu.add_command(label='Файл')
window.config(menu=menu)

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

menu.add_cascade(label='Автор', menu=new_item)

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

from tkinter import *  
from tkinter import Menu  
  
  
window = Tk()  
window.title("Добро пожаловать в приложение PythonRu")  
window.geometry('400x250')  
menu = Menu(window)  
new_item = Menu(menu)  
new_item.add_command(label='Новый')  
menu.add_cascade(label='Файл', menu=new_item)  
window.config(menu=menu)  
window.mainloop()

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

from tkinter import *  
  
  
window = Tk()  
window.title("Добро пожаловать в приложение PythonRu")  
window.geometry('400x250')  
menu = Menu(window)  
new_item = Menu(menu)  
new_item.add_command(label='Новый')  
new_item.add_separator()  
new_item.add_command(label='Изменить')  
menu.add_cascade(label='Файл', menu=new_item)  
window.config(menu=menu)  
window.mainloop()

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

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

new_item = Menu(menu, tearoff=0)

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

new_item.add_command(label='Новый', command=clicked)

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

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

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

from tkinter import *  
from tkinter import ttk  
  
  
window = Tk()  
window.title("Добро пожаловать в приложение PythonRu")  
window.geometry('400x250')  
tab_control = ttk.Notebook(window)  
tab1 = ttk.Frame(tab_control)  
tab_control.add(tab1, text='Первая')  
tab_control.pack(expand=1, fill='both')  
window.mainloop()

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

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

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

from tkinter import *  
from tkinter import ttk  
  
  
window = Tk()  
window.title("Добро пожаловать в приложение PythonRu")  
window.geometry('400x250')  
tab_control = ttk.Notebook(window)  
tab1 = ttk.Frame(tab_control)  
tab2 = ttk.Frame(tab_control)  
tab_control.add(tab1, text='Первая')  
tab_control.add(tab2, text='Вторая')  
lbl1 = Label(tab1, text='Вкладка 1')  
lbl1.grid(column=0, row=0)  
lbl2 = Label(tab2, text='Вкладка 2')  
lbl2.grid(column=0, row=0)  
tab_control.pack(expand=1, fill='both')  
window.mainloop()

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

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

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

lbl1 = Label(tab1, text= 'label1', padx=5, pady=5)

Это очень просто!

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

13 GUI-библиотек Python | Techrocks

Перевод статьи markdrozdov “13 Python GUI Libraries”.

Python

Python это высокоуровневый язык программирования, он используется как язык общего назначения. Этот язык был создан Гвидо ван Россумом и впервые выпущен в 1991 году. Философия проектирования Python фокусируется на читаемости кода. Для этой цели в языке используется значительное количество пробелов.

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

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

• объектно-ориентированную;
• императивную;
• функциональную;
• процедурную.

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

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

Он использует окна, значки, меню. Манипулировать GUI можно как с помощью мышки, так и с помощью клавиатуры.

GUI-библиотека

GUI-библиотека содержит виджеты. Виджеты это наборы графических элементов управления.

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

Python GUI

Когда вы пишете приложение с помощью Python, вам для этого понадобится использовать GUI.

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

1. Tkinter

Tkinter это набор инструментов, который может формировать GUI с помощью Python. Он позволяет вам запускать сценарии на Python в GUI-формате. Ссылка ведет на страницу с руководством по Tkinter.

2. Flexx

Многие GUI-библиотеки Python основаны на библиотеках, написанных на других языках, таких как C ++. Например, wxWidgets и libavg. Flexx создана на Python. Для отображения GUI использует веб-технологию.

3. CEF Python

Этот фреймворк нацелен на Windows, MAC OS и Linux. Основан на Google Chromium. Основное внимание в нем уделяется облегчению использования встроенного браузера в сторонних приложениях.

4. Dabo

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

5. Kivy

Kivy основан на OpenGL ES 2. У него есть собственный multi-touch для каждой отдельной платформы. Это событийно-ориентированный фреймворк, который прекрасно подходит для разработки игр.

6. Pyforms

Pyforms это фреймворк Python 2.7/3.x для разных окружений, используемый для разработки GUI приложения. В нем поощряется повторное использование кода.

7. PyGObject

С помощью PyGObject вы можете писать на Python приложения для проекта GNOME. Также можно писать приложения на Python, использующие GTK+.

8. PyQt

Qt это кросс-платформенный фреймворк. Он написан на С++. Это очень полная библиотека, включающая много инструментов и API. Широко используется во многих отраслях. Охватывает множество платформ.

9. PySide

Обёртка для Qt. PySide и PyQt отличаются тем, что последний является коммерчески доступным.

10. PyGUI

PyGUI предназначен для платформ Unix, Macintosh и Windows. Фокус этого MVC-фреймворка заключается в том, чтобы вписываться в экосистему Python с максимальной легкостью.

11. libavg

Это сторонняя библиотека, написанная на С++. Обладает следующими особенностями:

• показ элементов в форме переменных Python;
• система управления событиями;
• таймеры;
• поддержка логов.

12. PyGTK | PyGObject

«GTK+», широко используемая в Linux, является «GTK + «обёртка из» PyGTK». По сравнению с Kivy и PyQt, PyGTK очень легок для платформ Unix, Macintosh, Windows.

Этот MVC-фреймворк разработан Грегом Эвингом из университета Кентербери (Новая Зеландия). Его главный фокус – как можно более простая адаптация к экосистеме Python.

13. wxPython

Обертка кросс-платформенного GUI для Python на основе wxWidgets. Написана на С++.

Заключение

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

Обзор Python GUI библиотек — 5 популярных и бесплатных ~ PythonRu

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

Что такое GUI?

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

GUI-фреймворки легко доступны — они бесплатны и имеют открытый исходный код. В Python есть широкий спектр вариантов: от кроссплатформенных до заточенных под конкретную платформу.

Kyvi

Kyvi — это бесплатная библиотека Python с открытым исходным кодом. Она используется для разработки мобильных приложений и других приложений широкого назначения с естественным пользовательским интерфейсом. Распространяется по лицензии MIT и может работать на:

• Android,
• iOS,
• GNU/Linux,
• macOS,
• Windows.

PyQT

PyQT — одна из самых любимых кроссплатформенных Python-библиотек, реализующих библиотеку Qt (принадлежит Nokia) из одноименного фреймворка для разработки приложений. Сейчас PyQT доступна на Unix/Linux, Windows, macOS и Sharp Zaurus. Она объединяет лучшее из Python и Qt. И только разработчик решает, как создавать программу: с помощью кода или Qt Designer для дизайна визуальных элементов.

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

Tkinter

Tkinter — связка Python с набором GUI-инструментов Tk. Это стандартный интерфейс-Python. Он доступен на Linux, Windows и macOS с установленными Python. Имя Tkinter происходит от Tk interface.

PySide

PySide — это библиотека с открытым исходным кодом, которая также предлагается связь с Qt. Qt – это кроссплатформенные приложение и UI-фреймворк, которые позволяют разработчикам писать и разворачивать приложения на разных ОС без переписывания исходного кода.

Подписывайтесь на телеграм каналы

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

WxPython

WxPython — это смесь из библиотеки классов WxWidgets (ранее — WxWindows) для C++ и Python. Ее можно найти здесь: https://www.wxpython.org/. А вот ее Wiki: https://wiki.wxpython.org/.

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

как подружиться 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» и других).

Собираем проект на python3&PyQT5 под Windows, используя PyInstaller / Хабр

Причиной написания статьи, явилось огромное количество постоянно возникающих у новичков вопросов такого содержания: «Как собрать проект c pyqt5», «Почему не работает», «Какой инструмент выбрать» и т.д. Сегодня научимся собирать проекты без мучений и танцев с бубном.

Как-то пришлось написать небольшое desktop-приложение. В качестве языка программирования для разработки был выбран python, поскольку для решения моей задачи он подходил идеально. В стандартную библиотеку Python уже входит библиотека tkinter, позволяющая создавать GUI. Но проблема tkinter в том, что данной библиотеке посвящено мало внимания, и найти в интернете курс, книгу или FAQ по ней довольно-таки сложно. Поэтому было решено использовать более мощную, современную и функциональную библиотеку Qt, которая имеет привязки к языку программирования python в виде библиотеки PyQT5. Более подробно про PyQT можете почитать здесь. В качестве примера я буду использовать код:

#!/usr/bin/python3
# -*- coding: utf-8 -*-

import sys
from PyQt5.QtWidgets import QApplication, QWidget
from PyQt5.QtGui import QIcon

class Example(QWidget):

    def __init__(self):
        super().__init__()

        self.initUI()

    def initUI(self):

        self.setGeometry(300, 300, 300, 220)
        self.setWindowTitle('Icon')
        self.setWindowIcon(QIcon('web.png'))

        self.show()

if __name__ == '__main__':

    app = QApplication(sys.argv)
    ex = Example()
    sys.exit(app.exec_())

Если вы более-менее опытный разработчик, то понимаете, что без интерпретатора код на python не запустить. А хотелось бы дать возможность каждому пользователю использовать программу. Вот здесь к нам на помощь и приходят специальные библиотеки позволяющие собирать проекты в .exe, которые можно потом без проблем запустить, как обычное приложение.

Существует большое количество библиотек, позволяющих это сделать, среди которых самые популярные: cx_Freeze, py2exe, nuitka, PyInstaller и др. Про каждую написано довольно много. Но надо сказать, что многие из этих решений позволяют запускать код только на компьютере, с предустановленным интерпретатором и pyqt5. Не думаю, что пользователь будет заморачиваться и ставить себе дополнительные пакеты и программы. Надеюсь, вы понимаете, что запуск программы на dev-среде и у пользователя это не одно и тоже. Также нужно отметить, что у каждого решения были свои проблемы: один не запускался, другой собирал то, что не смог потом запустить, третий вообще отказывался что-либо делать.

После долгих танцев с бубном и активным гуглением, мне все же удалось собрать проект с помощью pyinstaller, в полностью работоспособное приложение.

Немного о Pyinstaller

Pyinstaller собирает python-приложение и все зависимости в один пакет. Пользователь может запускать приложение без установки интерпретатора python или каких-либо модулей. Pyinstaller поддерживает python 2.7 и python 3.3+ и такие библиотеки как: numpy, PyQt, Django, wxPython и другие.

Pyinstaller тестировался на Windows, Mac OS X и Linux. Как бы там ни было, это не кросс-платформенный компилятор: чтобы сделать приложение под Windows, делай это на Windows; Чтобы сделать приложение под Linux, делай это на Linux и т.д.

PyInstaller успешно используется с AIX, Solaris и FreeBSD, но тестирование не проводилось.

Подробнее о PyInstaller можно почитать здесь: документация.

К тому же после сборки приложение весило всего около 15 мб. Это к слову и является преимуществом pyinstaller, поскольку он не собирает все подряд, а только необходимое. Аналогичные же библиотеки выдавали результат за 200-300 мб.

Приступаем к сборке

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

pip install pypiwin32
pip install pyinstaller

Чтобы убедится, что все нормально установилось, вводим команду:

pyinstaller --version

должна высветиться версия pyinstaller. Если все правильно установилось, идем дальше.

В папке с проектом запускаем cmd и набираем:

 pyinstaller myscript.py

Собственно это и есть простейшая команда, которая соберет наш проект.

Синтаксис команды pyinstaller таков:

pyinstaller [options] script [script …] | specfile

Наиболее часто используемые опции:

—onefile — сборка в один файл, т.е. файлы .dll не пишутся.

—windowed -при запуске приложения, будет появляться консоль.

—noconsole — при запуске приложения, консоль появляться не будет.

—icon=app.ico — добавляем иконку в окно.

—paths — возможность вручную прописать путь к необходимым файлам, если pyinstaller

не может их найти(например: —paths D:\python35\Lib\site-packages\PyQt5\Qt\bin)

PyInstaller анализирует файл myscript.py и делает следующее:

1. Пишет файл myscript.spec в той же папке, где находится скрипт.
2. Создает папку build в той же папке, где находится скрипт.
3. Записывает некоторые логи и рабочие файлы в папку build.
4. Создает папку dist в той же папке, где находится скрипт.
5. Пишет исполняемый файл в папку dist.

В итоге наша команда будет выглядеть так:

pyinstaller --onefile --icon=name.ico --noconsole myscript.py

После работы программы вы найдете две папки: dist и build. Собственно в папке dist и находится наше приложение. Впоследствии папку build можно спокойно удалить, она не влияет на работоспособность приложения.

Спасибо за внимание. Надеюсь статья была вам полезна.

функционал, версии, установка и особенности работы

От автора: что такое PyQt? PyQt — это привязка Python с открытым исходным кодом для виджет-инструментария Qt, который также функционирует как кросс-платформенная среда разработки приложений. Qt — это популярная среда C ++ для написания приложений с помощью графического интерфейса для всех основных настольных, мобильных и встраиваемых платформ (поддерживает Linux, Windows, MacOS, Android, iOS, Raspberry Pi и многие другие).

PyQt разрабатывается и поддерживается Riverbank Computing, компанией, базирующейся в Англии, а Qt — финской фирмой The Qt Company.

В этом руководстве по PyQT мы рассмотрим:

Что такое PyQt?

Функции PyQT

Бесплатный курс «Python. Быстрый старт»

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

Получить курс

Версии PyQt

Как установить PyQt

Основные понятия и программы PyQt

Компоненты и виджеты

Темы

Функци PyQT

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

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

Базы данных SQL

Веб-инструментарий

Обработка XML

Сети

Эти функции можно комбинировать для создания расширенных пользовательских интерфейсов, а также автономных приложений. Многие крупные компании из различных отраслей используют PyQt: LG, Mercedes, AMD, Panasonic, Harman и т. д.

Версии PyQt

PyQt доступен в двух редакциях: PyQt4 и PyQt5. PyQt4 предоставляет связующий код для привязки версий Qx 4.x и 5.x, в то время как PyQt5 обеспечивает привязку только для версий 5.x. В результате PyQt5 не имеет обратной совместимости с устаревшими модулями более ранней версии. В этом руководстве будет использоваться для демонстрации примеров PyQt5. Помимо этих двух версий, Riverbank Computing также предоставляет PyQt3D — привязки python для инфраструктуры Qt3D. Qt3D — это прикладная среда, используемая для создания систем моделирования в реальном времени с 2D / 3D рендерингом.

Как установить PyQt

Есть два способа установки PyQt.

Использование файлов Wheel

Сборка и установка из исходного кода

Qt (произносится «кьют») — сложная система, а база кода PyQt содержит скомпилированный код C ++ и Python. В результате по сравнению с другими библиотеками Python это сложный процесс для сборки и установки из исходного кода. Тем не менее, вы можете легко установить PyQt5 с помощью Wheel.

Установка с помощью Wheel

Wheel — это новый стандартный формат упаковки и распространения Python. Проще говоря, Wheel — это ZIP-архив со специальным названием и расширение файла. Wheel можно установить с помощью pip (менеджер пакетов Python), который включен по умолчанию в последние версии Python.

Итак, если у вас установлен Python 3.4 или более поздней версии, у вас уже есть pip. Однако, если вы используете более старую версию Python, вам нужно скачать и установить pip, прежде продолжать. Вы можете найти инструкции по установке по этой ссылке: https://pypi.org/project/pip/.

Чтобы установить PyQt5:

Шаг 1) Откройте командную строку или PowerShell на компьютере с Windows.

Шаг 2) Введите следующее:

Этот шаг загрузит пакет PyQt5 whl (около 50 МБ) и установит его в вашей системе.

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

Основные понятия и программы PyQt

Теперь, когда вы успешно установили PyQt5 на компьютер, вы готовы писать приложения на python с помощью графического интерфейса. Давайте начнем с простого приложения, которое будет отображать пустое окно на экране. Запустите Python IDLE и введите следующее:

import sys
from PyQt5.QtWidgets import QApplication, QWidget
if __name__ == «__main__»:
app = QApplication(sys.argv)
w = QWidget()
w.resize(300,300)
w.setWindowTitle(‘Guru99’)
w.show()
sys.exit(app.exec_())

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

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

from PyQt5.QtWidgets import QApplication, QWidget

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

app = QApplication(sys.argv)

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

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

В этом примере вы не передали аргументы QApplications. Следовательно, вы также можете заменить его приведенным ниже кодом и даже не импортировать модуль sys.

app = QApplication([])
w = QWidget()

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

Метод resize класса QWidget позволяет устанавливать размеры любого виджета. В этом случае вы изменили размер окна на 300 * 300 пикселей. Здесь вы должны помнить, что виджеты могут быть вложены вместе, внешний виджет (т. е. виджет без родителя) называется окном.

w.setWindowTitle(‘Guru99’)

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

show() просто отображает виджет на экране монитора.

Метод app.exec_() запускает цикл событий Qt / C ++. Как вы знаете, PyQt в основном написан на C ++ и использует механизм цикла событий для реализации параллельного выполнения. app.exec_() передает управление Qt, который выходит из приложения только тогда, когда пользователь закроет его графический интерфейс. Вот почему Ctrl + C не выполняет выход из приложения, как в других программах Python. Поскольку Qt контролирует приложение, события Python не обрабатываются, пока мы не настроим их внутри приложения. Также обратите внимание, что у метода exec есть подчеркивание в имени; это потому, что exec() уже является ключевым словом в python, а подчеркивание разрешает конфликт имен.

Заполнение окон

В предыдущем разделе мы рассмотрели, как в Qt создать базовый виджет. Теперь пришло время сделать несколько более сложных интерфейсов, с которыми пользователи могут по-настоящему взаимодействовать. Снова, запустите IDLE и напишите следующее.

import sys
from PyQt5.QtWidgets import QApplication, QWidget, QLabel, QPushButton, QMessageBox

def dialog():
mbox = QMessageBox()

mbox.setText(«Your allegiance has been noted»)
mbox.setDetailedText(«You are now a disciple and subject of the all-knowing Guru»)
mbox.setStandardButtons(QMessageBox.Ok | QMessageBox.Cancel)

mbox.exec_()

if __name__ == «__main__»:
app = QApplication(sys.argv)
w = QWidget()
w.resize(300,300)
w.setWindowTitle(‘Guru99’)

label = QLabel(w)
label.setText(«Behold the Guru, Guru99»)
label.move(100,130)
label.show()

btn = QPushButton(w)
btn.setText(‘Beheld’)
btn.move(110,150)
btn.show()
btn.clicked.connect(dialog)

w.show()
sys.exit(app.exec_())

Сохраните файл как appone.py или как угодно и нажмите F5, чтобы запустить программу. Если вы не допустили ошибок, IDLE откроет новое окно с текстом и кнопкой, как показано ниже.

Как только вы нажмете кнопку в первом окне, откроется новое окно сообщения с текстом, который вы написали. Теперь вы можете нажать кнопку Hide Details/Show Details, чтобы переключить видимость дополнительного текста.

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

from PyQt5.QtWidgets import QApplication, QWidget, QLabel, QPushButton, QMessageBox

Это импортирует еще несколько виджетов, которые вы использовали в этом примере, а именно QLabel, QPushButton и QMessageBox.

def dialog():
mbox = QMessageBox()

mbox.setText(«Your allegiance has been noted»)
mbox.setDetailedText(«You are now a disciple and subject of the all-knowing Guru»)
mbox.setStandardButtons(QMessageBox.Ok | QMessageBox.Cancel)

mbox.exec_()

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

Метод dialog вызывается из основного блока программы, когда кнопка нажимается в определенном виджете (в данном случае, btn PushButton). Событие клика, запущенное этой кнопкой, вызывает выполнение этой функции. Такая функция называется в Qt слотом, вы узнаете больше о сигналах и слотах в следующих разделах.

if __name__ == «__main__»:
app = QApplication(sys.argv)
w = QWidget()
w.resize(300,300)
w.setWindowTitle(‘Guru99’)

Это основной раздел приложения, и, как и в предыдущем примере, вы начинаете с создания экземпляра QApplication, за которым следует простой виджет, это экземпляр QWidget.

label = QLabel(w)
btn = QPushButton(w)

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

Здесь важно заметить, что при создании объектов label и btn вы передаете объект окна (w) конструкторам QLabel и QPushButton. Вот как работает вложение в PyQt5. Чтобы создать виджет внутри другого виджета, вы передаете ссылку на родительский виджет в конструктор дочернего элемента.

label.move(100,130)
btn.move(110,150)

move() используется для установки позиции виджета относительно его родительского виджета. В первом случае метка будет перемещена на 100 пикселей с левой стороны и на 130 пикселей сверху окна.

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

btn.clicked.connect(dialog)

Наконец, это пример сигналов и слотов в Qt. В приложениях на основе графического интерфейса функции выполняются на основе действий, запускаемых пользователем, таких как наведение на элемент или нажатие кнопки. Эти действия называются событиями. Напомним, что метод app.exec_() передает управление в цикл обработки событий Qt. Для этого и предназначен цикл событий: прослушивать события и выполнять в ответ действия.

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

widget.signal.connect(slot)

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

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

Компоненты и виджеты

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

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

Структура каталогов PyQt5

Бесплатный курс «Python. Быстрый старт»

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

Получить курс

Это фундаментальные модули, используемые связыванием Qt в Python, в частности в PyQt5.

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

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

QtWidgets: Содержит большинство виджетов, доступных в Pyqt5.

QtGui: Содержит компоненты графического интерфейса и расширяет модуль QtCore.

QtNetwork: Содержит классы, используемые для реализации сетевого программирования через Qt. Он поддерживает TCP-серверы, TCP-сокеты, UDP-сокеты, обработку SSL, сетевых сеансов и поиск DNS.

QtMultimedia: Предоставляет низкоуровневый мультимедийный функционал.

QtSql: реализует интеграцию базы данных для баз данных SQL. Поддерживает ODBC, MySQL, Oracle, SQLite и PostgreSQL.

Виджеты PyQt5

Вот список наиболее часто используемых виджетов PyQt5:

QLineEdit: Это поле ввода, которое позволяет пользователю вводить одну строку текста.

QRadioButton: Это поле ввода с выбираемой кнопкой, аналогичное переключателям в html.

rad = QRadioButton(«button title»)
rad.setChecked(True) #to select the button by default.

QComboBox: Используется для отображения выпадающего меню со списком выбираемых элементов.

drop = QComboBox(w)
drop.addItems([«item one», «item two», «item three»])

QCheckBox: Отображает выбираемое квадратное поле перед меткой, которая отмечена, если выбрана, аналогично переключателям.

check = QCheckBox(«button title»)

QMenuBar: Отображает горизонтальную строку меню в верхней части окна. Вы можете добавить в эту панель только объекты класса QMenu. Эти объекты QMenu могут дополнительно содержать строки, объекты QAction или другие объекты QMenu.

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

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

QScrollBar: Используется для создания полос прокрутки, которые позволяют пользователю прокручивать вверх и вниз в пределах окна. Он состоит из подвижного ползунка, дорожки ползунка и двух кнопок для прокрутки ползунка вверх или вниз.

QSplitter: Разделители используются для разделения содержимого окна, чтобы виджеты были сгруппированы правильно и не выглядели нагроможденными. QSplitter является одним из основных обработчиков макетов, доступных в PyQt5, и используется для разделения содержимого как по горизонтали, так и по вертикали.

QDock: виджет-док — это подокно с двумя свойствами: оно может быть перемещено в главное окно и его можно закрепить за пределами родительского окна в другом месте на экране.

Макеты и темы

В предыдущих примерах мы использовали только методы move() и resize() для установки позиций виджетов в графическом интерфейсе.

Тем не менее, PyQt имеет мощный механизм управления компоновкой, который можно использовать для создания расширенных пользовательских интерфейсов приложений. В этом разделе вы узнаете о двух важных классах, которые используются в Qt для создания и управления макетами: QBoxLayout и QGridLayout.

QBoxLayout

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

QHBoxLayout: используется для выравнивания дочерних виджетов по горизонтали.

QVBoxLayout: используется для выравнивания дочерних виджетов по вертикали.

Например, так будут выглядеть три кнопки, выровненные по QHBoxLayout.

import sys
from PyQt5.QtWidgets import *

if __name__ == «__main__»:

app = QApplication([])
w = QWidget()
w.setWindowTitle(«Musketeers»)

btn1 = QPushButton(«Athos»)
btn2 = QPushButton(«Porthos»)
btn3 = QPushButton(«Aramis»)

hbox = QHBoxLayout(w)

hbox.addWidget(btn1)
hbox.addWidget(btn2)
hbox.addWidget(btn3)

w.show()

sys.exit(app.exec_())

А вот как они будут выглядеть в QVBoxLayout.

import sys
from PyQt5.QtWidgets import *

if __name__ == «__main__»:

app = QApplication([])
w = QWidget()
w.setWindowTitle(«Musketeers»)

btn1 = QPushButton(«Athos»)
btn2 = QPushButton(«Porthos»)
btn3 = QPushButton(«Aramis»)

vb = QVBoxLayout(w)

vb.addWidget(btn1)
vb.addWidget(btn2)
vb.addWidget(btn3)

w.show()

sys.exit(app.exec_())

Единственная функция, которая нуждается в каком-либо объяснении на данный момент, это метод addWidget(). Он используется для вставки виджетов в макет HBox или VBox. Он также используется в других макетах, где принимает другое количество параметров, как вы увидите в следующем разделе. Виджеты отображаются внутри макета в том порядке, в котором вы их вставляете.

QGridLayout

QGridLayout используется для создания интерфейсов, в которых виджеты расположены в виде сетки (например, матрицы или 2D-массива). Чтобы вставить элементы в сетку, вы можете использовать матричное представление, чтобы определить количество строк и столбцов в сетке, а также положение этих элементов.

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

import sys
from PyQt5.QtWidgets import *

if __name__ == «__main__»:
app = QApplication([])

w = QWidget()

grid = QGridLayout(w)

for i in range(3):
for j in range(3):
grid.addWidget(QPushButton(«Button»),i,j)


w.show()
sys.exit(app.exec_())

Вывод будет следующий:

Метод addWidget() в макете сетки принимает следующие аргументы:

Объект виджета, который вы хотите добавить в сетку

X-координата объекта

Y-координата объекта

Диапазон строк (по умолчанию = 0)

Col-span (по умолчанию = 0)

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

import sys
from PyQt5.QtWidgets import *

if __name__ == «__main__»:
app = QApplication([])

w = QWidget()

grid = QGridLayout(w)
grid.addWidget(QPushButton(«Button one»),0,0)
grid.addWidget(QPushButton(«Button two»),0,1)
grid.addWidget(QPushButton(«Button three»),1,0)
grid.addWidget(QPushButton(«Button four»),1,1)


w.show()
sys.exit(app.exec_())

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

Вы также можете передать параметры rowspan и colspan в addWidget(), чтобы охватить более одной строки или столбца.

grid.addWidget(QPushButton(«Button five»),2,0,1,0)

Это создаст кнопку, которая растягивается на оба столбца.

Темы

PyQt5 поставляется с некоторыми встроенными темами, которые вы можете использовать в приложениях. Метод setStyle(), вызываемый в экземпляре QApplication, используется для установки определенной темы для вашего приложения. Например, добавление следующей строки кода изменит тему приложения по умолчанию на Fusion:

Так будет выглядеть предыдущий пример в теме Fusion.

Еще одна полезная функция для создания тем приложений — это метод setPalette(). Вот код для изменения цвета различных виджетов с помощью setPalette().

import sys
from PyQt5.QtCore import Qt
from PyQt5.QtWidgets import *
from PyQt5.QtGui import QPalette

if __name__ == «__main__»:
app = QApplication([])
app.setStyle(«Fusion»)

qp = QPalette()
qp.setColor(QPalette.ButtonText, Qt.black)
qp.setColor(QPalette.Window, Qt.black)
qp.setColor(QPalette.Button, Qt.gray)
app.setPalette(qp)

w = QWidget()

grid = QGridLayout(w)
grid.addWidget(QPushButton(«Button one»),0,0)
grid.addWidget(QPushButton(«Button two»),0,1)
grid.addWidget(QPushButton(«Button three»),1,0)
grid.addWidget(QPushButton(«Button four»),1,1)


w.show()
sys.exit(app.exec_())

Вот результат:

Чтобы использовать метод setPalette(), сначала нужно определить палитру. Это делается путем создания объекта класса QPalette.

Обратите внимание, что класс QPalette принадлежит модулю QtGui, и вам нужно будет импортировать его, чтобы это работало. Создав объект QPalette, используйте метод setColor(), чтобы передать имя виджета, цвет которого вы хотите изменить, и цвет, который вы хотите установить.

qp.setColor(QPalette.Window, Qt.black)

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

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

Заключение

PyQt — это привязка Python для инфраструктуры пользовательского интерфейса C ++, Qt.

PyQt4 и PyQt5 — две основные версии, разработанные Riverbank Computing.

Основными модулями платформы PyQt являются: Qt, QtCore, QtWidgets, QtGui, QtSql, QtNetwork

PyQt поддерживает различные виджеты, такие как: Кнопки, Текстовые метки, Текстовые поля, Переключатели и чек-боксы, Панели инструментов и строки меню, Webkit, Вкладки, Доки

В PyQt интерактивность реализована с использованием сигналов и слотов.

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

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

Слот является функцией, которая подключается к сигналу и выполняет при повышении сигнала.

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

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

PyQt может использоваться для создания пользовательских интерфейсов, а также автономных приложений.

Источник: https://www.guru99.com

Редакция: Команда webformyself.

Бесплатный курс «Python. Быстрый старт»

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

Получить курс

Best Python GUI Framework | Наборы инструментов 2020 [Ultimate Guide]

Python — один из широко используемых языков программирования. Согласно опросу, доступно около 4,3 миллиона разработчиков Python. Кроме того, он имеет широкий спектр приложений от веб-разработки до графических пользовательских интерфейсов (GUI) для настольных ПК. Python GUI Framework побуждает нас узнать больше о программировании на Python.

«Создать лучший графический интерфейс Python при программировании на Python сложно, но возможно». На данный момент мы включили 10 лучших фреймворков для графического интерфейса пользователя Python | набор инструментов: Tkinter, Kivy, PyQT, WxPython, Libavg, PySide, PyGUI, Pyforms, Wax Python GUI.Все эти графические интерфейсы на Python используются во многих приложениях, таких как анимация, 3D и т. Д. Некоторые люди сжимают с помощью Python и Java, потому что не знают, что на самом деле находится в Python и java. Так что прочтите эту статью, чтобы прояснить все недоразумения относительно Python против Java.

Например; компьютеры, веб-сайты, мобильные приложения — это живые экземпляры приложений на языке программирования.

Во-первых, давайте разберемся, что такое графический интерфейс?

Что такое графический интерфейс пользователя (GUI)

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

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

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

Python помогает программистам решить эту проблему. Он имеет различные варианты графических интерфейсов для разработчиков. Давайте перейдем к более интересной части — фреймворкам Python GUI.

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

Топ-10 Python GUI Framework в 2019 году

Создание пользовательского интерфейса Python для любого приложения — отличная и интересная задача.Чтобы продолжить создание графического интерфейса Python, вам понадобятся инструменты. У Python есть множество инструментов, или вы можете сказать, что фреймворки графического интерфейса Python, которые используются для создания пользовательского интерфейса для мобильных приложений, веб-приложений и настольных приложений. Здесь у нас есть список из 10 лучших инструментов GUI | фреймворка для Python, который используют разработчики программного обеспечения —

1. Tkinter GUI
2. PyQT GUI
3. KIVY GUI
4. WxPython GUI
5. PySide GUI
6. PySimpleGUI
7. PyGUI
8. Pyforms GUI
9. Восковый графический интерфейс Python
10.Libavg

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

1. Tkinter GUI

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

Преимущество Tk в том, что он включен в стандартную библиотеку Python.Благодаря этому вам не нужно его устанавливать, Tk всегда является удобным и совместимым набором инструментов для работы разработчиков. Создать графический интерфейс через Tkinter не так уж и сложно. Tkinter используется в качестве дизайна с библиотеками Framework в Data Science и Python.

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

Создайте графический интерфейс Tkinter, следуя шагу

1. Для начала сначала Импортируйте модуль — Tkinter
2. Создайте главное окно, которое выполняется двумя способами.
3. Когда будет создано главное окно, добавьте в него несколько виджетов.
4. Реализуйте триггер функции для виджетов.

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

Давайте обсудим их по очереди.

Метод № 1

Tkinter предлагает метод для создания главного окна. Этот метод выглядит следующим образом:

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

Теперь мы переходим ко второму методу

Method # 2

Имя метода — mainloop (). Метод используется, когда вы готовы запустить приложение. Mainloop () содержит бесконечный цикл, запускающий приложение. Код для mainloop () —

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

1. pack () Метод — упорядочивает виджеты в блоках перед размещением их в родительском виджете.
2. grid () Метод — установка виджета в виде таблицы, называемой сеткой на основном виджете.
3. Метод place (): Устанавливает виджет с определенным позиционированием, указанным программой.

Итак, теперь вы можете добавить несколько виджетов, которые вы можете поместить в свое приложение Tkinter, некоторые из примеров с синтаксисом приведены ниже —

Здесь мастер используется для родительского окна

Это все в рамках графического интерфейса Tkinter.Следующий пример в лучшем графическом интерфейсе Python — PyQT.

2. PyQT GUI

PyQt — это Python UI-фреймворк для Qt, одного из популярных приложений кроссплатформенного GUI-фреймворка, написанного на языке C ++ и принадлежащего Nokia. Это привязка Qt, разработанная Riverbank Computing Limited. PyQT поддерживает Windows, OS X, Linux, iOS и Android. PyQT имеет две редакции, одна — PyQT4, построенная против QT 4.x. Другой — PyQT5, построенный против QT 5.x. Однако в основном он используется для настольных приложений.

Обе версии совместимы с Python 2 и 3. Лицензия на нее распространяется под лицензией GPL версии 3. Вы можете попробовать бесплатную версию, но некоторые функции в ней недоступны. Более того, если приложение, над которым вы работаете, имеет открытый исходный код, вы будете использовать PyQT с бесплатной лицензией. PyQT сочетает в себе лучшее из QT и Python и зарекомендовал себя как графический интерфейс пользователя. Иногда это нечто большее, чем набор инструментов Python GUI.

Теперь мы дадим вам обзор создания приложения PyQT python GUI.Он выполняет определенные шаги, давайте посмотрим на шаг.

Первым шагом является установка PyQT 5 в вашей системе —

Установка PYQT5: В Windows:

Используйте приведенный ниже код для установки PyQT в вашей системе Windows

Установите PyQT: В Linux

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

Для запуска процесса. откройте «Окно Qt Designer Window», затем выберите «Главное» окно и нажмите «Создать». Перетащите края и установите желаемый размер окна.

Теперь мы подошли к макету окна регистрации. Для этого создайте в своем мозгу визуальный план страницы регистрации. Идем с основами. Требования к странице регистрации — три текстовых поля, одна кнопка и третье — текстовые метки (метка регистрации, метка имени пользователя, пароль и метка подтверждения пароля).

Найдите эти виджеты в «Панели инструментов виджетов» и перетащите необходимое меню в рабочее или главное окно.

Установите внешний вид виджета или окна. Щелкните виджет правой кнопкой мыши и выберите «Изменить таблицу стилей». Чтобы просмотреть изменения, нажмите «ctrl + R».

Переходя к последнему, сохраните файлы. Файл будет сохранен с расширением .ui, и вам необходимо преобразовать его в расширение .py. Для этого преобразования откройте терминал и перейдите в папку, содержащую макет.UI файл.

Теперь введите «pyuic5 -x layout.UI -o layout.py» в терминале. Наконец, запустите layout.py через Python.

Переход на другую среду графического интерфейса пользователя под названием WxPython

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

3. KIVY GUI

Фреймворки Kivy GUI — более интересные проекты Python, поскольку они лицензированы MIT и основаны на OpenGL ES 2. OpenGL ES 2 был первым API мобильной графики и до сих пор наиболее доступным API 3D графики.Это библиотека Python с открытым исходным кодом, используемая для создания нового пользовательского интерфейса и для быстрой разработки веб-приложений.

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

Kivy Python GUI Builder поддерживает почти все платформы, такие как Windows, Linux, OS X и Android.Более того, Kivy — более полезная библиотека Gui, потому что она использует одни и те же коды для мобильных и настольных приложений. Кроме того, Kivy — это набор инструментов графического интерфейса Python с открытым исходным кодом, который используется для мобильных приложений и других приложений multi-touch. Чтобы получить обзор того, как создать графический интерфейс через Kivy, с нетерпением жду статьи.

Примечание. Для создания графического интерфейса через Kivy в вашей системе должна быть установлена ​​подходящая версия Python. Щелкните для –Python Download

Кроме того, установите Kivy в свою систему.Давайте посмотрим, как это происходит —

Установка Kivy: В Windows

• Перед установкой Kivy обновите пип и колесо.

Давайте посмотрим на метод установки Kivy в Linux

Установите Kivy: В Linux

Процесс установки Kivy в Linux немного отличается для оконной системы.

• В Linux добавьте PPA с помощью команды, приведенной ниже.

• Затем обновите список пакетов с помощью диспетчера пакетов

Наконец , установите Kivy в Linux с помощью указанной ниже строки кода.

Этапы создания графического интерфейса пользователя Python Kivy

Это трехэтапный процесс создания графического интерфейса пользователя Kivi Python.

1. Приложение Derive Kivy’s — представляет собой окно для наших виджетов.
2. Сформулируйте метод build () — он будет представлять содержимое виджетов.
3. Наконец, запустите программу, вызвав метод run ().

4. WxPython GUI

Еще одно имя в списке лучших фреймворков Python GUI — WxPython. Это кроссплатформенный графический пользовательский интерфейс на языке программирования Python. Этот инструментарий позволяет программистам создавать высокоэффективный функциональный пользовательский интерфейс Python.

Быстро, легко и просто. WxPython реализован как часть модуля расширения Python, который связывает элементы графического интерфейса известной кроссплатформенной библиотеки wxWidget. И эти элементы написаны на языке C ++.

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

Перед установкой WxPython для создания пользовательского интерфейса Python загрузите соответствующую версию Python.Наиболее часто используемые версии Python, которые могут связываться с wxPythone, — это 2.6 и 2.7. Работа над запуском WxPython в версии Python 3.0 все еще продолжается.

Установите WxPython GUI: в Linux

Чтобы установить WxPython в Linux, откройте терминал, найдите «wx gtk», установите и запустите программу.

Установите графический интерфейс WxPython: в Windows

• Перед установкой обновите пип и колесо.

• Установите WxPython, используя команду

. На этом установка WxPython завершена.

5. PySide GUI

PySide — это привязка Python для стороны QT. Это расширение Python или API для QT, который, вероятно, является отраслевым стандартом для разработки пользовательского интерфейса для кросс-платформенных приложений. Таким образом, вы можете запускать свой графический пользовательский интерфейс с помощью PySide в Windows, Mac и Linux без значительного изменения исходного кода. Это большое преимущество.

PySide и PyQT примерно одинаковы. Единственная разница в том, что они имеют открытый исходный код и лицензированы. PySide сравнительно снисходителен, чем другой конструктор графического интерфейса Python.Итак, если вы пытаетесь создать программу, которую хотите использовать в профессиональном плане или для продажи, то наши предложения — использовать Pyside. Чтобы использовать PySide, выберите Python версии 2.7 или 2.8. Теперь перейдите к установке PySide на разных устройствах.

Установите PySide: в Mac

Сначала установите или создайте QT 4.8 или используйте приведенный ниже код для установки:

Установите колесо за пипом, то есть диспетчер пакетов Python. Используйте код, написанный ниже.

Установите PySide: В Windows

Чтобы установить PySide в Windows, выполните шаг

• Сначала установите pip (менеджер пакетов python).Используйте для этого код

• Теперь используйте код для установки PySide в вашей системе.

Установите PySide в Linux

Следуйте инструкциям по загрузке Pyside в Linux

• Сначала установите зависимости сборки.

• Теперь установите последнюю версию диспетчера пакетов Python под названием pip distribution. Загрузите get-pi и запустите интерпретатор Python вашей версии Python. Используйте приведенную ниже команду для Python версии 2.7.

• Наконец, установите последнюю версию распределения колес —

Вот сравнение 5 лучших графических интерфейсов Python

6. PySimpleGUI

Библиотека PySimpleGUI основана на Tkinter и работает только на Python3. Он содержит единственный файл Python, благодаря которому его легко установить и с ним легко работать. Python Gui легко кодировать, использовать и настраивать.Эта кроссплатформенность также работает в Raspberry Pi.

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

7. PyGUI

PyGUI — это кроссплатформенное приложение с графическим интерфейсом. Он поддерживает Unix, Macintosh и Windows. По сравнению с другими фреймворками PyGUI является более легким, поскольку API полностью синхронизирован с Python.Встраивание кода в программу с графическим интерфейсом пользователя и приложение Python намного меньше. Вот почему внешний вид приложения обычно представляет собой фактический графический интерфейс платформы.

Отец PyGUI — доктор Грег Юинг. Они разработали это, когда он работал в Кентерберийском университете с целью создания GUI API, специально разработанного для Python. Цель состоит в том, чтобы сделать уникальную языковую функцию Python и графический пользовательский интерфейс, который без проблем работает с типами данных Python. Для новичков в этой области этот графический интерфейс прост и быстр в освоении.

8. Pyforms GUI

Один из последних графических интерфейсов Python — Pyforms. Это фреймворки Python 3, используемые для работы в режиме графического интерфейса Windows. По сути, это кроссплатформенный фреймворк с минимальным кодом. Pyforms является модульным и поддерживает повторное использование кода.

Однако Pyforms принадлежит PyQt, OpenGL и другим библиотекам. Он предлагает полный набор из 22 элементов управления, каждый из которых основан на объекте ControlBase. Кроме того, он включает видеоплееры, веб-браузер и графический интерфейс OpenGL

Pyforms в среде Python 3, чтобы приложения Pyforms могли выполняться в режиме графического интерфейса Windows.Фреймворк творчества развития продвижения через предоставленный API на python. и разрешить выполнение приложений, разработанных для графического интерфейса и веб-режима, в консоли терминала.

Некоторое преимущество

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

9. Wax Python GUI

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

WxPython — это оболочка для Cross-stage GUI API, часто обозначаемая как инструментарий wxWidgets, написанная на C ++ для Python.Это один из вариантов выбора для Tkinter, который поставляется вместе с Python. Это реализовано как собственный код модуля расширения PY. Популярными вариантами выбора являются PyGTK, его преемник PyGObject и PyQt. И wxWidgets, wxPython бесплатен.

10. Libavg GUI

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

Это также графический интерфейс с открытым исходным кодом, поддерживающий Linux, Mac OS X и Windows. Libavg находится под лицензией LGPL (Стандартная общественная лицензия ограниченного применения). Этот фреймворк пользовательского интерфейса Python отличается художественным исполнением и широким набором функций. Например, механизм компоновки, который может решать многие задачи, быстрые видеовыходы, шейдерные эффекты графического процессора (графический процессор), системная разметка для отображения текста.

Игра с несколькими касаниями на большом экране — это пример графического интерфейса Python Libavg. Перейдем к установке Libavg в вашей системе.

Перед тем, как начать, загрузите Python версии 2.7. Поскольку Libavg поддерживает эту версию Python.

Установка Libavg: в Mac

Установщик Mac является официальным DMG (образ диска). Шаги установки следующие:

1. Первым шагом является загрузка образа диска
2. , а затем двойное соединение для его монтирования
3. Снова дважды щелкните файл pkg, чтобы запустить программу установки
4. Следуйте инструкциям, которые вы получите после запуска установщик.

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

Здесь вы найдете множество тестовых изображений и прочего.

Установка графического интерфейса Libavg: в Linux

Сначала перейдите к уже доступному пакету ubuntu. Если пакет Ubuntu «Sudo apt-get install python-libavg» устарел, загрузите tarball и выполните установку исходного кода.

Установка графического интерфейса Libavg: в Windows

Сначала загрузите версию Python 2.7 в свою систему, затем загрузите среду выполнения Visual C ++.

На втором этапе загрузите драйвер цифровой камеры CMU 1394 и установщик Libavg.

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

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

Теперь запустите тест.

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

Однако, согласно Google, существует около 256 языков программирования, которые классифицируются в алфавитном порядке. Среди бесчисленного множества наиболее популярных языков программирования рассматриваются следующие: Python, PHP, JavaScript, Java, TypeScript, C #, Elixir, Rust, Swift, Go и т. Д..

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

Во-первых, Tkinter vs Kivy,

1. Tkinter vs Kivy

Второй — PyQT против PySide,

2. PyQt против PySide

Третий — Kivy vs PyQT,

3. Kivy vs PyQT

Четвертый — WxPython vs Tkinter,

4. WxPython vs Tkinter

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

Что такое программирование на Python

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

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

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

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

История языка Python

Ван Россум — отец языка Python. В начале 1980-х он работал над языком ABC, а в конце 1980-х начал искать язык сценариев с синтаксисом наподобие ABC.Таким образом, можно сказать, что именно влияние ABC привело к созданию и развитию языка программирования Python.

Первая версия Python представлена ​​в 1991 году. Более того, история названия языка довольно интересна. Название языка Python не из-за змеи. Это название связано с тем, что Ван Россум — большой поклонник шоу под названием «Летный цирк Монти Пайтона». Сын, название языка Python вдохновлено шоу.

Первая версия языка программирования Python — 1.0 запущен в 1991 году. Сейчас оценка Python достигнута до 3,6 до 2016 г. —

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

Почему мы используем программирование на Python

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

• Язык Python является бесплатным и имеет открытый исходный код. Поэтому разработчику не нужно ни за что платить.
• Совместима с максимальным количеством платформ. Таким образом, программист сталкивается с меньшим количеством проблем, чем другие языки.
• Python поддерживает объектно-ориентированное программирование. В объектно-ориентированном программировании разработчики используют объекты, основанные на данных и функциональности. Разработчики, ориентированные на процедуры, применяют многократно используемые части кода.
• Ассоциация Python создала огромную коллекцию из нескольких библиотек для Python.И это помогает вам поддерживать документацию. Кроме того, вы можете управлять модульным тестированием веб-браузеров, электронной почты, баз данных, криптографии, графического интерфейса пользователя (Graphical User Interface).
• Вы можете перенести программу Python с одной платформы на другую и запустить ее, не внося никаких изменений. Он поддерживает почти все платформы, такие как Windows, Mac OS X и Linux.
• Более того, вы можете без труда комбинировать части C / C ++ или других языков с кодом Python. Это повысит производительность вашего программирования.

На этом мы заканчиваем руководство по графическому интерфейсу Python!

Заключение

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

Мы собрали для вас лучшую среду графического интерфейса Python.

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

Блог, который вам может понравиться — Java GUI Framework и другие приложения Java

.

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

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

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

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

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

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

Но для программ общего назначения не считайте ни командную строку, ни веб-интерфейс.Командная строка предлагает множество преимуществ — скорость, удаленный доступ, возможность повторного использования, возможность создания сценариев и контроль, — которые могут быть более важны для пользователей вашего приложения, чем графический интерфейс, и существует множество библиотек, таких как Click, Cement и Cliff, которые упрощают создавать отличные программы из командной строки.

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

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

Все еще уверены, что хотите создать графический интерфейс? Отлично, вот несколько фантастических библиотек с открытым исходным кодом, с которых можно начать.

PyQt, PySide и Qt для Python

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

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

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

В качестве другого варианта использования библиотек Qt с Python рассмотрите Qt для Python (обычно известный как PySide2), доступный в рамках LPGL.

Tkinter

Если бы существовал единственный пакет, который можно было бы назвать «стандартным» набором инструментов графического интерфейса для Python, это был бы Tkinter. Tkinter — это оболочка для Tcl / Tk, популярного графического интерфейса и языковой пары, впервые получившего популярность в начале 90-х годов. Преимущество выбора Tkinter — это огромное количество ресурсов, включая книги и образцы кода, а также большое сообщество пользователей, которые могут помочь вам, если у вас возникнут вопросы.С простых примеров легко начать работу, и они довольно удобочитаемы.

Tkinter доступен под лицензией Python поверх лицензии BSD Tcl / Tk.

WxPython

WxPython переносит кроссплатформенную библиотеку графического интерфейса wxWidgets из собственного C ++ в Python. WxPython выглядит немного более естественным, чем Tkinter, в разных операционных системах, потому что он использует виджеты хост-системы для создания графического интерфейса. Начать работу с ним довольно просто, и сообщество разработчиков постоянно растет.Возможно, вам придется связать wxPython с вашими приложениями или потребовать от пользователя установить его самостоятельно, поскольку он не устанавливается автоматически вместе с Python.

WxPython использует лицензию библиотеки wxWindows своего родительского проекта, одобренного OSI.

Python GTK + 3

Ранее известный как PyGTK, проект Python GTK + 3 обеспечивает привязки Python к объектам GTK (окнам, виджетам и т. Д.). GTK + наиболее широко используется в качестве основы для рабочего стола GNOME, но он доступен для автономных приложений в Linux, Windows и Mac.В Python GTK + 3 такая же структура доступна для ваших проектов Python.

Когда вы используете Python GTK + 3, вы можете использовать многие из тех же инструментов разработки, которые созданы для самого GTK +. В частности, сюда входит Glade, дизайнер интерфейсов для приложений GTK +. Интерфейсы, разработанные в Glade, сохраняются как XML и используются объектом GtkBuilder в коде вашего приложения, но интерфейс, который вы используете, является перетаскиваемым, что упрощает создание динамического и отзывчивого пользовательского интерфейса без необходимости переводить то, что вы видите в своем коде. разум в код макета.

Киви

Созданный с учетом быстрой разработки и современных устройств, Kivy представляет собой набор инструментов для Linux (включая Raspberry Pi), Windows, Mac и Android. Проект ориентирован на «инновационные пользовательские интерфейсы», и он используется для мультимедийных приложений, таких как приложения для музыкальных контроллеров для телефонов и приложения для интерактивной доски, занимающие всю стену конференц-зала.

Kivy не имеет программы визуального макета, такой как QtCreator и Glade, но он использует свой собственный язык дизайна, чтобы помочь вам связать макет пользовательского интерфейса с объектами кода.Это позволяет легко разделить (как мысленно, так и в коде макета) классы и функции в вашем приложении. Kivy также размещает Kivy Garden, хранилище пользовательских виджетов и надстроек, поэтому, если вы думаете о создании чего-то, чего не предоставляет сама Kivy, возможно, это уже существует в Garden.

Это не единственный выбор, который у вас есть, даже далеко. Чтобы узнать о дополнительных возможностях, посетите страницу «Программирование с графическим интерфейсом на Python» в официальной вики-странице Python Software Foundation, где перечислены десятки других инструментов.Доступны решения для привязки Python ко многим различным библиотекам виджетов и инструментам графического интерфейса, таким как FLTK, FOX и многим другим. Хотя новичкам, вероятно, следует избегать проектов, обеспечивающих только частичную реализацию или тех, которые больше не поддерживаются активно, существует множество хороших инструментов для различных ситуаций.

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

У вас есть фаворит, не упомянутый здесь? Дайте нам знать в комментариях ниже!

Вы хотите прочитать больше подобных статей? Подпишитесь на нашу еженедельную рассылку новостей по электронной почте.

.

Шесть лучших графических интерфейсов Python для разработчиков

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

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

Итак, давайте начнем с нашего списка из 6 лучших графических интерфейсов Python:

1. Kivy
   Kivy — это ускоренная платформа OpenGL ES 2 для создания новых пользовательских интерфейсов. Он поддерживает несколько платформ, а именно Windows, MacOSX, Linux, Android iOS и Raspberry Pi.Это открытый исходный код, в его инструментарий входит более 20 виджетов.
2. PyQT
   PyQT — одна из самых популярных кроссплатформенных привязок Python, реализующих библиотеку Qt для среды разработки приложений Qt (принадлежит Nokia). В настоящее время PyQT доступен для Unix / Linux, Windows, Mac OS X и Sharp Zaurus. Он сочетает в себе лучшее из Python и Qt, и программист может решить, создавать ли программу путем кодирования или с помощью Qt Designer для создания визуальных диалогов.

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

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

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

4. WxPython
   WxPython — это оболочка с открытым исходным кодом для кроссплатформенной библиотеки графического интерфейса WxWidgets (ранее известной как WxWindows), реализованная как модуль расширения Python. С WxPython вы как разработчик можете создавать собственные приложения для Windows, Mac OS и Unix.

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

5. PyGUI
   PyGUI — это кроссплатформенный фреймворк графических приложений для Unix, Macintosh и Windows. По сравнению с некоторыми другими фреймворками графического интерфейса пользователя PyGUI, безусловно, является самым простым и легким из всех, поскольку API полностью синхронизирован с Python. PyGUI вставляет очень меньше кода между платформой графического интерфейса пользователя и приложением Python, поэтому на экране приложения обычно отображается естественный графический интерфейс платформы.
6. PySide
   PySide — это бесплатный кроссплатформенный набор инструментов с графическим интерфейсом пользователя Qt, инициированный и спонсируемый Nokia, Qt — это инфраструктура пользовательского интерфейса и кроссплатформенное приложение.PySide в настоящее время поддерживает Linux / X11, Mac OS X, Maemo и Windows, а поддержка Android — в планах на ближайшее будущее. PySide предоставляет инструменты для работы с мультимедиа, XML-документами, сетью, базами данных и графическим интерфейсом. Ключевой особенностью PySide является его API-совместимость с PyQt4, поэтому, если вы хотите перейти на PySide, этот процесс будет беспроблемным.

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

Х. Фатима Х. Фатима Х. Фатима раньше была инженером по профессии и писателем по энтузиазму, пока не стала писать на полную ставку. В настоящее время она работает маркетологом в Endurance International Group (APAC). В основном она пишет то, что глубоко воспринимает и анализирует, это ее способ расслабиться. Ее интересы включают письмо, чтение (заядлый читатель), просмотр фильмов на иностранных языках и публичные выступления.Просмотреть все сообщения Х. Фатимы.

Как создать приложение с графическим интерфейсом пользователя Python с помощью wxPython — Real Python

Существует множество наборов инструментов графического пользовательского интерфейса (GUI), которые можно использовать с языком программирования Python. Большая тройка — это Tkinter, wxPython и PyQt. Каждый из этих наборов инструментов будет работать с Windows, macOS и Linux, а PyQt имеет дополнительные возможности для работы на мобильных устройствах.

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

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

Вот затронутые темы:

• Начало работы с wxPython
• Определение графического интерфейса пользователя
• Создание скелета приложения
• Создание рабочего приложения

Приступим к обучению!

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

Инструментарий графического интерфейса пользователя wxPython представляет собой оболочку Python для библиотеки C ++ под названием wxWidgets.Первоначальный выпуск wxPython был в 1998 году, поэтому wxPython существует довольно давно. Основное отличие wxPython от других наборов инструментов, таких как PyQt или Tkinter , заключается в том, что wxPython по возможности использует фактические виджеты на собственной платформе. Благодаря этому приложения wxPython выглядят родными для операционной системы, в которой они работают.

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

Это не означает, что wxPython не поддерживает настраиваемые виджеты. Фактически, в набор инструментов wxPython входит множество настраиваемых виджетов, а также десятки и десятки основных виджетов. На странице загрузок wxPython есть раздел под названием Extra Files , который стоит проверить.

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

Установка wxPython

Для этой статьи вы будете использовать последнюю версию wxPython, а именно wxPython 4 , также известную как выпуск Phoenix. Версии wxPython 3 и wxPython 2 созданы только для Python 2 . Когда Робин Данн, основной разработчик wxPython, создавал выпуск wxPython 4, он отказался от множества псевдонимов и очистил много кода, чтобы сделать wxPython более питоническим и более простым в поддержке.

Если вы переходите со старой версии wxPython на wxPython 4 (Phoenix), вам нужно будет воспользоваться следующими ссылками:

Пакет wxPython 4 совместим как с Python 2.7, так и с Python 3.

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

Примечание: В Mac OS X вам понадобится установленный компилятор, например XCode , для успешного завершения установки.Linux также может потребовать от вас установки некоторых зависимостей, прежде чем установщик pip будет работать правильно.

Например, мне нужно было установить freeglut3-dev , libgstreamer-plugins-base0.10-dev и libwebkitgtk-3.0-dev на Xubuntu, чтобы заставить его установить.

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

Для наиболее популярных версий Linux доступны некоторые колеса Python, которые вы можете найти в разделе Extras Linux с версиями GTK2 и GTK3. Чтобы установить одно из этих колес, вы должны использовать следующую команду:

  $ pip install -U -f https://extras.wxpython.org/wxPython4/extras/linux/gtk3/ubuntu-18.04/ wxPython
  

Убедитесь, что вы изменили приведенную выше команду в соответствии с вашей версией Linux.

Определение графического интерфейса

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

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

• Главное окно
• Меню
• Панель инструментов
• Пуговицы
• Ввод текста
• Этикетки

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

.