home Tecnologia de manufatura Equipamentos de Fabricação
Manufaturação industrial
Internet das coisas industrial | Materiais industriais | Manutenção e reparo de equipamentos | Programação industrial |
home  MfgRobots >> Manufaturação industrial >  >> Industrial programming >> python

Tutorial PyQt5 com exemplos:GUI de design usando PyQt em Python

O que é PyQt?


PyQt é uma ligação python do kit de ferramentas de widget de código aberto Qt, que também funciona como uma estrutura de desenvolvimento de aplicativos multiplataforma. Qt é uma estrutura C++ popular para escrever aplicativos GUI para todas as principais plataformas de desktop, móveis e embarcadas (suporta Linux, Windows, MacOS, Android, iOS, Raspberry Pi e muito mais).

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

Neste tutorial PyQt5, você aprenderá:

Recursos do PyQT


Aqui estão os recursos importantes do PyQt:

Aprenda PyQt, que consiste em mais de seiscentas classes cobrindo uma variedade de recursos, como

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

Versões do PyQt


O PyQt está disponível em duas edições, PyQt4 e PyQt5. O PyQt4 fornece um código de colagem para vincular as versões 4.xe 5.x da estrutura Qt, enquanto o PyQt5 fornece uma vinculação apenas para as versões 5.x. Como resultado, o PyQt5 não é compatível com os módulos obsoletos da versão mais antiga. Neste tutorial do Qt GUI, o PyQt5 será usado para a demonstração de exemplos. Além dessas duas versões,

A Riverbank Computing também fornece PyQt3D—as ligações python para a estrutura Qt3D. Qt3D é um framework de aplicação 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:

Qt (pronuncia-se cute) é um sistema complexo, e a base de código PyQt contém código compilado em C++ e Python sob o capô. Como resultado, é um processo complicado construí-lo e instalá-lo a partir da fonte em comparação com outras bibliotecas python. No entanto, você pode instalar facilmente o PyQt5 usando rodas.

Instalação com rodas


Wheels são o novo formato padrão de empacotamento e distribuição do Python. Simplificando, uma roda é um arquivo ZIP com um nome especial e .whl extensão de arquivo. Wheels pode ser instalado usando o pip (gerenciador de pacotes do Python), que está incluído por padrão nas versões recentes do Python.

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

Para instalar o PyQt5,

Etapa 1) Abra o prompt de comando.
Abra o prompt de comando ou o PowerShell em sua máquina Windows.



Etapa 2) Digite o seguinte. 

 pip install PyQt5

Etapa 3) Instalação bem sucedida.
Esta etapa neste tutorial do PyQt5 irá baixar o pacote PyQt5 whl (cerca de 50 MB) e instalá-lo em seu sistema.



Como alternativa, você também pode baixar um binário do Windows para a versão do python instalada em seu computador.

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

Conceitos e programas básicos do PyQt


Agora que você instalou o PyQt5 com sucesso em seu computador, você está pronto para escrever aplicativos de design de GUI em Python.

Vamos começar com um aplicativo simples neste tutorial do PyQt5 que exibirá uma janela vazia na tela.

Ative 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 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 se abrirá com o título Guru99 como mostrado abaixo.



Excelente! Está funcionando. Não é muito, mas é o suficiente para entender o básico. Agora, neste tutorial do PyQt, vamos ver em detalhes o que cada uma das linhas do seu programa faz. 

from PyQt5.QtWidgets import QApplication, QWidget

Essa instrução importa todos os módulos necessários para criar uma GUI no namespace atual. O módulo QtWidgets contém todos os principais widgets que você usará neste tutorial do Python Qt. 
app = QApplication(sys.argv)

Aqui, você está criando um objeto da classe QApplication. Esta etapa é uma necessidade para o PyQt5; cada aplicativo de interface do usuário deve criar uma instância de QApplication, como uma espécie de ponto de entrada no aplicativo. Se você não criá-lo, os 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 PyQt5, você não passou nenhum argumento para QApplications. Portanto, você também pode substituí-lo pelo código abaixo e nem precisa importar o módulo sys. 
app = QApplication([])
w = QWidget()

Em seguida, fazemos um objeto da classe QWidget. QWidget é a classe base de todos os objetos de UI no Qt, e praticamente tudo que você vê em um aplicativo é um widget. Isso inclui diálogos, 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 de redimensionamento 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 juntos, o widget mais externo (ou seja, o widget sem pai) é chamado de Window. 
w.setWindowTitle("Guru99")

O método setWindowTitle() permite que você passe uma string como argumento que irá definir o título da janela para a string que você passar. No exemplo do 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 loop de eventos Qt/C++. Como você sabe, o PyQt é amplamente escrito em C++ e usa o mecanismo de loop de eventos para implementar a execução paralela. app.exec_() passa o controle para o Qt que sairá do aplicativo somente quando o usuário o fechar a partir da GUI. É por isso que ctrl+c não sairá do aplicativo como em outros programas python. Como o Qt tem controle sobre o aplicativo, os eventos python não são processados, a menos que os configuremos dentro do aplicativo. Além disso, observe que o método exec tem 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 fazer um widget básico no Qt. Agora é hora de fazer algumas interfaces mais envolventes com as quais os usuários possam realmente interagir. Novamente, inicie 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 coisa que você goste 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 como mostrado abaixo.


  1. Depois de clicar no botão na 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 de janela na caixa de mensagem, um título padrão foi fornecido pelo próprio python.

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, ou seja, 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 slots 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.

A coisa crítica a notar 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 do filho. 
label.move(100,130)
btn.move(110,150)

move() é usado para definir a posição de um widget em relação ao 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á posicionado a 110px da esquerda e 150px da parte superior da janela. Este exemplo é uma maneira grosseira de obter layouts e geralmente não é usado na produção; ele é incluído aqui apenas para fins de aprendizado. O Qt suporta diferentes layouts que você verá em detalhes nas próximas seções deste tutorial do PyQt. 
btn.clicked.connect(dialog)

Finalmente, este é um exemplo de sinais e slots em Qt. Em aplicativos baseados em GUI, as funções são executadas com base nas ações executadas pelo usuário, como passar o mouse sobre um elemento ou clicar em um botão. Essas ações são chamadas de eventos . Lembre-se de que o método app.exec_() transfere o controle para o Qt evento- ciclo. É para isso que existe o loop de eventos:para ouvir eventos e executar ações em resposta.

Sempre que um evento ocorre, como um usuário clicando em um botão, o widget Qt correspondente gera um sinal . Esses sinais podem ser conectados a funções python (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 de slots na linguagem Qt.

Subsequentemente, a sintaxe básica para acionar uma função de slot em resposta ao sinal de um evento é a seguinte 
 widget.signal.connect(slot)

O que significa que sempre que um sinal é acionado por um widget , o slot conectado função será executada. Em resumo, sinais e slots são usados ​​pelo Qt para comunicar entre objetos e facilitar 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 criar aplicativos GUI. No entanto, com o PyQt5, houve um rearranjo de classes em diferentes módulos e revisões nas licenças.

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

Estrutura de diretórios PyQt5



Esses são os módulos fundamentais usados ​​pela ligação Qt do Python, especificamente PyQt5.

Widgets PyQt5


Aqui está uma lista dos widgets mais usados ​​no PyQt5

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, o 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 que são usadas no Qt para criar e gerenciar layouts.
  1. QBoxLayout
  2. QGridLayout

QBoxLayout


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

Por exemplo, é assim que três botões alinhados com QHBoxLayout ficarão. 


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 alguma explicação neste momento é o método addWidget(). Ele é usado para inserir widgets no layout HBox ou VBox. Ele também é usado em outros layouts onde leva 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 de matriz 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 da grade recebe estes argumentos:


Para entender melhor, 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, 

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

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


Temas


O PyQt5 vem com alguns temas integrados que você pode usar em seus aplicativos. O setStyle() 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 que o exemplo anterior ficará no Fusion Theme



Outra função útil para tematizar 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. O PyQt também permite que você use 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 as folhas de estilo Qt.

Resumo


python

  • Linguagem C
  • VHDL
  • Verilog
  • MATLAB
  • python
  • Java
    1. Tutorial de coleções de C# com exemplos
    2. Python String count() com EXEMPLOS
    3. Python String format() Explique com EXEMPLOS
    4. Método Python String find() com exemplos
    5. Funções do Python Lambda com EXEMPLOS
    6. Função Python round() com EXEMPLOS
    7. Função Python map() com EXEMPLOS
    8. Python Timeit() com exemplos
    9. Contador Python em coleções com exemplo
    10. type() e isinstance() em Python com exemplos