Tutorial PyQt5 con esempi: progettare la GUI utilizzando PyQt in Python

PyQt è un software gratuito sviluppato e gestito da Riverbank Computing, una società con sede in Inghilterra, mentre Qt è sviluppato da una società finlandese chiamata The Qt Company.

Caratteristiche di PyQT

Ecco le caratteristiche importanti di PyQt:

Impara PyQt che consiste di più di seicento classi che coprono una gamma di funzionalità come

• Interfacce utente grafiche
• Database SQL
• Toolkit web
• Elaborazione XML
• Networking

Queste funzionalità possono essere combinate per creare interfacce utente avanzate e applicazioni autonome. Molte grandi aziende di tutti i settori utilizzano Qt. Alcuni esempi sono LG, Mercedes, AMD, Panasonic, Harman, ecc.

Versioni PyQt

PyQt è disponibile in due edizioni, PyQt4 e PyQt5. PyQt4 fornisce il codice collante per l'associazione delle versioni 4.x e 5.x del framework Qt mentre PyQt5 fornisce un'associazione solo per le versioni 5.x. Di conseguenza, PyQt5 non è retrocompatibile con i moduli deprecati della versione precedente. In questo tutorial sulla GUI Qt, PyQt5 verrà utilizzato per la dimostrazione degli esempi. Oltre a queste due versioni,

Riverbank Computing fornisce anche PyQt3D, i collegamenti Python per il framework Qt3D. Qt3D è un framework applicativo utilizzato per creare sistemi di simulazione in tempo reale con rendering 2D/3D.

Come installare PyQt5

In questo tutorial di PyQt5 vedremo i due modi per installare PyQt:

• Utilizzo dei file Wheel
• Compilazione e installazione dal codice sorgente

Qt (pronunciato cute) è un sistema complesso e la base di codice PyQt contiene codice compilato C++ and Python codice sotto il cofano. Di conseguenza, è un processo complicato compilarlo e installarlo dalla sorgente rispetto ad altre librerie python. Tuttavia, puoi installare facilmente PyQt5 usando wheels.

Installazione con ruote

Le ruote sono il nuovo standard Python imballaggio e formato di distribuzione. In parole povere, una ruota è un archivio ZIP con un nome speciale e .quando estensione del file. Le ruote possono essere installate utilizzando pip (Pythonil gestore pacchetti di), incluso per impostazione predefinita nelle versioni recenti di Python.

Quindi, se hai Python 3.4 o versione successiva installata, hai già pip. Se, tuttavia, stai utilizzando una versione precedente di Python, è necessario scaricare e installare pip prima di procedere. Puoi cercare istruzioni a riguardo a questo link: https://pypi.org/project/pip/.

Per installare PyQt5,

Passo 1) Apri il prompt dei comandi.
Apri il prompt dei comandi o PowerShell nel tuo Windows macchina.

Passo 2) Digita quanto segue.

 pip install PyQt5

Passo 3) Installazione avvenuta con successo.
Questo passaggio di questo tutorial su PyQt5 scaricherà il pacchetto whl PyQt5 (circa 50 MB) e lo installerà sul tuo sistema.

In alternativa è anche possibile scaricare un Windows binario per la versione di Python installata sul tuo computer.

Una volta completato, procedi alla sezione successiva di questo tutorial PyQt5 per scrivere la tua prima app GUI.

PyQt di base Concepts e programmi

Ora che hai installato con successo PyQt5 sul tuo computer, sei pronto per scrivere Python Applicazioni di progettazione GUI.

Iniziamo con una semplice app in questo tutorial PyQt5 che visualizzerà una finestra vuota sullo schermo.

Accendi il tuo pitone IDLE e digita quanto segue:

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

Salvalo come app.py (il nome non ha importanza) e premi F5 per eseguire il programma. In alternativa, fai semplicemente doppio clic sul file salvato per avviare l'applicazione. Se hai fatto tutto correttamente, si aprirà una nuova finestra con il titolo Guru99 come mostrato di seguito.

Grande! Sta funzionando. Non è molto, ma è sufficiente per afferrare le basi. Ora in questo tutorial di PyQt, vediamo in dettaglio cosa fa ciascuna riga del tuo programma.

from PyQt5.QtWidgets import QApplication, QWidget

Questa istruzione importa tutti i moduli necessari per creare una GUI nello spazio dei nomi corrente. Il modulo QtWidgets contiene tutti i principali widget che utilizzerai in questo Python Tutorial su Qt.

app = QApplication(sys.argv)

Qui stai creando un oggetto della classe QApplication. Questo passaggio è necessario per PyQt5; ogni app dell'interfaccia utente deve creare un'istanza di QApplication, come una sorta di punto di ingresso nell'app. Se non lo crei, verranno visualizzati degli errori.

sys.argv è l'elenco dei parametri della riga di comando che è possibile passare all'applicazione quando la si avvia tramite la shell o durante l'automazione dell'interfaccia.

In questo esempio PyQt5, non hai passato alcun argomento a QApplications. Pertanto, puoi anche sostituirlo con il codice seguente e non dover nemmeno importare il modulo sys.

app = QApplication([])

w = QWidget()

Successivamente, creiamo un oggetto della classe QWidget. QWidget è la classe base di tutti gli oggetti UI in Qt e praticamente tutto ciò che vedi in un'app è un widget. Ciò include finestre di dialogo, testi, pulsanti, barre e così via. La caratteristica che ti consente di progettare interfacce utente complesse è che i widget possono essere annidati, ovvero puoi avere un widget all'interno di un widget, che è all'interno di un altro widget. Lo vedrai in azione nella prossima sezione.

w.resize(300,300)

Il metodo di ridimensionamento della classe QWidget consente di impostare le dimensioni di qualsiasi widget. In questo caso, hai ridimensionato la finestra a 300px per 300px.

Qui dovresti ricordare che i widget possono essere nidificati insieme, il widget più esterno (cioè il widget senza genitore) è chiamato Finestra.

w.setWindowTitle("Guru99")

Il metodo setWindowTitle() ti consente di passare una stringa come argomento che imposterà il titolo della finestra sulla stringa che passi. Nell'esempio PyQt5, la barra del titolo visualizzerà Guru99.

w.show()

show() visualizza semplicemente il widget sullo schermo del monitor.

sys.exit(app.exec_())

Il metodo app.exec_() avvia Qt/C++ ciclo di eventi. Come sai, PyQt è in gran parte scritto C++ e usa il meccanismo del ciclo di eventi per implementare l'esecuzione parallela. app.exec_() passa il controllo a Qt che uscirà dall'applicazione solo quando l'utente la chiuderà dalla GUI. Ecco perché ctrl+c non uscirà dall'applicazione come in altri programmi python. Poiché Qt ha il controllo sull'app, gli eventi python non vengono elaborati a meno che non li impostiamo all'interno dell'applicazione. Nota inoltre che il metodo exec ha un trattino basso nel suo nome; questo perché exec() era già una parola chiave in python e il trattino basso risolve il conflitto di denominazione.

Oltre le finestre vuote

Nella sezione precedente, hai visto come creare un widget di base in Qt. È giunto il momento di creare interfacce più coinvolgenti con le quali gli utenti possano veramente interagire. Ancora una volta, accendi il tuo IDLE e scrivi quanto segue.

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

Salva il file come appone.py o come preferisci e premi F5 per eseguire il programma. Se non hai fatto errori, il IDLE si aprirà una nuova finestra con del testo e un pulsante come mostrato di seguito.

1. Dopo aver cliccato sul pulsante nella prima finestra, si aprirà una nuova finestra di messaggio con il testo che hai scritto.
2. Ora puoi cliccare sul pulsante Nascondi dettagli/Mostra dettagli per attivare o disattivare la visibilità del testo aggiuntivo.

Come potete vedere, poiché non avevamo impostato alcun titolo nella finestra del messaggio, Python stesso ha fornito un titolo predefinito.

Ora che funziona, diamo un'occhiata al codice extra che hai aggiunto al precedente esempio PyQt5.

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

Questo importa altri widget che hai utilizzato negli esempi PyQt5, vale a dire 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_()

Qui hai definito un metodo denominato dialog che crea un widget casella di messaggio e imposta del testo sui pulsanti e su altri campi.

Il metodo dialog viene chiamato dal blocco principale del programma quando viene premuto un pulsante in un widget specifico (in questo caso, il btn PushButton). L'evento clic attivato su quel pulsante determina l'esecuzione di questa funzione. Tale funzione è chiamata slot in Qt e ne imparerai di più Segnali and slot nei prossimi paragrafi.

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

Questa è la sezione principale dell'app e come nell'esempio precedente, si inizia creando un'istanza di QApplication seguita da un semplice widget, ovvero un'istanza di QWidget.

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

Hai aggiunto due nuovi widget in questa applicazione: QLabel e QPushButton. QLabel viene utilizzato per stampare testo non modificabile o segnaposto all'interno di un widget, mentre QPushButton viene utilizzato per creare un pulsante cliccabile.

La cosa fondamentale da notare qui è che quando crei gli oggetti label e btn, stai passando l'oggetto finestra (w) ai costruttori di QLabel e QPushButton. Ecco come funziona la nidificazione in PyQt5. Per creare un widget all'interno di un altro widget, passi il riferimento del widget genitore al costruttore del figlio.

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

move() viene utilizzato per impostare la posizione di un widget rispetto al widget genitore. Nel primo caso l'etichetta verrà spostata di 100px da sinistra e di 130px dalla parte superiore della finestra.

Allo stesso modo, il pulsante verrà posizionato a 110px da sinistra e 150px dalla parte superiore della finestra. Questo esempio è un modo approssimativo per realizzare layout e generalmente non viene utilizzato nella produzione; è incluso qui solo a scopo didattico. Qt supporta diversi layout che vedrai in dettaglio nelle prossime sezioni di questo tutorial di PyQt.

btn.clicked.connect(dialog)

Infine, questo è un esempio di segnali e slot in Qt. Nelle applicazioni basate sulla GUI, le funzioni vengono eseguite in base alle azioni eseguite dall'utente, come passare il mouse su un elemento o fare clic su un pulsante. Queste azioni sono chiamate eventi. Ricordiamo che il metodo app.exec_() trasferisce il controllo a Qt evento-ciclo continuo. Questo è lo scopo del ciclo degli eventi: ascoltare gli eventi ed eseguire azioni in risposta.

Ogni volta che si verifica un evento, come un utente che fa clic su un pulsante, il widget Qt corrispondente solleva un segnale. È possibile collegare questi segnali funzioni Python (come la funzione di dialogo in questo esempio) in modo che la funzione venga eseguita quando viene attivato un segnale. Queste funzioni vengono chiamate slot nel gergo Qt.

Successivamente, la sintassi di base per attivare una funzione slot in risposta al segnale di un evento è la seguente

 widget.signal.connect(slot)

Il che significa che ogni volta che a segnale è attivato da a widget di, il connesso fessura la funzione verrà eseguita. In sintesi, i segnali e gli slot vengono utilizzati da Qt per comunicare tra oggetti e facilitare la riusabilità e l'interattività dei componenti.

Ora che sai come nidificare i widget e implementare le interazioni utilizzando segnali e slot, ecco un elenco di widget utili e altre classi che puoi utilizzare nelle tue app PyQt.

Componenti e widget

In PyQt sono disponibili numerosi widget per la creazione di app GUI. Tuttavia, con PyQt5, c'è stato un rimescolamento delle classi in diversi moduli e revisioni nelle licenze.

Pertanto, è fondamentale avere una visione di alto livello della struttura di PyQt5. In questa sezione vedrai come PyQt5 è organizzato internamente e imparerai a conoscere i diversi moduli, librerie e classi API forniti da PyQt5.

Struttura delle directory PyQt5

Questi sono i moduli fondamentali utilizzati da PythonIl legame Qt di , in particolare PyQt5.

• Qt: Combina tutte le classi/moduli menzionati di seguito in un unico modulo. Aumenta notevolmente la memoria utilizzata dall'applicazione. Tuttavia, è più semplice gestire il framework importando solo un modulo.
• QtCore: contiene le classi non grafiche principali utilizzate da altri moduli. È qui che vengono implementati il ​​loop di eventi Qt, i segnali, la connettività degli slot, ecc.
• QtWidget: contiene la maggior parte dei widget disponibili in Pyqt5.
• QtGui: contiene componenti GUI ed estende il modulo QtCore.
• QtNetwork: contiene classi utilizzate per implementare la programmazione di rete tramite Qt. Supporta server TCP, socket TCP, socket UDP, gestione SSL, sessioni di rete e ricerche DNS.
• Qt multimediale fornisce funzionalità multimediali di basso livello.
• QtSql: implementa l'integrazione del database per i database SQL. Supporta ODBC, MySQL, Oracle, SQLitee PostgreSQL.

Widget PyQt5

Ecco un elenco dei widget utilizzati più frequentemente in PyQt5

• QLineModifica: Questo è un campo di input che consente all'utente di inserire una riga di testo.

  line = QLineEdit()

• QRadioButton: Questo è un campo di input con un pulsante selezionabile, simile ai pulsanti di opzione in html.

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

• QComboBox: Viene utilizzato per visualizzare un menu a discesa con un elenco di voci selezionabili.

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

• QVerificareBox: Visualizza una casella quadrata selezionabile davanti all'etichetta che viene spuntata se selezionata, simile ai pulsanti di scelta rapida.

  check = QCheckBox("button title")

• QMenuBar: visualizza una barra dei menu orizzontale nella parte superiore di una finestra. Puoi aggiungere solo oggetti della classe QMenu a questa barra. Questi oggetti QMenu possono contenere inoltre stringhe, oggetti QAction o altri oggetti QMenu.

• QToolBar: È una barra o riquadro orizzontale che può essere spostato all'interno della finestra. Può contenere pulsanti e altri widget.

• QTab: viene utilizzato per suddividere il contenuto di una finestra in più pagine a cui è possibile accedere tramite diverse schede nella parte superiore del widget. Si compone di due sezioni: la barra delle schede e la scheda.

• QScrollBar: Viene utilizzato per creare barre di scorrimento che consentono all'utente di scorrere verso l'alto e verso il basso all'interno di una finestra. È costituito da un cursore mobile, una traccia del cursore e due pulsanti per scorrere il cursore verso l'alto o verso il basso.

  scroll = QScrollBar()

• QSplitter: i divisori vengono utilizzati per separare il contenuto di una finestra in modo che i widget siano raggruppati correttamente e non appaiano disordinati. QSplitter è uno dei principali gestori di layout disponibili in PyQt5 e viene utilizzato per dividere il contenuto sia orizzontalmente che verticalmente.

• QDock: Un widget Dock è una sottofinestra con due proprietà:
• Può essere spostato all'interno della finestra principale e
• Può essere agganciato all'esterno della finestra principale in un'altra posizione sullo schermo.

Layout e temi

Nei precedenti esempi PyQt5, hai utilizzato solo i metodi move() e resize() per impostare le posizioni dei widget nella GUI.

Tuttavia, PyQt dispone di un robusto motore di gestione del layout che può essere utilizzato per creare interfacce utente avanzate per le applicazioni. In questa sezione imparerai due importanti classi utilizzate in Qt per creare e gestire i layout.

1. QBoxdisposizione
2. QGridLayout

QBoxdisposizione

QBoxIl layout viene utilizzato per allineare i widget secondari del layout in una riga orizzontale o verticale. Le due classi di interesse che ereditano da QBoxLa disposizione è:

• QHBoxLayout: utilizzato per allineare orizzontalmente i widget secondari.
• QVBoxLayout: utilizzato per allineare verticalmente i widget secondari.

Ad esempio, ecco come tre pulsanti si sono allineati con QHBoxIl layout apparirà.

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

Ed ecco come appariranno in 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_())

L'unica funzione che necessita di qualche spiegazione a questo punto è il metodo addWidget(). Viene utilizzato per inserire widget nell'HBox o VBox disposizione. Viene utilizzato anche in altri layout dove richiede un numero diverso di parametri, come vedrai nella sezione successiva. I widget appariranno all'interno del layout nell'ordine in cui li inserisci.

QGridLayout

QGridLayout viene utilizzato per creare interfacce in cui i widget sono disposti sotto forma di griglia (come una matrice o un array 2D). Per inserire elementi in un layout di griglia, è possibile utilizzare la rappresentazione a matrice per definire il numero di righe e colonne nella griglia nonché la posizione di tali elementi.

Ad esempio, per creare una griglia 3*3 (ovvero una griglia con tre righe e tre colonne), scriverai il seguente codice:

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

Questo sarà l'output:

Il metodo addWidget() Nel layout della griglia accetta questi argomenti:

• L'oggetto widget che desideri aggiungere alla griglia
• La coordinata x dell'oggetto
• La coordinata y dell'oggetto
• L'intervallo di righe (impostazione predefinita = 0)
• L'intervallo col-(default=0)

Per capirlo meglio puoi inserire manualmente ciascun widget come mostrato di seguito

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

Ecco come apparirà la griglia:

Puoi anche passare i parametri rowspan e colspan a addWidget() per estendere più di una riga o colonna.

Per esempio,

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

Questo creerà un pulsante che si estende su entrambe le colonne.

Temi

PyQt5 viene fornito con alcuni temi integrati che puoi utilizzare nelle tue app. IL setStyle() Il metodo chiamato sull'istanza QApplication viene utilizzato per impostare un tema particolare per l'applicazione.

Ad esempio, aggiungendo la seguente riga di codice cambierà il tema della tua applicazione da predefinito a Fusion

app.setStyle("Fusion")

Ecco come apparirà l'esempio precedente in Fusion Theme

Un'altra funzione utile per creare temi per le tue app è il metodo setPalette(). Ecco il codice per cambiare il colore di diversi widget 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_())

Ecco il risultato.

Per utilizzare il metodo setPalette(), devi prima definire una tavolozza. Questo viene fatto creando un oggetto della classe QPalette.

 qp = QPalette()

Nota che la classe QPalette appartiene al modulo QtGui e dovrai importarla affinché funzioni. Una volta creato l'oggetto QPalette, usa il metodo setColor() per passare il nome di un widget di cui vuoi cambiare il colore e il colore che vuoi che venga impostato.

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

Questo cambierà il colore della finestra in nero. Dopo aver definito la combinazione di colori, utilizza la funzione setPalette() per applicare la tavolozza alla tua applicazione.

app.setPalette(qp)

Questo è tutto ciò che devi fare se vuoi creare alcuni temi di base per la tua app. PyQt ti consente anche di utilizzare fogli di stile per definire l'aspetto dei tuoi widget. Se hai familiarità con i CSS, puoi definire facilmente stili avanzati per la tua app utilizzando i fogli di stile Qt.

Sintesi

• PyQt è il binding python per il C++ Struttura dell'interfaccia utente, Qt.
• PyQt4 e PyQt5 sono le due versioni principali sviluppate da Riverbank Computing.
• I moduli principali del framework PyQt sono:
1. Qt
2. QtCore
3. QtWidget
4. QtGui
5. QtSql
6. QtNetwork
• PyQt supporta vari widget come:
1. Bottoni
2. Etichette di testo
3. Campi di testo
4. Pulsanti di scelta e caselle di controllo
5. Barre degli strumenti e barre dei menu
6. webkit
7. Tabs
8. Docks
• In PyQt, l'interattività viene implementata utilizzando Segnali and slots.
• An evento è un'azione eseguita da un utente nella GUI (come fare clic su un pulsante).
• A segnale viene generato dal widget corrispondente quando si verifica un evento su di esso.
• A fessura è una funzione connessa al segnale ed eseguita quando il segnale viene alzato.
• PyQt ha un motore di layout robusto e supporta la progettazione e la gestione avanzata del layout. Questi sono due schemi di layout usati frequentemente in PyQt:
1. Box disposizione
2. Griglia layout
• PyQt Designer ti consente di creare temi personalizzati per l'applicazione GUI e dispone del supporto integrato per i fogli di stile.
• qtcreator Python può essere utilizzato per creare interfacce utente e applicazioni autonome.