Tutorial PyQt5 con esempi: Creare Python Interfacce grafiche con Qt

Le sezioni seguenti ti guideranno dalle basi di PyQt all'installazione, ai widget principali, ai layout e ai temi, con esempi funzionanti.

Cos'è PyQt?

PyQt è un Python collegamento del toolkit di widget open-source Qt, che funziona anche come framework di sviluppo di applicazioni multipiattaforma. Qt è un popolare C++ framework per la scrittura di applicazioni GUI per tutte le principali piattaforme desktop, mobili e embedded (supporta Linux, Windows, macOS, Android, iOS, Raspberry Pi e altro).

PyQt è un software libero sviluppato e gestito da Riverbank Computing, un'azienda con sede in Inghilterra, mentre Qt è sviluppato da un'azienda finlandese chiamata The Qt Company.

Caratteristiche di PyQt

Ecco le caratteristiche importanti di PyQt:

PyQt è composto da oltre seicento classi che coprono una vasta gamma di funzionalità, tra cui:

• 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 e Harman.

Versioni PyQt

PyQt è disponibile in due edizioni, PyQt4 e PyQt5. PyQt4 fornisce il codice di collegamento per le versioni 4.x e 5.x del framework Qt, mentre PyQt5 fornisce un collegamento solo per le versioni 5.x. Di conseguenza, PyQt5 non è retrocompatibile con i moduli deprecati della versione precedente. In questo tutorial GUI di PyQt, verrà utilizzato PyQt5 per la dimostrazione degli esempi. Oltre a queste due versioni, Riverbank Computing fornisce anche PyQt3D. Python Binding 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 nascosto. Di conseguenza, è un processo complicato da compilare e installare dal codice sorgente rispetto ad altri Python librerie. Tuttavia, è possibile installare facilmente PyQt5 utilizzando i file wheel.

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 PythonPrima di procedere, è necessario scaricare e installare pip. Puoi trovare le istruzioni 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 installato 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 correttamente PyQt5 sul tuo computer, sei pronto a scrivere Python Applicazioni con interfaccia grafica (GUI).

Iniziamo questo tutorial su PyQt5 con una semplice applicazione che visualizzerà una finestra vuota sullo schermo.

Accendi il tuo Python 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 è importante) e premi F5 per eseguire il programma. In alternativa, fai 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.

Ottimo! Funziona. Non è molto, ma è sufficiente per comprendere le basi. Ora, in questo tutorial su PyQt, vediamo nel 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 QApplication. Pertanto, puoi sostituirlo con il codice seguente e non dovrai 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.

In questo caso, è importante ricordare che i widget possono essere annidati; il widget più esterno (ovvero il widget senza un elemento padre) è chiamato Finestra.

w.setWindowTitle("Guru99")

Il metodo setWindowTitle() consente di passare una stringa come argomento che imposterà il titolo della finestra sulla stringa passata. 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 utilizza il meccanismo del ciclo di eventi per implementare l'esecuzione parallela. app.exec_() passa il controllo a Qt, che chiuderà l'applicazione solo quando l'utente la chiude dall'interfaccia grafica. Ecco perché ctrl+c non chiuderà l'applicazione come in altri casi. Python programmi. Poiché Qt ha il controllo sull'app, Python Gli eventi non vengono elaborati a meno che non li impostiamo all'interno dell'applicazione. Inoltre, si noti che il metodo exec ha un underscore 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. Ora è il momento di creare interfacce più complesse con cui gli utenti possano interagire veramente. Di nuovo, avvia 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 commesso 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 puoi vedere, poiché non avevamo impostato alcun titolo di finestra nella casella di messaggio, è stato fornito un titolo predefinito da Python stessa.

Ora che funziona, diamo un'occhiata al codice aggiuntivo che hai inserito nell'esempio PyQt5 precedente.

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 su GUI, le funzioni vengono eseguite in base alle azioni eseguite dall'utente, come il passaggio del mouse su un elemento o il 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 Python funzioni (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.

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

 widget.signal.connect(slot)

Ciò significa che ogni volta che un 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 d'insieme della struttura di PyQt5. In questa sezione, vedremo come è organizzato internamente PyQt5 e impareremo 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.

• QtQuesto modulo combina tutte le classi/moduli menzionati di seguito in un unico modulo. Ciò aumenta considerevolmente la memoria utilizzata dall'applicazione. Tuttavia, è più facile gestire il framework importando un solo 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.
• QtWidgetContiene 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 multimedialeFornisce 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 più utilizzati 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 radio 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")

• QMenuBarVisualizza una barra dei menu orizzontale nella parte superiore di una finestra. È possibile aggiungere a questa barra solo oggetti della classe QMenu. Tali oggetti QMenu possono a loro volta contenere 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.
• QTabViene utilizzato per suddividere il contenuto di una finestra in più pagine, accessibili tramite diverse schede poste sopra il widget. È composto da due sezioni: la barra delle schede e la pagina delle schede.
• 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, un cursore track, e due pulsanti per far 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.
• QDockUn widget dock è una sottofinestra con due proprietà: può essere spostato all'interno della finestra principale e può essere ancorato 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 a griglia accetta i seguenti argomenti:

• L'oggetto widget che desideri aggiungere alla griglia
• La coordinata x dell'oggetto
• La coordinata y dell'oggetto
• L'intervallo di riga (predefinito = 0)
• Lo spazio col-span (predefinito = 0)

Per comprenderlo meglio, è possibile 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, il tema della tua applicazione cambierà da quello predefinito a Fusion.

app.setStyle("Fusion")

Ecco come apparirà l'esempio precedente nel tema Fusion.

Un'altra funzione utile per personalizzare l'aspetto delle tue app è il metodo setPalette(). Ecco il codice per cambiare il colore di diversi widget utilizzando 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()

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

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

Questo cambierà il colore della finestra in nero. Dopo aver definito la combinazione di colori, usa la funzione setPalette() per applicare la tavolozza all'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.

DOMANDE FREQUENTI