PyQt5-zelfstudie met voorbeelden: Aanmaken Python GUI's met Qt

De onderstaande secties leiden u van de basisprincipes van PyQt tot installatie, kernwidgets, lay-outs en thema's met werkende voorbeelden.

Wat is PyQt?

PyQt is een Python binding van de open-source widget-toolkit Qt, die ook functioneert als een platformonafhankelijk framework voor applicatieontwikkeling. Qt is een populaire C++ framework voor het schrijven van GUI-applicaties voor alle belangrijke desktop-, mobiele en embedded platforms (het 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 ontwikkeld wordt door een Fins bedrijf genaamd The Qt Company.

Kenmerken van PyQt

Hier zijn belangrijke kenmerken van PyQt:

PyQt bestaat uit meer dan zeshonderd klassen die een breed scala aan functies bestrijken, zoals:

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

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

PyQt-versies

PyQt is beschikbaar in twee edities: PyQt4 en PyQt5. PyQt4 biedt verbindingscode voor de 4.x- en 5.x-versies van het Qt-framework, terwijl PyQt5 alleen een verbinding biedt voor de 5.x-versies. Hierdoor is PyQt5 niet achterwaarts compatibel met de verouderde modules van de oudere versie. In deze PyQt GUI-tutorial wordt PyQt5 gebruikt voor de demonstratie van voorbeelden. Naast deze twee versies biedt Riverbank Computing ook PyQt3D aan. Python Bindings voor het Qt3D-framework. Qt3D is een applicatie-framework dat wordt gebruikt om realtime 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. Daardoor is het compileren en installeren vanuit de broncode een gecompliceerd proces in vergelijking met andere systemen. Python bibliotheken. Je 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 PythonJe moet eerst pip downloaden en installeren voordat je verder kunt gaan. Je kunt instructies 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 binaire code voor de versie van Python geïnstalleerd op uw computer.

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 je PyQt5 succesvol op je computer hebt geïnstalleerd, ben je klaar om te schrijven. Python GUI-applicaties.

Laten we in deze PyQt5-tutorial beginnen met een eenvoudige app die een leeg venster op je scherm weergeeft.

Steek je aan 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 bestand op als app.py (de naam maakt niet uit) en druk op F5 om het programma uit te voeren. Je kunt ook dubbelklikken op het opgeslagen bestand om de applicatie te starten. Als je alles goed hebt gedaan, wordt er een nieuw venster geopend met de titel Guru99 zoals hieronder weergegeven.

Geweldig! Het werkt. Het is niet veel, maar het is genoeg om de basis te begrijpen. Laten we in deze PyQt-tutorial eens gedetailleerd bekijken wat elke regel in je 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 heb je geen argumenten doorgegeven aan QApplication. Je kunt het daarom ook vervangen door de onderstaande code en hoeft zelfs de sys-module niet 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.

Hierbij is het belangrijk te onthouden dat widgets in elkaar genesteld kunnen worden; de buitenste widget (dat wil zeggen, 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 opgegeven tekenreeks. In het PyQt5-voorbeeld zal de titelbalk het volgende weergeven: Guru99.

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 maakt gebruik van het event loop-mechanisme om parallelle uitvoering te implementeren. `app.exec_()` geeft de controle door aan Qt, die de applicatie alleen afsluit wanneer de gebruiker deze via de GUI sluit. Daarom sluit Ctrl+C de applicatie niet af zoals in andere gevallen. Python programma's. Omdat Qt de controle over de app heeft, Python Gebeurtenissen worden pas verwerkt als we ze binnen de applicatie instellen. Merk ook op dat de `exec`-methode een underscore in de naam heeft; dit komt omdat `exec()` al een sleutelwoord was in de applicatie. Python En de underscore lost het naamgevingsconflict op.

Achter lege ramen

In het vorige gedeelte zag je hoe je een basiswidget in Qt maakt. Nu is het tijd om wat complexere interfaces te maken waarmee gebruikers echt kunnen interageren. Start je Qt-programma opnieuw op. 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 een andere naam naar keuze en druk op F5 om het programma uit te voeren. Als je geen fouten hebt gemaakt, zou het programma moeten starten. 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, werd er een standaardtitel weergegeven omdat we geen venstertitel in het berichtenvenster hadden ingesteld. Python zelf.

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

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, begin je met het maken van een instantie van QApplication, gevolgd door een eenvoudige widget, oftewel een instantie 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)

Tot slot is dit een voorbeeld van signalen en slots in Qt. In GUI-gebaseerde applicaties worden functies uitgevoerd op basis van acties van de gebruiker, zoals het bewegen van de muis over een element of het klikken op een knop. Deze acties worden aangeroepen. events. Bedenk dat de methode app.exec_() de controle overdraagt ​​aan de Qt gebeurtenis 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.

De basissyntaxis om een ​​slotfunctie te activeren als reactie op een signaal van een gebeurtenis is als volgt:

 widget.signal.connect(slot)

Dit betekent dat telkens wanneer een 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.

Het is daarom cruciaal om een ​​overzicht te hebben van de structuur van PyQt5. In dit gedeelte ziet u hoe PyQt5 intern is georganiseerd en leert u meer over de verschillende modules, bibliotheken en API-klassen die PyQt5 biedt.

PyQt5-directorystructuur

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

• QtHet combineert alle onderstaande klassen/modules in één enkele module. Dit verhoogt het geheugenverbruik van de applicatie aanzienlijk. Het framework is echter gemakkelijker 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.
• QtWidgetsBevat 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

Hieronder vindt u een lijst met de meest gebruikte widgets in PyQt5:

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

line = QLineEdit()

• QRadioKnopDit is een invoerveld met een selecteerbare knop, vergelijkbaar met de keuzeknoppen 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")

• QMenubalkHet toont een horizontale menubalk bovenaan een venster. Je kunt alleen objecten van de klasse QMenu aan deze balk toevoegen. Deze QMenu-objecten kunnen vervolgens 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.
• QTabHet wordt gebruikt om de inhoud van een venster op te delen in meerdere pagina's die toegankelijk zijn via verschillende tabbladen boven de widget. Het bestaat uit twee onderdelen: de tabbalk en de tabpagina.
• QScrollBarHet wordt gebruikt om schuifbalken te maken waarmee de gebruiker binnen een venster omhoog en omlaag kan scrollen. Het bestaat uit een beweegbare schuifregelaar en een schuifregelaar. track, en twee knoppen om de schuifregelaar omhoog of omlaag te bewegen.

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.
• QDockEen dock-widget is een subvenster met twee eigenschappen: het kan binnen het hoofdvenster worden verplaatst en het kan buiten het hoofdvenster op een andere locatie op het scherm worden vastgezet.

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 addWidget()-methode in de grid-layout accepteert 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 rijspan (standaard = 0)
• De kolomspan (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, verandert het thema van uw applicatie van het standaardthema naar Fusion.

app.setStyle("Fusion")

Zo zal het vorige voorbeeld eruitzien in het Fusion-thema.

Een andere handige functie voor het thematiseren van je apps is de setPalette()-methode. 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_())

Dit 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 aangemaakt, gebruikt u de setColor()-methode om de naam van een widget waarvan u de kleur wilt wijzigen en de gewenste kleur door te geven.

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

Hierdoor wordt de kleur van het venster zwart. Nadat je je kleurenschema hebt gedefinieerd, gebruik je de functie setPalette() om het palet op je applicatie 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.

Veelgestelde vragen