PyQt5-zelfstudie met voorbeelden: ontwerp GUI met PyQt in Python

PyQt is gratis software ontwikkeld en onderhouden door Riverbank Computing, een bedrijf gevestigd in Engeland, terwijl Qt is ontwikkeld door een Fins bedrijf genaamd The Qt Company.

Kenmerken van PyQT

Hier zijn belangrijke kenmerken van PyQt:

Leer PyQt, dat bestaat uit meer dan zeshonderd klassen die een reeks functies omvatten, zoals

• Grafische gebruikersinterfaces
• SQL-databases
• Webtoolkits
• XML-verwerking
• Netwerken

Deze functies kunnen worden gecombineerd om zowel geavanceerde gebruikersinterfaces als zelfstandige applicaties te creëren. Veel grote bedrijven in alle sectoren gebruiken Qt. Enkele voorbeelden zijn LG, Mercedes, AMD, Panasonic, Harman, etc.

PyQt-versies

PyQt is beschikbaar in twee edities, PyQt4 en PyQt5. PyQt4 biedt lijmcode voor het binden van 4.x- en 5.x-versies van het Qt-framework, terwijl PyQt5 alleen een binding biedt voor de 5.x-versies. Als gevolg hiervan is PyQt5 niet achterwaarts compatibel met de verouderde modules van de oudere versie. In deze Qt GUI-tutorial zal PyQt5 worden gebruikt voor de demonstratie van voorbeelden. Afgezien van deze twee versies,

Riverbank Computing biedt ook PyQt3D: de Python-bindingen voor het Qt3D-framework. Qt3D is een applicatieframework dat wordt gebruikt om real-time simulatiesystemen met 2D/3D-rendering te creëren.

Hoe PyQt5 te installeren

In deze PyQt5-tutorial zullen we de twee manieren zien om PyQt te installeren:

• Wheel-bestanden gebruiken
• Bouwen en installeren vanaf de bron

Qt (uitgesproken als schattig) is een complex systeem en de PyQt-codebase bevat gecompileerde C++ en Python code onder de motorkap. Als gevolg hiervan is het een ingewikkeld proces om het te bouwen en te installeren vanuit de bron vergeleken met andere pythonbibliotheken. U kunt PyQt5 echter eenvoudig installeren met behulp van wheels.

Installatie met wielen

Wielen zijn de nieuwe standaard Python verpakking en distributieformaat. Simpel gezegd is een wiel een ZIP-archief met een speciale naam en .wat bestandsextensie. Wielen kunnen worden geïnstalleerd met behulp van pip (Python's pakketbeheerder), die standaard is opgenomen in de recente versies van Python.

Dus, als je hebt Python 3.4 of later geïnstalleerd, hebt u al pip. Als u echter een oudere versie van Python, moet je pip downloaden en installeren voordat je verder kunt gaan. Instructies hiervoor kunt u vinden via deze link: https://pypi.org/project/pip/.

Om PyQt5 te installeren,

Stap 1) Open de opdrachtprompt.
Open de opdrachtprompt of PowerShell in uw Windows machine.

Stap 2) Typ het volgende.

 pip install PyQt5

Stap 3) Installatie voltooid.
Met deze stap in deze PyQt5-tutorial wordt het PyQt5 whl-pakket (ongeveer 50 MB) gedownload en op uw systeem geïnstalleerd.

Als alternatief kunt u ook een Windows binair voor de versie van Python die op uw computer is geïnstalleerd.

Zodra het voltooid is, gaat u verder naar de volgende sectie in deze PyQt5-tutorial om uw eerste GUI-app te schrijven.

Basis PyQt Concepts en programma's

Nu u PyQt5 met succes op uw computer hebt geïnstalleerd, bent u klaar om te schrijven Python GUI-ontwerptoepassingen.

Laten we beginnen met een eenvoudige app in deze PyQt5-tutorial, die een leeg venster op uw scherm zal weergeven.

Start je python IDLE en typ het volgende in:

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

Sla het op als app.py (de naam maakt niet uit) en druk op F5 om het programma te starten. U kunt ook gewoon dubbelklikken op uw opgeslagen bestand om de applicatie te starten. Als u alles goed hebt gedaan, opent er een nieuw venster met de titel Guru99, zoals hieronder weergegeven.

Geweldig! Het werkt. Het is niet veel, maar het is genoeg om de basisbeginselen te begrijpen. Laten we nu in deze PyQt-tutorial in detail bekijken wat elk van de regels in uw programma doet.

from PyQt5.QtWidgets import QApplication, QWidget

Met deze instructie worden alle modules geïmporteerd die u nodig hebt om een ​​GUI in de huidige naamruimte te maken. De QtWidgets-module bevat alle belangrijke widgets die u hierin gaat gebruiken Python Qt-tutorial.

app = QApplication(sys.argv)

Hier maakt u een object van de klasse QApplication. Deze stap is een noodzaak voor PyQt5; elke UI-app moet een exemplaar van QApplication creëren, als een soort toegangspunt tot de app. Als u het niet maakt, worden er fouten weergegeven.

sys.argv is de lijst met opdrachtregelparameters die u aan de toepassing kunt doorgeven wanneer u deze via de shell start of tijdens het automatiseren van de interface.

In dit PyQt5-voorbeeld heeft u geen argumenten doorgegeven aan QApplications. Daarom kunt u het ook vervangen door de onderstaande code en hoeft u niet eens de sys-module te importeren.

app = QApplication([])

w = QWidget()

Vervolgens maken we een object van de QWidget-klasse. QWidget is de basisklasse van alle UI-objecten in Qt en vrijwel alles wat u in een app ziet, is een widget. Dat omvat dialogen, teksten, knoppen, balken, enzovoort. De functie waarmee u complexe gebruikersinterfaces kunt ontwerpen, is dat de widgets genest kunnen worden, d.w.z. u kunt een widget in een widget hebben, die zich in weer een andere widget bevindt. U zult dit in de volgende sectie in actie zien.

w.resize(300,300)

Met de resize-methode van de klasse QWidget kunt u de afmetingen van elke widget instellen. In dit geval hebt u het formaat van het venster gewijzigd naar 300 px bij 300 px.

Hier moet u onthouden dat widgets samen kunnen worden genest; de buitenste widget (dwz de widget zonder ouder) wordt een venster genoemd.

w.setWindowTitle("Guru99")

Met de methode setWindowTitle() kunt u een tekenreeks doorgeven als argument, waardoor de titel van het venster wordt ingesteld op de tekenreeks die u doorgeeft. In het PyQt5-voorbeeld zal de titelbalk Guru99 weergeven.

w.show()

show() geeft eenvoudigweg de widget weer op het beeldscherm.

sys.exit(app.exec_())

De app.exec_() methode start de Qt/C++ gebeurtenis lus. Zoals u weet is PyQt grotendeels geschreven C++ en gebruikt het event loop-mechanisme om parallelle uitvoering te implementeren. app.exec_() geeft de controle door aan Qt, die de applicatie alleen zal verlaten wanneer de gebruiker deze sluit vanuit de GUI. Daarom zal ctrl+c de applicatie niet verlaten zoals in andere python-programma's. Omdat Qt controle heeft over de app, worden python-gebeurtenissen niet verwerkt, tenzij we ze in de applicatie instellen. Merk ook op dat de exec-methode een underscore in zijn naam heeft; dit komt omdat exec() al een trefwoord was in python en de underscore naamgevingsconflicten oplost.

Achter lege ramen

In de vorige sectie hebt u gezien hoe u een basiswidget kunt maken in Qt. Het is nu tijd om wat meer betrokken interfaces te maken waarmee de gebruikers echt kunnen communiceren. Nogmaals, start uw IDLE en schrijf het volgende.

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

Sla het bestand op als appone.py of iets anders dat je leuk vindt en druk op F5 om het programma te starten. Als je geen fouten hebt gemaakt, is de IDLE opent een nieuw venster met wat tekst en een knop, zoals hieronder weergegeven.

1. Zodra u op de knop in het eerste venster klikt, wordt er een nieuw berichtenvak geopend met de tekst die u hebt geschreven.
2. U kunt nu op de knop Details verbergen/Details weergeven klikken om de zichtbaarheid van extra tekst in of uit te schakelen.

Zoals u kunt zien, hebben we geen venstertitel in het berichtvenster opgegeven. Python zelf heeft een standaardtitel aangeleverd.

Nu het werkt, gaan we eens kijken naar de extra code die je hebt toegevoegd aan het vorige PyQt5-voorbeeld.

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

Hiermee worden nog enkele widgets geïmporteerd die u in PyQt5-voorbeelden hebt gebruikt, namelijk QLabel, QPushButton en 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_()

Hier hebt u een methode met de naam dialog gedefinieerd die een berichtenvakwidget maakt en tekst toevoegt aan de knoppen en andere velden.

De dialoogmethode wordt aangeroepen vanuit het hoofdblok van het programma wanneer er op een knop wordt gedrukt in een specifieke widget (in dit geval de btn PushButton). De klikgebeurtenis die op die knop wordt geactiveerd, zorgt ervoor dat deze functie wordt uitgevoerd. Een dergelijke functie wordt in Qt een slot genoemd, en u zult er meer over te weten komen signalen en speelautomaten in de komende paragrafen.

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

Dit is het hoofdgedeelte van de app en net als in het vorige voorbeeld begint u met het maken van een exemplaar van QApplication, gevolgd door een eenvoudige widget, dat wil zeggen een exemplaar van QWidget.

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

U heeft twee nieuwe widgets toegevoegd aan deze applicatie: QLabel en QPushButton. QLabel wordt gebruikt om niet-bewerkbare tekst of tijdelijke aanduidingen in een widget af te drukken, terwijl QPushButton wordt gebruikt om een ​​klikbare knop te maken.

Het belangrijkste om op te merken is dat wanneer u de objecten label en btn maakt, u het window-object (w) doorgeeft aan de constructors van QLabel en QPushButton. Dit is hoe nesten werkt in PyQt5. Om een ​​widget binnen een andere widget te maken, geeft u de referentie van de bovenliggende widget door aan de constructor van het kind.

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

move() wordt gebruikt om de positie van een widget ten opzichte van zijn bovenliggende widget in te stellen. In het eerste geval wordt het label 100px vanaf de linkerkant en 130px vanaf de bovenkant van het venster verplaatst.

Op dezelfde manier wordt de knop 110 px vanaf de linkerkant en 150 px vanaf de bovenkant van het venster geplaatst. Dit voorbeeld is een ruwe manier om lay-outs te verkrijgen en wordt over het algemeen niet gebruikt in de productie; het is hier alleen opgenomen voor leerdoeleinden. Qt ondersteunt verschillende lay-outs die u in detail zult zien in de komende secties van deze PyQt-tutorial.

btn.clicked.connect(dialog)

Tenslotte is dit een voorbeeld van signalen en slots in Qt. In op GUI gebaseerde applicaties worden functies uitgevoerd op basis van de acties die door de gebruiker worden uitgevoerd, zoals de muis over een element bewegen of op een knop klikken. Deze acties worden genoemd events. Bedenk dat de methode app.exec_() de controle overdraagt ​​aan de Qt evenement-lus. Dit is waar de gebeurtenislus voor is: om naar gebeurtenissen te luisteren en als reactie daarop acties uit te voeren.

Telkens wanneer een gebeurtenis plaatsvindt, zoals een gebruiker die op een knop klikt, verhoogt de overeenkomstige Qt-widget een signaal. Deze signalen kunnen worden aangesloten Python-functies (zoals de dialoogfunctie in dit voorbeeld), zodat de functie wordt uitgevoerd wanneer een signaal wordt geactiveerd. Deze functies worden genoemd speelautomaten in Qt-jargon.

Vervolgens is de basissyntaxis voor het activeren van een slotfunctie als reactie op het signaal van een gebeurtenis als volgt

 widget.signal.connect(slot)

Dat betekent dat wanneer a signaal wordt geactiveerd door een widget, de verbonden sleuf functie zal worden uitgevoerd. Samenvattend worden signalen en slots door Qt gebruikt om tussen objecten te communiceren en de herbruikbaarheid en interactiviteit van componenten te vergemakkelijken.

Nu u weet hoe u widgets kunt nesten en interacties kunt implementeren met behulp van signalen en slots, vindt u hier een lijst met nuttige widgets en andere klassen die u in uw PyQt-apps kunt gebruiken.

Componenten en widgets

Er is een groot aantal widgets beschikbaar in PyQt voor het maken van GUI-apps. Met PyQt5 is er echter een herschikking van de klassen in verschillende modules en herzieningen van de licenties geweest.

Daarom is het cruciaal om een ​​overzicht op hoog niveau te hebben van de structuur van PyQt5. In deze sectie ziet u hoe PyQt5 intern is georganiseerd en leert u over de verschillende modules, bibliotheken en API-klassen die door PyQt5 worden aangeboden.

PyQt5-directorystructuur

Dit zijn de fundamentele modules die worden gebruikt door Python's Qt-binding, specifiek PyQt5.

• Qt: Het combineert alle onderstaande klassen/modules in één enkele module. Het vergroot aanzienlijk het geheugen dat door de applicatie wordt gebruikt. Het is echter eenvoudiger om het raamwerk te beheren door slechts één module te importeren.
• QtCore: Bevat de belangrijkste niet-grafische klassen die door andere modules worden gebruikt. Dit is waar de Qt-gebeurtenislus, signalen en slotconnectiviteit, enz. worden geïmplementeerd.
• QtWidgets: Bevat de meeste widgets die beschikbaar zijn in Pyqt5.
• QtGui: Bevat GUI-componenten en breidt de QtCore-module uit.
• QtNetwerk: Bevat klassen die worden gebruikt om netwerkprogrammering via Qt te implementeren. Het ondersteunt TCP-servers, TCP-sockets, UDP-sockets, SSL-afhandeling, netwerksessies en DNS-lookups.
• Qt Multimedia biedt multimediafunctionaliteit op laag niveau.
• QtSQL: implementeert database-integratie voor SQL-databases. Ondersteunt ODBC, MySQL, Oracle, SQLiteen PostgreSQL.

PyQt5-widgets

Hier is een lijst met de meest gebruikte widgets in PyQt5

• QLineBewerken: Dit is een invoerveld waarin de gebruiker één regel tekst kan invoeren.

  line = QLineEdit()

• QRadioKnop: Dit is een invoerveld met een selecteerbare knop, vergelijkbaar met de keuzerondjes in html.

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

• QComboBox: Het wordt gebruikt om een ​​vervolgkeuzemenu weer te geven met een lijst met selecteerbare items.

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

• QControleerBox: Geeft een selecteerbaar vierkant vakje weer vóór het label dat wordt aangevinkt als het is geselecteerd, vergelijkbaar met keuzerondjes.

  check = QCheckBox("button title")

• QMenubalk: het geeft een horizontale menubalk weer bovenaan een venster. U kunt alleen objecten van de klasse QMenu aan deze balk toevoegen. Deze QMenu-objecten kunnen verder strings, QAction-objecten of andere QMenu-objecten bevatten.

• QToolBar: Het is een horizontale balk of paneel dat binnen het venster kan worden verplaatst. Het kan knoppen en andere widgets bevatten.

• QTab: het wordt gebruikt om de inhoud van een venster op te splitsen in meerdere pagina's die toegankelijk zijn via verschillende tabbladen bovenaan de widget. Het bestaat uit twee secties: de tabbladbalk en de tabbladpagina.

• QScrollBar: Het wordt gebruikt om schuifbalken te maken waarmee de gebruiker binnen een venster omhoog en omlaag kan scrollen. Het bestaat uit een beweegbare schuifregelaar, een schuifregelaar en twee knoppen om de schuifregelaar omhoog of omlaag te schuiven.

  scroll = QScrollBar()

• QSplitser: Splitters worden gebruikt om de inhoud van een venster te scheiden, zodat de widgets correct worden gegroepeerd en er niet rommelig uitzien. QSplitter is een van de primaire lay-outhandlers die beschikbaar zijn in PyQt5 en wordt gebruikt om de inhoud zowel horizontaal als verticaal te splitsen.

• QDock: Een dockwidget is een subvenster met twee eigenschappen:
• Het kan binnen het hoofdvenster worden verplaatst en
• Het kan buiten het bovenliggende venster worden vastgezet op een andere locatie op het scherm.

Lay-outs en thema's

In de vorige PyQt5-voorbeelden hebt u alleen de methoden move() en resize() gebruikt om de posities van widgets in uw GUI in te stellen.

PyQt heeft echter een robuuste layoutbeheer-engine die kan worden gebruikt om geavanceerde gebruikersinterfaces voor applicaties te creëren. In deze sectie leert u over twee belangrijke klassen die in Qt worden gebruikt om lay-outs te maken en te beheren.

1. QBoxLayout
2. QGridLayout

QBoxLayout

QBoxLay-out wordt gebruikt om de onderliggende widgets van de lay-out in een horizontale of verticale rij uit te lijnen. De twee belangenklassen die erven van QBoxIndeling zijn:

• QHBoxLay-out: wordt gebruikt om de onderliggende widgets horizontaal uit te lijnen.
• QVBoxLay-out: wordt gebruikt om de onderliggende widgets verticaal uit te lijnen.

Dit is bijvoorbeeld hoe drie knoppen uitgelijnd zijn met QHBoxDe lay-out zal eruitzien.

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

En zo zullen ze er in QV uitzienBoxLay-out.

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

De enige functie die op dit moment enige uitleg behoeft, is de methode addWidget(). Het wordt gebruikt om widgets in te voegen in de HBox of VBox indeling. Het wordt ook gebruikt in andere lay-outs waar een ander aantal parameters nodig is, zoals u in de volgende sectie zult zien. De widgets verschijnen in de lay-out in de volgorde waarin u ze invoegt.

QGridLayout

QGridLayout wordt gebruikt om interfaces te maken waarin de widgets zijn opgemaakt in de vorm van een raster (zoals een matrix of 2D-array). Om elementen in een rasterindeling in te voegen, kunt u de matrixweergave gebruiken om het aantal rijen en kolommen in het raster te definiëren, evenals de positie van die elementen.

Om bijvoorbeeld een 3*3-raster te maken (dat wil zeggen, een raster met drie rijen en drie kolommen), schrijft u de volgende code:

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

Dit wordt de uitvoer:

De methode addWidget() heeft in de rasterindeling de volgende argumenten:

• Het widgetobject dat u aan het raster wilt toevoegen
• De x-coördinaat van het object
• De y-coördinaat van het object
• De rijreeks (standaard =0)
• De col-span (standaard=0)

Om het beter te begrijpen, kunt u elke widget handmatig invoegen, zoals hieronder weergegeven

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

Dit is hoe het raster eruit zal zien:

U kunt ook de parameters rowspan en colspan doorgeven aan addWidget() om meer dan één rij of kolom te omspannen.

Bijvoorbeeld

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

Hierdoor wordt een knop gemaakt die zich over beide kolommen uitstrekt.

Thema's

PyQt5 wordt geleverd met een aantal ingebouwde thema’s die u in uw apps kunt gebruiken. De setStijl() De methode die wordt aangeroepen op het QApplication-exemplaar wordt gebruikt om een ​​bepaald thema voor uw toepassing in te stellen.

Als u bijvoorbeeld de volgende regel code toevoegt, wordt het thema van uw applicatie gewijzigd van standaard naar Fusion

app.setStyle("Fusion")

Dit is hoe het vorige voorbeeld eruit zal zien in Fusion Theme

Een andere handige functie voor het thematiseren van uw apps is de setPalette() -methode. Hier is de code voor het wijzigen van de kleur van verschillende widgets met 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_())

Hier is het resultaat.

Om de methode setPalette() te gebruiken, moet u eerst een palet definiëren. Dit wordt gedaan door een object van de klasse QPalette te maken.

 qp = QPalette()

Merk op dat de klasse QPalette tot de QtGui-module behoort en dat u deze moet importeren om dit te laten werken. Nadat u het object QPalette hebt gemaakt, gebruikt u de methode setColor() om de naam door te geven van een widget waarvan u de kleur wilt wijzigen en de kleur die u wilt instellen.

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

Hierdoor wordt de kleur van het venster zwart. Nadat u uw kleurenschema hebt gedefinieerd, gebruikt u de functie setPalette() om het palet op uw toepassing toe te passen.

app.setPalette(qp)

Dat is alles wat u hoeft te doen als u enkele basisthema's voor uw app wilt maken. Met PyQt kunt u ook stylesheets gebruiken om het uiterlijk van uw widgets te definiëren. Als u bekend bent met CSS, kunt u eenvoudig geavanceerde stijlen voor uw app definiëren met behulp van Qt Style Sheets.

Samenvatting

• PyQt is de python-binding voor de C++ UI-framework, Qt.
• PyQt4 en PyQt5 zijn de twee belangrijkste versies die zijn ontwikkeld door Riverbank Computing.
• De belangrijkste modules van het PyQt-framework zijn:
1. Qt
2. QtCore
3. QtWidgets
4. QtGui
5. QtSQL
6. QtNetwerk
• PyQt ondersteunt verschillende widgets zoals:
1. Knopen
2. Tekstlabels
3. Tekstvelden
4. Keuzerondjes en selectievakjes
5. Werkbalken en menubalken
6. webkit
7. Tabs
8. Docks
• In PyQt wordt interactiviteit geïmplementeerd met behulp van signalen en slots.
• An gebeurtenis is een actie die wordt uitgevoerd door een gebruiker in de GUI (zoals klikken op een knop).
• A signaal wordt gegenereerd door de overeenkomstige widget wanneer er een gebeurtenis op plaatsvindt.
• A sleuf is een functie die is verbonden met het signaal en wordt uitgevoerd wanneer het signaal wordt verhoogd.
• PyQt heeft een robuuste lay-outengine en ondersteunt geavanceerd lay-outontwerp en -beheer. Dit zijn twee veelgebruikte lay-outschema's in PyQt:
1. Box Layout
2. Grid Layout
• Met PyQt-ontwerper kunt u aangepaste thema's maken voor GUI-toepassingen en heeft ingebouwde ondersteuning voor stijlbladen.
• qtcreator Python kan worden gebruikt om zowel gebruikersinterfaces als zelfstandige applicaties te creëren.