PyQt5 Tutorial med eksempler: Design GUI ved hjælp af PyQt in Python

PyQt er en gratis software udviklet og vedligeholdt af Riverbank Computing, et firma baseret i England, hvorimod Qt er udviklet af et finsk firma kaldet The Qt Company.

Funktioner i PyQT

Her er vigtige funktioner i PyQt:

Lær PyQt, som består af mere end seks hundrede klasser, der dækker en række funktioner som f.eks

• Grafiske brugergrænseflader
• SQL databaser
• Webværktøjssæt
• XML-behandling
• netværk

Disse funktioner kan kombineres for at skabe avancerede brugergrænseflader såvel som selvstændige applikationer. Mange store virksomheder på tværs af alle brancher bruger Qt. Nogle eksempler er LG, Mercedes, AMD, Panasonic, Harman osv.

PyQt versioner

PyQt er tilgængelig i to udgaver, PyQt4 og PyQt5. PyQt4 giver limkode til binding af 4.x- og 5.x-versioner af Qt-rammerne, mens PyQt5 kun giver binding til 5.x-versionerne. Som et resultat er PyQt5 ikke bagudkompatibel med de forældede moduler i den ældre version. I denne Qt GUI tutorial vil PyQt5 blive brugt til demonstration af eksempler. Bortset fra disse to versioner,

Riverbank Computing leverer også PyQt3D - python-bindingerne til Qt3D-rammeværket. Qt3D er en applikationsramme, der bruges til at skabe realtidssimuleringssystemer med 2D/3D-gengivelse.

Sådan installeres PyQt5

I denne PyQt5 tutorial vil vi se de to måder at installere PyQt på:

• Brug af Wheel-filer
• Bygge og installere fra kilden

Qt (udtales sød) er et komplekst system, og PyQt-kodebasen indeholder kompilerede C++ og Python kode under motorhjelmen. Som et resultat er det en kompliceret proces at bygge og installere det fra kilden sammenlignet med andre pythonbiblioteker. Du kan dog nemt installere PyQt5 ved hjælp af hjul.

Montering med hjul

Hjul er den nye standard Python emballage og distributionsformat. Et hjul er ganske enkelt et ZIP-arkiv med et særligt navn og .WHL filtypenavn. Hjul kan monteres ved hjælp af pip (Python's pakkehåndtering), som er inkluderet som standard i de seneste versioner af Python.

Så hvis du har Python 3.4 eller nyere installeret, har du allerede pip. Hvis du dog bruger en ældre version af Python, skal du downloade og installere pip, før du går videre. Du kan søge efter instruktioner til det på dette link: https://pypi.org/project/pip/.

For at installere PyQt5,

Trin 1) Åbn kommandoprompt.
Åbn kommandoprompten eller PowerShell i din Windows maskine.

Trin 2) Indtast følgende.

 pip install PyQt5

Trin 3) Installationen lykkedes.
Dette trin i denne PyQt5-tutorial vil downloade PyQt5 whl-pakken (ca. 50 MB) og installere den på dit system.

Alternativt kan du også downloade en Windows binær til den version af python, der er installeret på din computer.

Når det er færdigt, skal du fortsætte til næste afsnit i denne PyQt5-tutorial for at skrive din første GUI-app.

Grundlæggende PyQt Concepts og programmer

Nu hvor du har installeret PyQt5 på din computer, er du klar til at skrive Python GUI design applikationer.

Lad os starte med en simpel app i denne PyQt5 tutorial, som viser et tomt vindue på din skærm.

Tænd din python IDLE og indtast følgende:

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

Gem det som app.py (navnet er ligegyldigt), og tryk på F5 for at køre programmet. Alternativt skal du bare dobbeltklikke på din gemte fil for at starte programmet. Hvis du har gjort alt rigtigt, åbnes et nyt vindue med titlen Guru99 som vist nedenfor.

Store! Det virker. Det er ikke meget, men det er nok til at forstå det grundlæggende. Lad os nu i denne PyQt-tutorial se i detaljer, hvad hver af linjerne i dit program gør.

from PyQt5.QtWidgets import QApplication, QWidget

Denne erklæring importerer alle de moduler, du skal bruge for at oprette en GUI til det aktuelle navneområde. QtWidgets-modulet indeholder alle de vigtigste widgets, som du vil bruge i dette Python Qt tutorial.

app = QApplication(sys.argv)

Her opretter du et objekt af QApplication-klassen. Dette trin er en nødvendighed for PyQt5; hver UI-app skal oprette en forekomst af QApplication, som en slags indgangspunkt til appen. Hvis du ikke opretter det, vil der blive vist fejl.

sys.argv er listen over kommandolinjeparametre, som du kan sende til applikationen, når du starter den gennem skallen eller mens du automatiserer grænsefladen.

I dette PyQt5-eksempel har du ikke videregivet nogen argumenter til QApplications. Derfor kan du også erstatte det med koden nedenfor og ikke engang skulle importere sys-modulet.

app = QApplication([])

w = QWidget()

Dernæst laver vi et objekt af QWidget-klassen. QWidget er basisklassen for alle UI-objekter i Qt, og stort set alt, hvad du ser i en app, er en widget. Det inkluderer dialoger, tekster, knapper, bjælker og så videre. Funktionen, der giver dig mulighed for at designe komplekse brugergrænseflader, er, at widgets kan indlejres, dvs. du kan have en widget inde i en widget, som er inde i endnu en widget. Du vil se dette i aktion i næste afsnit.

w.resize(300,300)

Tilpasningsmetoden for QWidget-klassen giver dig mulighed for at indstille dimensionerne for enhver widget. I dette tilfælde har du ændret størrelsen på vinduet til 300px med 300px.

Her skal du huske, at widgets kunne indlejres sammen, den yderste widget (dvs. widgetten uden forælder) kaldes et vindue.

w.setWindowTitle("Guru99")

Metoden setWindowTitle() giver dig mulighed for at sende en streng som et argument, der vil sætte titlen på vinduet til den streng, du sender. I PyQt5-eksemplet vil titellinjen vise Guru99.

w.show()

show() viser blot widgetten på monitorskærmen.

sys.exit(app.exec_())

App.exec_()-metoden starter Qt/C++ begivenhedsløkke. Som du ved, er PyQt stort set skrevet ind C++ og bruger hændelsesløkkemekanismen til at implementere parallel eksekvering. app.exec_() overfører kontrollen til Qt, som kun afslutter applikationen, når brugeren lukker den fra GUI. Det er grunden til, at ctrl+c ikke afslutter programmet som i andre python-programmer. Da Qt har kontrol over appen, behandles python-begivenheder ikke, medmindre vi sætter dem op inde i applikationen. Bemærk også, at exec-metoden har en understregning i sit navn; dette skyldes, at exec() allerede var et nøgleord i python, og understregningen løser navnekonflikter.

Ud over tomme vinduer

I det forrige afsnit så du, hvordan du laver en grundlæggende widget i Qt. Det er nu tid til at lave nogle mere involverede grænseflader, som brugerne virkelig kan interagere med. Igen, fyr op for din IDLE og skriv følgende.

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

Gem filen som appone.py eller noget, du kan lide, og tryk på F5 for at køre programmet. Hvis du ikke har lavet nogen fejl, IDLE åbner et nyt vindue med noget tekst og en knap som vist nedenfor.

1. Når du klikker på knappen i det første vindue, åbnes en ny beskedboks med den tekst, du har skrevet.
2. Du kan nu klikke på knappen Skjul detaljer/Vis detaljer for at skifte synligheden af ​​yderligere tekst.

Som du kan se, da vi ikke havde angivet nogen vinduestitel i meddelelsesboksen, blev en standardtitel leveret af python selv.

Nu hvor det virker, lad os tage et kig på den ekstra kode, som du har tilføjet til det forrige PyQt5-eksempel.

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

Dette importerer nogle flere widgets, som du har brugt i PyQt5-eksempler, nemlig QLabel, QPushButton og 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_()

Her har du defineret en metode med navnet dialog, som opretter en beskedboks-widget og sætter noget tekst til knapperne og andre felter.

Dialogmetoden kaldes fra programmets hovedblok, når der trykkes på en knap i en specifik widget (i dette tilfælde btn-trykknappen). Klikhændelsen, der udløses på den knap, får denne funktion til at udføres. Sådan en funktion kaldes en slot i Qt, og du vil lære mere om signaler og spillemaskiner i de kommende afsnit.

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

Dette er hovedsektionen af ​​appen, og som i det foregående eksempel starter du med at oprette en instans af QApplication efterfulgt af en simpel widget, altså en instans af QWidget.

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

Du har tilføjet to nye widgets i denne applikation: QLabel og QPushButton. QLabel bruges til at udskrive ikke-redigerbar tekst eller pladsholdere inde i en widget, hvorimod QPushButton bruges til at oprette en klikbar knap.

Det kritiske at bemærke her er, at når du opretter label- og btn-objekterne, videregiver du vinduesobjektet (w) til konstruktørerne af QLabel og QPushButton. Sådan fungerer nesting i PyQt5. For at oprette en widget inde i en anden widget sender du referencen for den overordnede widget til barnets konstruktør.

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

move() bruges til at indstille en widgets position i forhold til dens overordnede widget. I det første tilfælde flyttes etiketten 100px fra venstre og 130px fra toppen af ​​vinduet.

På samme måde vil knappen blive placeret 110px fra venstre og 150px fra toppen af ​​vinduet. Dette eksempel er en grov måde at opnå layout på og bruges generelt ikke i produktionen; det er kun inkluderet her i læringsøjemed. Qt understøtter forskellige layouts, som du vil se i detaljer i de kommende afsnit af denne PyQt-tutorial.

btn.clicked.connect(dialog)

Endelig er dette et eksempel på signaler og slots i Qt. I GUI-baserede applikationer udføres funktioner baseret på de handlinger, som brugeren udfører, som at holde musen over et element eller klikke på en knap. Disse handlinger kaldes begivenheder. Husk, at app.exec_() metoden overfører kontrol til Qt begivenhed-sløjfe. Dette er, hvad begivenhedsløkken er til for: at lytte efter begivenheder og udføre handlinger som reaktion.

Når en hændelse indtræffer, som at en bruger klikker på en knap, hæver den tilsvarende Qt-widget en signal. Disse signaler kan tilsluttes python funktioner (som dialogfunktionen i dette eksempel), således at funktionen udføres, når et signal udløses. Disse funktioner kaldes spillemaskiner på Qt-sprog.

Efterfølgende er den grundlæggende syntaks til at udløse en slotfunktion som svar på signalet fra en begivenhed som følger

 widget.signal.connect(slot)

Hvilket betyder, at når en signal udløses af en widget, den tilsluttede slot funktion vil blive udført. Sammenfattende bruges signaler og slots af Qt til at kommunikere mellem objekter og lette komponentgenanvendelighed og interaktivitet.

Nu hvor du ved, hvordan du indlejrer widgets og implementerer interaktioner ved hjælp af signaler og slots, er her en liste over nyttige widgets og andre klasser, som du kan bruge i dine PyQt-apps.

Komponenter og widgets

Der er et stort antal widgets tilgængelige i PyQt til oprettelse af GUI-apps. Men med PyQt5 er der sket en omrokering af klasser til forskellige moduler og revisioner i licenserne.

Derfor er det afgørende at have et overblik over strukturen af ​​PyQt5 på højt niveau. I dette afsnit vil du se, hvordan PyQt5 er organiseret internt og lære om de forskellige moduler, biblioteker og API-klasser leveret af PyQt5.

PyQt5-katalogstruktur

Dette er de grundlæggende moduler, der bruges af Python's Qt-binding, specifikt PyQt5.

• Qt: Den kombinerer alle klasser/moduler nævnt nedenfor i et enkelt modul. Det øger betydeligt den hukommelse, der bruges af applikationen. Det er dog nemmere at administrere rammerne ved kun at importere ét modul.
• QtCore: Indeholder de ikke-grafiske kerneklasser, der bruges af andre moduler. Det er her Qt-hændelsesløkken, signaler og slot-forbindelse osv. implementeres.
• QtWidgets: Indeholder de fleste af de tilgængelige widgets i Pyqt5.
• QtGui: Indeholder GUI-komponenter og udvider QtCore-modulet.
• QtNetværk: Indeholder klasser, der bruges til at implementere netværksprogrammering gennem Qt. Det understøtter TCP-servere, TCP-sockets, UDP-sockets, SSL-håndtering, netværkssessioner og DNS-opslag.
• QtMultimedia giver multimediefunktionalitet på lavt niveau.
• QtSql: implementerer databaseintegration til SQL-databaser. Understøtter ODBC, MySQL, Oracle, SQLiteog PostgreSQL.

PyQt5-widgets

Her er en liste over de mest brugte widgets i PyQt5

• QLineEdit: Dette er et inputfelt, som gør det muligt at indtaste én tekstlinje af brugeren.

  line = QLineEdit()

• QRadio-knap: Dette er et inputfelt med en valgbar knap, svarende til radioknapperne i html.

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

• QComboBox: Den bruges til at vise en rullemenu med en liste over valgbare elementer.

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

• QCheckBox: Viser en valgbar firkantet boks foran etiketten, der er markeret, hvis den er valgt, svarende til alternativknapper.

  check = QCheckBox("button title")

• QMenuBar: den viser en vandret menulinje øverst i et vindue. Du kan kun tilføje objekter fra QMenu-klassen til denne bjælke. Disse QMenu-objekter kan yderligere indeholde strenge, QAction-objekter eller andre QMenu-objekter.

• QToolBar: Det er en vandret bjælke eller rude, som kan flyttes inden for vinduet. Det kan indeholde knapper og andre widgets.

• QTab: det bruges til at opdele indholdet af et vindue i flere sider, der kan tilgås via forskellige faner oven på widgetten. Den består af to sektioner: fanelinjen og fanebladet.

• QScrollBar: Det bruges til at oprette rullepaneler, som giver brugeren mulighed for at rulle op og ned i et vindue. Den består af en bevægelig skyder, et skyderspor og to knapper til at rulle skyderen op eller ned.

  scroll = QScrollBar()

• QSplitter: Splittere bruges til at adskille indholdet af et vindue, så widgets er grupperet korrekt og ikke virker rodet. QSplitter er en af ​​de primære layouthandlere, der er tilgængelige i PyQt5 og bruges til at opdele indholdet både horisontalt og vertikalt.

• QDock: En dock-widget er et undervindue med to egenskaber:
• Det kan flyttes inden for hovedvinduet og
• Den kan forankres uden for forældrevinduet til en anden placering på skærmen.

Layouts og temaer

I de tidligere PyQt5-eksempler har du kun brugt metoderne move() og resize() til at indstille positionerne for widgets i din GUI.

PyQt har dog en robust layoutstyringsmotor, som kan bruges til at skabe avancerede brugergrænseflader til applikationer. I dette afsnit lærer du om to vigtige klasser, der bruges i Qt til at oprette og administrere layouts.

1. QBoxLayout
2. QGridLayout

QBoxLayout

QBoxLayout bruges til at justere layoutets underordnede widgets i en vandret eller lodret række. De to interesseklasser, der arver fra QBoxLayout er:

• QHBoxLayout: bruges til at placere underordnede widgets vandret.
• QVBoxLayout: bruges til at indrette de underordnede widgets lodret.

For eksempel er det sådan, tre knapper er justeret med QHBoxLayoutet vil se ud.

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

Og sådan vil de se ud i 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_())

Den eneste funktion, der behøver nogen forklaring på dette tidspunkt, er addWidget()-metoden. Det bruges til at indsætte widgets i HBox eller VBox layout. Det bruges også i andre layouts, hvor det tager et andet antal parametre, som du vil se i næste afsnit. Widgetterne vises inde i layoutet i den rækkefølge, du indsætter dem i.

QGridLayout

QGridLayout bruges til at skabe grænseflader, hvor widgets er lagt ud i form af et gitter (som en matrix eller 2D-array). For at indsætte elementer i et gitterlayout kan du bruge matrixrepræsentationen til at definere antallet af rækker og kolonner i gitteret samt placeringen af ​​disse elementer.

For at oprette et 3*3-gitter (dvs. et gitter med tre rækker og tre kolonner), skal du for eksempel skrive følgende kode:

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

Dette vil være outputtet:

Metoden addWidget() I gitterlayoutet tager disse argumenter:

• Det widgetobjekt, du vil føje til gitteret
• Objektets x-koordinat
• Objektets y-koordinat
• Rækkevidden (standard =0)
• Col-span (standard=0)

For at forstå det bedre, kan du manuelt indsætte hver widget som vist nedenfor

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

Sådan kommer gitteret til at se ud:

Du kan også sende rowspan- og colspan-parametrene til addWidget() for at spænde over mere end én række eller kolonne.

For eksempel:

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

Dette vil skabe en knap, der strækker sig over begge kolonner.

Temaer

PyQt5 kommer med nogle indbyggede temaer, som du kan bruge i dine apps. Det sætStyle() metode kaldet på QApplication-instansen bruges til at indstille et bestemt tema til din applikation.

For eksempel vil tilføjelse af følgende kodelinje ændre temaet for din applikation fra standard til Fusion

app.setStyle("Fusion")

Sådan vil det forrige eksempel se ud i Fusion Theme

En anden nyttig funktion til at tematisere dine apps er setPalette()-metoden. Her er koden til at ændre farven på forskellige widgets ved hjælp af 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_())

Her er resultatet.

For at bruge metoden setPalette() skal du først definere en palet. Dette gøres ved at oprette et objekt af QPalette-klassen.

 qp = QPalette()

Bemærk, at QPalette-klassen tilhører QtGui-modulet, og du bliver nødt til at importere den, for at dette fungerer. Når du har oprettet QPalette-objektet, skal du bruge metoden setColor() til at videregive navnet på en widget, hvis farve du vil ændre, og den farve du vil indstille.

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

Dette vil ændre farven på vinduet til sort. Når du har defineret dit farveskema, skal du bruge funktionen setPalette() til at anvende paletten på din applikation.

app.setPalette(qp)

Det er alt, du skal gøre, hvis du vil oprette nogle grundlæggende temaer til din app. PyQt giver dig også mulighed for at bruge stylesheets til at definere udseendet af dine widgets. Hvis du er fortrolig med CSS, kan du nemt definere avancerede stilarter til din app ved hjælp af Qt Style Sheets.

Resumé

• PyQt er python-bindingen for C++ UI-ramme, Qt.
• PyQt4 og PyQt5 er de to store versioner udviklet af Riverbank Computing.
• Hovedmodulerne i PyQt frameworket er:
1. Qt
2. QtCore
3. QtWidgets
4. QtGui
5. QtSql
6. QtNetværk
• PyQt understøtter forskellige widgets som:
1. Knapper
2. Tekstetiketter
3. Tekstfelter
4. Alternativknapper og afkrydsningsfelter
5. Værktøjslinjer og menulinjer
6. web kit
7. Tabs
8. Docks
• I PyQt implementeres interaktivitet vha signaler og slots.
• An begivenhed er en handling udført af en bruger i GUI'en (som at klikke på en knap).
• A signal hæves af den tilsvarende widget, når en hændelse opstår på den.
• A slot er en funktion, der er forbundet med signalet og udføres, når signalet hæves.
• PyQt har en robust layoutmotor og understøtter avanceret layoutdesign og -styring. Disse er to ofte brugte layoutskemaer i PyQt:
1. Box Layout
2. Grid layout
• PyQt-designeren giver dig mulighed for at oprette brugerdefinerede temaer til GUI-applikationer og har indbygget understøttelse af typografiark.
• qtcreator Python kan bruges til at skabe brugergrænseflader såvel som selvstændige applikationer.