Tutorial PyQt5 com exemplos: Criar Python GUIs com Qt

As seções abaixo abordam desde os conceitos básicos do PyQt até a instalação, widgets principais, layouts e temas, com exemplos executáveis.

O que é PyQt?

PyQtGenericName é um Python vinculação do kit de ferramentas de widgets de código aberto Qt, que também funciona como uma estrutura de desenvolvimento de aplicativos multiplataforma. Qt é popular C++ Framework para escrever aplicativos GUI para todas as principais plataformas desktop, móveis e embarcadas (compatível com Linux, Windows, macOS, Android, iOS, Raspberry Pi e muito mais).

PyQt é um software livre desenvolvido e mantido pela Riverbank Computing, uma empresa sediada na Inglaterra, enquanto o Qt é desenvolvido por uma empresa finlandesa chamada The Qt Company.

Características do PyQt

Aqui estão recursos importantes do PyQt:

PyQt consiste em mais de seiscentas classes que abrangem uma variedade de recursos, tais como:

• Interfaces Gráficas do Usuário
• Bases de Dados SQL
• Kits de ferramentas da web
• processamento de XML
• Networking

Esses recursos podem ser combinados para criar interfaces de usuário avançadas, bem como aplicativos independentes. Muitas grandes empresas de diversos setores utilizam o Qt. Alguns exemplos são LG, Mercedes, AMD, Panasonic e Harman.

Versões PyQt

O PyQt está disponível em duas edições: PyQt4 e PyQt5. O PyQt4 fornece código de integração para as versões 4.x e 5.x do framework Qt, enquanto o PyQt5 oferece integração apenas para a versão 5.x. Consequentemente, o PyQt5 não é compatível com os módulos obsoletos da versão anterior. Neste tutorial de GUI em PyQt, o PyQt5 será usado para a demonstração dos exemplos. Além dessas duas versões, a Riverbank Computing também oferece o PyQt3D. Python Vinculações para o framework Qt3D. O Qt3D é um framework de aplicações usado para criar sistemas de simulação em tempo real com renderização 2D/3D.

Como instalar o PyQt5

Neste tutorial do PyQt5, veremos as duas maneiras de instalar o PyQt:

• Usando arquivos Wheel
• Construindo e instalando a partir da fonte

Qt (pronuncia-se cute) é um sistema complexo e a base de código PyQt contém compilado C++ e Python código subjacente. Consequentemente, compilá-lo e instalá-lo a partir do código-fonte é um processo complexo em comparação com outras distribuições. Python bibliotecas. No entanto, você pode instalar facilmente o PyQt5 usando wheels.

Instalação com rodas

As rodas são o novo padrão Python formato de embalagem e distribuição. Simplificando, uma roda é um arquivo ZIP com um nome especial e .enquanto extensão de arquivo. As rodas podem ser instaladas usando pip (Pythongerenciador de pacotes), que está incluído por padrão nas versões recentes do Python.

Então, se você tem Python 3.4 ou posterior instalado, você já tem o pip. Se, no entanto, você estiver usando uma versão mais antiga do PythonVocê precisa baixar e instalar o pip antes de prosseguir. Você pode encontrar instruções neste link: https://pypi.org/project/pip/.

Para instalar o PyQt5:

Passo 1) Abra o prompt de comando.
Abra o prompt de comando ou PowerShell em seu Windows máquina.

Passo 2) Digite o seguinte.

 pip install PyQt5

Passo 3) Instalação bem sucedida.
Esta etapa deste tutorial do PyQt5 fará o download do pacote whl do PyQt5 (cerca de 50 MB) e o instalará em seu sistema.

Alternativamente, você também pode baixar um Windows binário para a versão de Python instalado no seu computador.

Quando estiver concluído, prossiga para a próxima seção deste tutorial PyQt5 para escrever seu primeiro aplicativo GUI.

PyQt básico Concepts e Programas

Agora que você instalou o PyQt5 com sucesso em seu computador, você está pronto para escrever. Python Aplicações com interface gráfica.

Neste tutorial de PyQt5, vamos começar com um aplicativo simples que exibirá uma janela vazia na sua tela.

Ligue o seu Python IDLE e digite o seguinte:

Programa 1

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_())

Salve o arquivo como app.py (o nome não importa) e pressione F5 para executar o programa. Como alternativa, basta clicar duas vezes no arquivo salvo para iniciar o aplicativo. Se você fez tudo certo, uma nova janela será aberta com o título Guru99, conforme mostrado abaixo.

Ótimo! Está funcionando. Não é muita coisa, mas é o suficiente para entender o básico. Agora, neste tutorial de PyQt, vamos ver em detalhes o que cada linha do seu programa faz.

from PyQt5.QtWidgets import QApplication, QWidget

Esta instrução importa todos os módulos necessários para criar uma GUI para o namespace atual. O módulo QtWidgets contém todos os principais widgets que você usará neste Python Tutorial Qt.

app = QApplication(sys.argv)

Aqui, você está criando um objeto da classe QApplication. Esta etapa é uma necessidade para PyQt5; todo aplicativo de UI deve criar uma instância de QApplication, como uma espécie de ponto de entrada no aplicativo. Se você não criá-lo, erros serão mostrados.

sys.argv é a lista de parâmetros de linha de comando que você pode passar para o aplicativo ao iniciá-lo por meio do shell ou ao automatizar a interface.

Neste exemplo em PyQt5, você não passou nenhum argumento para QApplication. Portanto, você também pode substituí-lo pelo código abaixo, sem precisar importar o módulo sys.

app = QApplication([])

w = QWidget()

A seguir, criamos um objeto da classe QWidget. QWidget é a classe base de todos os objetos UI no Qt, e praticamente tudo que você vê em um aplicativo é um widget. Isso inclui caixas de diálogo, textos, botões, barras e assim por diante. O recurso que permite projetar interfaces de usuário complexas é que os widgets podem ser aninhados, ou seja, você pode ter um widget dentro de um widget, que está dentro de outro widget. Você verá isso em ação na próxima seção.

w.resize(300,300)

O método resize da classe QWidget permite definir as dimensões de qualquer widget. Neste caso, você redimensionou a janela para 300px por 300px.

Aqui, você deve lembrar que os widgets podem ser aninhados; o widget mais externo (ou seja, o widget sem elemento pai) é chamado de Janela.

w.setWindowTitle("Guru99")

O método setWindowTitle() permite que você passe uma string como argumento, que definirá o título da janela para a string passada. No exemplo em PyQt5, a barra de título exibirá Guru99.

w.show()

show() simplesmente exibe o widget na tela do monitor.

sys.exit(app.exec_())

O método app.exec_() inicia o Qt/C++ ciclo de eventos. Como você sabe, PyQt é amplamente escrito em C++ e utiliza o mecanismo de loop de eventos para implementar a execução paralela. `app.exec_()` passa o controle para o Qt, que encerrará o aplicativo somente quando o usuário o fechar pela interface gráfica. É por isso que Ctrl+C não encerra o aplicativo como em outros casos. Python programas. Já que o Qt tem controle sobre o aplicativo, Python Os eventos não são processados ​​a menos que os configuremos dentro da aplicação. Observe também que o método `exec` possui um sublinhado em seu nome; isso ocorre porque `exec()` já era uma palavra-chave em Python e o sublinhado resolve o conflito de nomenclatura.

Além das janelas vazias

Na seção anterior, você viu como criar um widget básico em Qt. Agora é hora de criar interfaces mais complexas com as quais os usuários possam interagir de verdade. Novamente, abra seu... IDLE e escreva o seguinte.

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_())

Salve o arquivo como appone.py ou qualquer outro nome que preferir e pressione F5 para executar o programa. Se você não cometeu nenhum erro, o IDLE abrirá uma nova janela com algum texto e um botão conforme mostrado abaixo.

1. Depois de clicar no botão da primeira janela, uma nova caixa de mensagem será aberta com o texto que você escreveu.
2. Agora você pode clicar no botão Ocultar detalhes/Mostrar detalhes para alternar a visibilidade do texto adicional.

Como você pode ver, como não havíamos definido nenhum título para a janela da caixa de mensagem, um título padrão foi fornecido por Python si.

Agora que está funcionando, vamos dar uma olhada no código extra que você adicionou ao exemplo anterior do PyQt5.

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

Isso importa mais alguns widgets que você usou nos exemplos do PyQt5, nomeadamente QLabel, QPushButton e 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_()

Aqui, você definiu um método chamado dialog que cria um widget de caixa de mensagem e define algum texto para os botões e outros campos.

O método dialog é chamado a partir do bloco principal do programa quando um botão é pressionado em um widget específico (neste caso, o btn PushButton). O evento click acionado nesse botão faz com que esta função seja executada. Essa função é chamada de slot no Qt, e você aprenderá mais sobre sinais e caça-níqueis nos próximos parágrafos.

if __name__ == "__main__":
    app = QApplication(sys.argv)
    w = QWidget()
    w.resize(300,300)
    w.setWindowTitle("Guru99")

Esta é a seção principal do aplicativo e, como no exemplo anterior, você começa criando uma instância de QApplication seguida por um widget simples, ou seja, uma instância de QWidget.

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

Você adicionou dois novos widgets neste aplicativo: QLabel e QPushButton. QLabel é usado para imprimir texto não editável ou espaços reservados dentro de um widget, enquanto QPushButton é usado para criar um botão clicável.

O ponto crítico a ser observado aqui é que quando você cria os objetos label e btn, você está passando o objeto window (w) para os construtores de QLabel e QPushButton. É assim que o aninhamento funciona no PyQt5. Para criar um widget dentro de outro widget, você passa a referência do widget pai para o construtor filho.

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

move() é usado para definir a posição de um widget em relação ao seu widget pai. No primeiro caso, o rótulo será movido 100px da esquerda e 130px do topo da janela.

Da mesma forma, o botão será colocado a 110px da esquerda e a 150px do topo da janela. Este exemplo é uma forma rudimentar de obter layouts e geralmente não é usado na produção; ele está incluído aqui apenas para fins de aprendizagem. Qt suporta diferentes layouts que você verá em detalhes nas próximas seções deste tutorial do PyQt.

btn.clicked.connect(dialog)

Por fim, este é um exemplo de sinais e slots em Qt. Em aplicações com interface gráfica, as funções são executadas com base nas ações realizadas pelo usuário, como passar o cursor sobre um elemento ou clicar em um botão. Essas ações são chamadas de slots. semelhantes. Lembre-se de que o método app.exec_() transfere o controle para o Qt evento laço. É para isso que existe o loop de eventos: para ouvir eventos e executar ações em resposta.

Sempre que ocorre um evento, como um usuário clicando em um botão, o widget Qt correspondente gera um sinal. Esses sinais podem ser conectados a Python funções (como a função de diálogo neste exemplo) para que a função seja executada quando um sinal for acionado. Essas funções são chamadas caça-níqueis na linguagem Qt.

Em seguida, a sintaxe básica para acionar uma função de slot em resposta ao sinal de um evento é a seguinte:

 widget.signal.connect(slot)

Isso significa que sempre que um sinal é desencadeado por um Widget, o conectado ranhura função será executada. Em resumo, sinais e slots são usados ​​pelo Qt para comunicação entre objetos e facilitam a reutilização e interatividade dos componentes.

Agora que você sabe como aninhar widgets e implementar interações usando sinais e slots, aqui está uma lista de widgets úteis e outras classes que você pode usar em seus aplicativos PyQt.

Componentes e widgets

Há um grande número de widgets disponíveis no PyQt para a criação de aplicativos GUI. No entanto, com o PyQt5, houve uma reorganização das classes em diferentes módulos e revisões nas licenças.

Portanto, é crucial ter uma visão geral da estrutura do PyQt5. Nesta seção, você verá como o PyQt5 está organizado internamente e aprenderá sobre os diferentes módulos, bibliotecas e classes de API fornecidos pelo PyQt5.

Estrutura de diretório PyQt5

Estes são os módulos fundamentais usados ​​por Pythonda ligação Qt, especificamente PyQt5.

• QtEle combina todas as classes/módulos mencionados abaixo em um único módulo. Isso aumenta consideravelmente o uso de memória pela aplicação. No entanto, é mais fácil gerenciar o framework importando apenas um módulo.
• QtCoreGenericName: contém as principais classes não gráficas usadas por outros módulos. É aqui que o loop de eventos Qt, sinais e conectividade de slot, etc. são implementados.
• QtWidgetsContém a maioria dos widgets disponíveis no PyQt5.
• QtGuiGenericName: Contém componentes GUI e estende o módulo QtCore.
• QtNetwork: Contém classes usadas para implementar programação de rede através do Qt. Ele suporta servidores TCP, soquetes TCP, soquetes UDP, manipulação de SSL, sessões de rede e pesquisas de DNS.
• Qt MultimídiaOferece funcionalidades multimídia de baixo nível.
• QtSqlGenericName: implementa integração de banco de dados para bancos de dados SQL. Suporta ODBC, MySQL, Oracle, SQLite e PostgreSQL.

Widgets PyQt5

Segue abaixo uma lista dos widgets mais frequentemente usados ​​no PyQt5:

• QLineEditar: Este é um campo de entrada que permite que uma linha de texto seja inserida pelo usuário.

line = QLineEdit()

• QRadioButtonEste é um campo de entrada com um botão selecionável, semelhante aos botões de opção em HTML.

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

• QComboBox: É usado para exibir um menu suspenso com uma lista de itens selecionáveis.

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

• QCheckBox: exibe uma caixa quadrada selecionável na frente do rótulo que será marcado se selecionado, semelhante aos botões de opção.

check = QCheckBox("button title")

• QMenuBarExibe uma barra de menu horizontal na parte superior da janela. Você só pode adicionar objetos da classe QMenu a essa barra. Esses objetos QMenu podem conter strings, objetos QAction ou outros objetos QMenu.
• QToolBarName: É uma barra ou painel horizontal que pode ser movido dentro da janela. Pode conter botões e outros widgets.
• QTabÉ utilizado para dividir o conteúdo de uma janela em várias páginas que podem ser acessadas por meio de diferentes abas na parte superior do widget. Consiste em duas seções: a barra de abas e a página de abas.
• QScrollBarÉ utilizado para criar barras de rolagem que permitem ao usuário rolar para cima e para baixo dentro de uma janela. Consiste em um controle deslizante móvel e um elemento deslizante. track, e dois botões para rolar o controle deslizante para cima ou para baixo.

scroll = QScrollBar()

• QSplitter: Divisores são usados ​​para separar o conteúdo de uma janela para que os widgets sejam agrupados corretamente e não pareçam desordenados. QSplitter é um dos principais manipuladores de layout disponíveis no PyQt5 e é usado para dividir o conteúdo horizontal e verticalmente.
• QDockUm widget de encaixe é uma subjanela com duas propriedades: pode ser movido dentro da janela principal e pode ser encaixado fora da janela principal em outro local na tela.

Layouts e Temas

Nos exemplos anteriores do PyQt5, você usou apenas os métodos move() e resize() para definir as posições dos widgets em sua GUI.

No entanto, PyQt possui um mecanismo robusto de gerenciamento de layout que pode ser usado para criar interfaces de usuário avançadas para aplicativos. Nesta seção, você aprenderá sobre duas classes importantes usadas no Qt para criar e gerenciar layouts.

1. QBoxtraçado
2. QGridLayout

QBoxtraçado

QBoxLayout é usado para alinhar os widgets filhos do layout em uma linha horizontal ou vertical. As duas classes de interesse que herdam de QBoxDisposição são:

• QHBoxLayout: usado para alinhar os widgets filhos horizontalmente.
• QVBoxLayout: usado para alinhar os widgets filhos verticalmente.

Por exemplo, é assim que três botões alinhados com QHBoxO layout ficará.

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_())

E é assim que eles ficarão no 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_())

A única função que precisa de explicação neste momento é o método addWidget(). É usado para inserir widgets no HBox ou VBox layout. Também é usado em outros layouts onde é necessário um número diferente de parâmetros, como você verá na próxima seção. Os widgets aparecerão dentro do layout na ordem em que você os inserir.

QGridLayout

QGridLayout é usado para criar interfaces nas quais os widgets são dispostos na forma de uma grade (como uma matriz ou array 2D). Para inserir elementos em um layout de grade, você pode usar a representação matricial para definir o número de linhas e colunas na grade, bem como a posição desses elementos.

Por exemplo, para criar uma grade 3*3 (ou seja, uma grade com três linhas e três colunas), você escreverá o seguinte código:

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_())

Esta será a saída:

O método addWidget() no layout de grade aceita os seguintes argumentos:

• O objeto widget que você deseja adicionar à grade
• A coordenada x do objeto
• A coordenada y do objeto
• O intervalo entre linhas (padrão = 0)
• O col-span (padrão = 0)

Para melhor compreensão, você pode inserir manualmente cada widget, conforme mostrado abaixo.

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_())

Esta é a aparência da grade:

Você também pode passar os parâmetros rowspan e colspan para addWidget() para abranger mais de uma linha ou coluna.

Por exemplo, nos

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

Isso criará um botão que se estende por ambas as colunas.

Temas

PyQt5 vem com alguns temas integrados que você pode usar em seus aplicativos. O setEstilo() O método chamado na instância QApplication é usado para definir um tema específico para seu aplicativo.

Por exemplo, adicionar a seguinte linha de código mudará o tema do seu aplicativo de padrão para Fusion.

app.setStyle("Fusion")

Assim ficará o exemplo anterior no tema Fusion.

Outra função útil para personalizar a aparência dos seus aplicativos é o método setPalette(). Aqui está o código para alterar a cor de diferentes widgets usando 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_())

Aqui está o resultado.

Para usar o método setPalette(), primeiro você precisa definir uma paleta. Isso é feito criando um objeto da classe QPalette.

 qp = QPalette()

Observe que a classe QPalette pertence ao módulo QtGui e você precisará importá-la para que isso funcione. Depois de criar o objeto QPalette, use o método setColor() para passar o nome de um widget cuja cor você deseja alterar e a cor que deseja definir.

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

Isso mudará a cor da janela para preto. Depois de definir seu esquema de cores, use a função setPalette() para aplicar a paleta ao seu aplicativo.

app.setPalette(qp)

Isso é tudo que você precisa fazer se quiser criar alguns temas básicos para seu aplicativo. PyQt também permite usar folhas de estilo para definir a aparência de seus widgets. Se você estiver familiarizado com CSS, poderá definir facilmente estilos avançados para seu aplicativo usando Qt Style Sheets.

Perguntas Frequentes