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

Wat is PyQt?

PyQt is een python-binding van de open-source widget-toolkit Qt, die ook functioneert als een platform voor platformonafhankelijke applicatie-ontwikkeling. Qt is een populair C++-framework voor het schrijven van GUI-applicaties voor alle belangrijke desktop-, mobiele en embedded platforms (ondersteunt Linux, Windows, MacOS, Android, iOS, Raspberry Pi en meer).

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.

In deze PyQt5-zelfstudie leert u:

Kenmerken van PyQT
PyQt-versies
PyQt5 installeren
Basis PyQt-concepten en -programma's
Componenten en widgets
Thema's

Kenmerken van PyQT

Hier zijn belangrijke kenmerken van PyQt:

Leer PyQt, dat bestaat uit meer dan zeshonderd lessen 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 toepassingen te creëren. Veel grote bedrijven in alle sectoren gebruiken Qt. Enkele voorbeelden zijn LG, Mercedes, AMD, Panasonic, Harman, enz.

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 een binding biedt voor alleen de 5.x-versies. Als gevolg hiervan is PyQt5 niet achterwaarts compatibel met de verouderde modules van de oudere versie. In deze Qt GUI-zelfstudie wordt PyQt5 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 applicatieraamwerk dat wordt gebruikt om realtime simulatiesystemen te maken met 2D/3D-rendering.

Hoe PyQt5 te installeren

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

Wielbestanden gebruiken
Bouwen en installeren vanaf de bron

Qt (spreek uit 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 vanaf de bron te bouwen en te installeren in vergelijking met andere python-bibliotheken. U kunt PyQt5 echter eenvoudig installeren met behulp van wielen.

Installatie met wielen

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

Dus als je Python 3.4 of hoger hebt geïnstalleerd, heb je al pip. Als u echter een oudere versie van Python gebruikt, moet u pip downloaden en installeren voordat u verder gaat. Je kunt daarvoor instructies zoeken via deze link:https://pypi.org/project/pip/.

Om PyQt5 te installeren,

Stap 1) Open de opdrachtprompt.
Open de opdrachtprompt of PowerShell op uw Windows-computer.

Stap 2) Typ het volgende.

 pip install PyQt5

Stap 3) Installatie geslaagd.
Deze stap in deze PyQt5-zelfstudie zal het PyQt5 whl-pakket (ongeveer 50 MB) downloaden en op uw systeem installeren.

Als alternatief kunt u ook een Windows-binary downloaden voor de versie van python die op uw computer is geïnstalleerd.

Zodra het is voltooid, gaat u verder met het volgende gedeelte in deze PyQt5-zelfstudie om uw eerste GUI-app te schrijven.

Basis PyQt-concepten en programma's

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

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

Start je python IDLE op en typ het volgende:

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

Sla het op als app.py (de naam doet er niet toe) en druk op F5 om het programma uit te voeren. U kunt ook dubbelklikken op uw opgeslagen bestand om de toepassing te starten. Als je alles goed hebt gedaan, wordt er een nieuw venster geopend met de titel Guru99 zoals hieronder weergegeven.

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

from PyQt5.QtWidgets import QApplication, QWidget

Deze instructie importeert alle modules die u nodig hebt om een GUI te maken in de huidige naamruimte. De QtWidgets-module bevat alle belangrijke widgets die u in deze Python Qt-zelfstudie gaat gebruiken.

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 instantie van QApplication maken, als een soort toegangspunt tot de app. Als u het niet maakt, worden fouten weergegeven.

sys.argv is de lijst met opdrachtregelparameters die u aan de toepassing kunt doorgeven bij het starten via de shell of bij het automatiseren van de interface.

In dit PyQt5-voorbeeld heb je geen argumenten doorgegeven aan QApplications. Daarom kun je het ook vervangen door de onderstaande code en hoef je niet eens de sys-module te importeren.

app = QApplication([])

w = QWidget()

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

w.resize(300,300)

Met de methode voor het wijzigen van de grootte van de klasse QWidget kunt u de afmetingen van elke widget instellen. In dit geval heeft u het formaat van het venster aangepast naar 300px bij 300px.

Hier moet u onthouden dat widgets samen kunnen worden genest, de buitenste widget (d.w.z. de widget zonder ouder) wordt een venster genoemd.

w.setWindowTitle("Guru99")

Met de methode setWindowTitle() kunt u een tekenreeks als argument doorgeven waarmee 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 de widget gewoon weer op het beeldscherm.

sys.exit(app.exec_())

De methode app.exec_() start de Qt/C++-gebeurtenislus. Zoals u weet, is PyQt grotendeels geschreven in C ++ en gebruikt het het gebeurtenislusmechanisme om parallelle uitvoering te implementeren. app.exec_() geeft de besturing door aan Qt die de toepassing alleen zal afsluiten wanneer de gebruiker deze vanuit de GUI sluit. Dat is de reden waarom ctrl+c de toepassing niet zal afsluiten zoals in andere python-programma's. Omdat Qt controle heeft over de app, worden python-gebeurtenissen niet verwerkt, tenzij we ze in de applicatie hebben ingesteld. Merk ook op dat de exec-methode een onderstrepingsteken in zijn naam heeft; dit komt omdat exec() al een sleutelwoord was in python en het onderstrepingsteken het naamgevingsconflict oplost.

Voorbij lege vensters

In het vorige gedeelte heb je gezien hoe je een basiswidget kunt maken in Qt. Het is nu tijd om wat meer betrokken interfaces te maken waarmee de gebruikers echt kunnen communiceren. Start nogmaals je 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 wat je maar wilt en druk op F5 om het programma uit te voeren. Als je geen fouten hebt gemaakt, zal de IDLE een nieuw venster openen met wat tekst en een knop zoals hieronder getoond.

Zodra u op de knop in het eerste venster klikt, wordt een nieuw berichtvenster geopend met de tekst die u had geschreven.
U kunt nu op de knop Details verbergen/Details weergeven klikken om de zichtbaarheid van extra tekst in te schakelen.

Zoals je kunt zien, werd er een standaardtitel geleverd door python zelf, aangezien we geen venstertitel in het berichtvenster hadden ingesteld.

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

Dit importeert wat meer widgets die je hebt gebruikt in PyQt5-voorbeelden, 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 dialoog gedefinieerd waarmee een widget voor een berichtvenster wordt gemaakt en wat tekst wordt toegevoegd aan de knoppen en andere velden.

De dialoogmethode wordt aangeroepen vanuit het hoofdblok van het programma wanneer een knop wordt ingedrukt 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. Zo'n functie heet een slot in Qt, en je leert meer over signalen en slots 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 begin je met het maken van een instantie van QApplication gevolgd door een eenvoudige widget, d.w.z. een instantie van QWidget.

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

U hebt in deze toepassing twee nieuwe widgets toegevoegd: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 het label en de btn-objecten maakt, u het vensterobject (w) doorgeeft aan de constructors van QLabel en QPushButton. Dit is hoe nesten werkt in PyQt5. Om een widget in een andere widget te maken, geeft u de verwijzing 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 maken 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-zelfstudie.

btn.clicked.connect(dialog)

Ten slotte 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 muisaanwijzer op een element of het klikken op een knop. Deze acties worden gebeurtenissen genoemd . Bedenk dat de methode app.exec_() de controle overdraagt aan de Qt event- 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, geeft de bijbehorende Qt-widget een signaal . Deze signalen kunnen worden verbonden met python-functies (zoals de dialoogfunctie in dit voorbeeld) zodat de functie wordt uitgevoerd wanneer een signaal wordt geactiveerd. Deze functies heten slots in Qt-jargon.

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

 widget.signal.connect(slot)

Wat betekent dat wanneer een signaal wordt geactiveerd door een widget , het verbonden slot functie zal worden uitgevoerd. Samengevat worden signalen en slots door Qt gebruikt om te communiceren tussen objecten en om 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 handige 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 klassen in verschillende modules en herzieningen in de licenties geweest.

Daarom is het cruciaal om een beeld op hoog niveau te hebben van de structuur van PyQt5. In dit gedeelte 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 de Qt-binding van Python, met name PyQt5.

Qt :Het combineert alle klassen/modules die hieronder worden genoemd in een enkele module. Het verhoogt aanzienlijk het geheugen dat door de toepassing wordt gebruikt. Het is echter gemakkelijker om het framework te beheren door slechts één module te importeren.
QtCore :Bevat de niet-grafische kernklassen die door andere modules worden gebruikt. Dit is waar de Qt-gebeurtenislus, signalen en slot-connectiviteit, enz. worden geïmplementeerd.
QtWidgets :Bevat de meeste widgets die beschikbaar zijn in Pyqt5.
QtGui :Bevat GUI-componenten en breidt de QtCore-module uit.
QtNetwork :Bevat klassen die worden gebruikt om netwerkprogrammering via Qt te implementeren. Het ondersteunt TCP-servers, TCP-sockets, UDP-sockets, SSL-verwerking, netwerksessies en DNS-lookups.
QtMultimedia biedt multimediafunctionaliteit op laag niveau.
QtSql :implementeert database-integratie voor SQL-databases. Ondersteunt ODBC, MySQL, Oracle, SQLite en PostgreSQL.

PyQt5-widgets

Hier is een lijst met de meest gebruikte widgets in PyQt5

QLineEdit :Dit is een invoerveld waarin de gebruiker één regel tekst kan invoeren.
```
line = QLineEdit()
```

QRadioButton :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 van selecteerbare items.
```
drop = QComboBox(w)
drop.addItems(["item one", "item two", "item three"])
```

QCheckBox :geeft een selecteerbaar vierkant vak weer voor het label dat is aangevinkt indien geselecteerd, vergelijkbaar met keuzerondjes.
```
check = QCheckBox("button title")
```

QMenuBar :het toont een horizontale menubalk bovenaan een venster. U kunt alleen objecten van de QMenu-klasse aan deze balk toevoegen. Die QMenu-objecten kunnen verder strings, QAction-objecten of andere QMenu-objecten bevatten.

QToolBar :Het is een horizontale balk of paneel die 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 tabbalk en de tabpagina.

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

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

QDock :Een dock-widget is een subvenster met twee eigenschappen:
Het kan binnen het hoofdvenster worden verplaatst en
Het kan buiten het bovenliggende venster worden gedockt op een andere locatie op het scherm.

Lay-outs en thema's

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

PyQt heeft echter een robuuste lay-outbeheerengine die kan worden gebruikt om geavanceerde gebruikersinterfaces voor applicaties te creëren. In dit gedeelte leer je over twee belangrijke klassen die in Qt worden gebruikt om lay-outs te maken en te beheren.

QBoxLayout
QGridLayout

QBoxLayout

QBoxLayout wordt gebruikt om de onderliggende widgets van de lay-out uit te lijnen in een horizontale of verticale rij. De twee interessante klassen die overerven van QBoxLayout zijn:

QHBoxLayout:gebruikt om de onderliggende widgets horizontaal te lijnen.
QVBoxLayout:gebruikt om de onderliggende widgets verticaal te lijnen.

Dit is bijvoorbeeld hoe drie knoppen die zijn uitgelijnd met QHBoxLayout eruit zullen zien.

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

De enige functie die op dit moment enige uitleg behoeft, is de methode addWidget(). Het wordt gebruikt om widgets in de HBox- of VBox-lay-out in te voegen. Het wordt ook gebruikt in andere lay-outs waar het een ander aantal parameters vereist, 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 rasterlay-out in te voegen, kunt u de matrixweergave gebruiken om het aantal rijen en kolommen in het raster en de positie van die elementen te definiëren.

Als u bijvoorbeeld een 3*3-raster wilt maken (d.w.z. 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() in de rasterlay-out heeft 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 rij-spanwijdte (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_())

Zo ziet het raster eruit:

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

Bijvoorbeeld,

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

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

Thema's

PyQt5 wordt geleverd met enkele ingebouwde thema's die u in uw apps kunt gebruiken. De setStyle() methode aangeroepen op de QApplication-instantie wordt gebruikt om een bepaald thema voor uw toepassing in te stellen.

Als u bijvoorbeeld de volgende regel code toevoegt, verandert het thema van uw toepassing van standaard in Fusion

app.setStyle("Fusion")

Zo ziet het vorige voorbeeld eruit in Fusion Theme

Een andere handige functie voor het thematiseren van uw apps is de methode setPalette(). Hier is de code voor het wijzigen van de kleur van verschillende widgets met behulp van 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 QPalette-klasse tot de QtGui-module behoort en dat u deze moet importeren om dit te laten werken. Nadat u het QPalette-object 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 verandert de kleur van het venster in 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 het 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:

Qt
QtCore
QtWidgets
QtGui
QtSql
QtNetwork

PyQt ondersteunt verschillende widgets zoals:

Knoppen
Tekstlabels
Tekstvelden
Radioknoppen en selectievakjes
Werkbalken en menubalken
Webkit
Tabbladen
Dokken

In PyQt wordt interactiviteit geïmplementeerd met behulp van signalen en slots.
Een evenement is een actie die wordt uitgevoerd door een gebruiker in de GUI (zoals klikken op een knop).
Een signaal wordt verhoogd door de bijbehorende widget wanneer er een gebeurtenis op plaatsvindt.
Een slot 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:

Vakindeling
Rasterindeling

Met PyQt-ontwerper kunt u aangepaste thema's maken voor GUI-applicaties en heeft ingebouwde ondersteuning voor stylesheets.
Qt-maker Python kan worden gebruikt om zowel gebruikersinterfaces als standalone applicaties te maken.

Python XML Parser-zelfstudie:voorbeeld van xml-bestand lezen (Minidom, ElementTree) Multithreading in Python met voorbeeld:leer GIL in Python

Python