PyQt5 oktatóanyag példákkal: Létrehozás Python Grafikus felhasználói felületek Qt-vel

Az alábbi szakaszok a PyQt alapjaitól a telepítésen, az alapvető widgeteken, az elrendezéseken és a témákon át vezetnek végig, futtatható példákkal kiegészítve.

Mi az a PyQt?

PyQt egy olyan Python a nyílt forráskódú widget-eszközkészlet Qt kötését, amely egyben platformfüggetlen alkalmazásfejlesztési keretrendszerként is működik. A Qt egy népszerű C++ keretrendszer grafikus alkalmazások írásához minden nagyobb asztali, mobil és beágyazott platformra (támogatja a Linuxot, Windows, macOS, Android, iOS, Raspberry Pi és még sok más).

A PyQt egy ingyenes szoftver, amelyet a Riverbank Computing, egy angliai székhelyű cég fejleszt és tart karban, míg a Qt-t egy finn cég, a The Qt Company fejleszti.

A PyQt funkciói

Íme a PyQt fontos funkciói:

A PyQt több mint hatszáz osztályból áll, amelyek számos funkciót lefednek, mint például:

• Grafikus felhasználói felületek
• SQL adatbázisok
• Webes eszközkészletek
• XML feldolgozás
• hálózatépítés

Ezek a funkciók kombinálhatók fejlett felhasználói felületek és önálló alkalmazások létrehozásához. Számos nagyvállalat használja a Qt-t minden iparágban. Néhány példa erre: LG, Mercedes, AMD, Panasonic és Harman.

PyQt verziók

A PyQt két kiadásban érhető el, PyQt4-ben és PyQt5-ben. A PyQt4 összekötő kódot biztosít a Qt keretrendszer 4.x és 5.x verzióinak kötéséhez, míg a PyQt5 csak az 5.x verziókhoz biztosít kötést. Ennek eredményeként a PyQt5 nem kompatibilis visszafelé a régebbi verzió elavult moduljaival. Ebben a PyQt GUI oktatóanyagban a PyQt5-öt fogjuk használni a példák bemutatásához. E két verzión kívül a Riverbank Computing a PyQt3D-t is biztosítja – a… Python kötések a Qt3D keretrendszerhez. A Qt3D egy alkalmazáskeretrendszer, amelyet valós idejű szimulációs rendszerek létrehozására használnak 2D/3D rendereléssel.

A PyQt5 telepítése

Ebben a PyQt5 oktatóanyagban a PyQt telepítésének két módját fogjuk látni:

• Kerékfájlok használata
• Építés és telepítés forrásból

A Qt (ejtsd: aranyos) egy összetett rendszer, és a PyQt kódbázis lefordított C++ és a Python kód a motorháztető alatt. Ennek eredményeként bonyolultabb folyamat a forrásból lefordítani és telepíteni, mint más Python könyvtárak. A PyQt5-öt azonban könnyen telepítheti kerekek használatával.

Szerelés kerekekkel

A kerekek az új szabvány Python csomagolás és forgalmazási formátum. Egyszerűen szólva a kerék egy ZIP-archívum, amelynek speciális neve és .whl fájl kiterjesztését. A kerekek a pip (Pythoncsomagkezelője), amely alapértelmezés szerint benne van a legújabb verziókban Python.

Tehát, ha van Python 3.4 vagy újabb telepítve van, már van pip. Ha azonban egy régebbi verziót használ Python, a továbblépés előtt le kell töltened és telepítened kell a pip-et. Az utasításokat ezen a linken találod: https://pypi.org/project/pip/.

A PyQt5 telepítéséhez:

Step 1) Nyissa meg a Parancssor parancsot.
Nyissa meg a Parancssort vagy a PowerShellt Windows gépen.

Step 2) Írja be a következőket.

 pip install PyQt5

Step 3) Sikeres telepítés.
A PyQt5 oktatóanyag ezen lépése letölti a PyQt5 whl csomagot (körülbelül 50 MB), és telepíti a rendszerére.

Alternatív megoldásként letöltheti a Windows bináris fájl a következő verzióhoz: Python telepítve van a számítógépre.

Ha elkészült, folytassa a PyQt5 oktatóanyag következő szakaszával az első grafikus felhasználói felület megírásához.

Alapvető PyQt Concepts és Programok

Most, hogy sikeresen telepítette a PyQt5-öt a számítógépére, készen áll az írásra Python Grafikus felhasználói felületű alkalmazások.

Kezdjük egy egyszerű alkalmazással ebben a PyQt5 oktatóanyagban, amely egy üres ablakot jelenít meg a képernyőn.

Gyújtsd be a Python IDLE és írja be a következőket:

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

Mentsd el app.py néven (a név nem számít), és nyomd meg az F5 billentyűt a program futtatásához. Alternatív megoldásként kattints duplán a mentett fájlra az alkalmazás elindításához. Ha mindent jól csináltál, egy új ablak nyílik meg a következő címmel: Guru99, ahogy az alább látható.

Remek! Működik. Nem sok, de elég az alapok megértéséhez. Ebben a PyQt oktatóanyagban most részletesen megnézzük, hogy mit csinálnak a programod sorai.

from PyQt5.QtWidgets import QApplication, QWidget

Ez az utasítás importálja a grafikus felhasználói felület létrehozásához szükséges összes modult az aktuális névtérbe. A QtWidgets modul tartalmazza az összes főbb widgetet, amelyet ebben használni fog Python Qt bemutató.

app = QApplication(sys.argv)

Itt létrehozza a QApplication osztály objektumát. Ez a lépés a PyQt5 számára szükséges; minden UI-alkalmazásnak létre kell hoznia egy QApplication-példányt, mintegy belépési pontként az alkalmazásba. Ha nem hozza létre, hibák jelennek meg.

A sys.argv azon parancssori paraméterek listája, amelyeket átadhat az alkalmazásnak, amikor elindítja azt a shell-en keresztül, vagy amikor automatizálja a felületet.

Ebben a PyQt5 példában nem adtál át argumentumokat a QApplicationnak. Ezért lecserélheted az alábbi kóddal, és még a sys modult sem kell importálnod.

app = QApplication([])

w = QWidget()

Ezután elkészítjük a QWidget osztály objektumát. A QWidget a Qt összes felhasználói felületi objektumának alaposztálya, és gyakorlatilag minden, amit egy alkalmazásban lát, widget. Ide tartoznak a párbeszédpanelek, szövegek, gombok, sávok és így tovább. Az összetett felhasználói felületek tervezését lehetővé tevő funkció az, hogy a widgetek egymásba ágyazhatók, azaz egy widgeten belül lehet egy widget, amely egy újabb widgeten belül van. Ezt működés közben láthatja a következő részben.

w.resize(300,300)

A QWidget osztály átméretezési módszere lehetővé teszi bármely widget méretének beállítását. Ebben az esetben az ablakot 300 x 300 képpontra méretezte át.

Itt ne feledd, hogy a widgetek egymásba is ágyazhatók; a legkülső widgetet (azaz a szülő nélküli widgetet) ablaknak nevezik.

w.setWindowTitle("Guru99")

A setWindowTitle() metódus lehetővé teszi egy karakterlánc argumentumként való átadását, amely az ablak címét az átadott karakterláncra állítja be. A PyQt5 példában a címsor a következőképpen jelenik meg: Guru99.

w.show()

show() egyszerűen megjeleníti a widgetet a monitor képernyőjén.

sys.exit(app.exec_())

Az app.exec_() metódus elindítja a Qt/C++ eseményhurok. Mint tudod, a PyQt nagyrészt be van írva C++ és az eseményciklus mechanizmusát használja a párhuzamos végrehajtás megvalósításához. Az app.exec_() átadja a vezérlést a Qt-nek, amely csak akkor lép ki az alkalmazásból, ha a felhasználó bezárja azt a grafikus felhasználói felületről. Ezért a ctrl+c nem fog kilépni az alkalmazásból, mint más esetekben. Python programok. Mivel a Qt irányítja az alkalmazást, Python Az események nem kerülnek feldolgozásra, hacsak nem állítjuk be őket az alkalmazáson belül. Azt is vedd figyelembe, hogy az exec metódus nevében aláhúzásjel található; ez azért van, mert az exec() már szerepelt kulcsszóként a Python és az aláhúzásjel feloldja az elnevezési ütközést.

Az üres ablakokon túl

Az előző részben láthattad, hogyan készíthetsz egy alapvető widgetet Qt-ben. Most itt az ideje, hogy bonyolultabb felületeket hozzunk létre, amelyekkel a felhasználók valóban interakcióba léphetnek. Indítsd el újra a... IDLE és írja be a következőket.

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

Mentse el a fájlt appone.py vagy bármilyen más néven, és nyomja meg az F5 billentyűt a program futtatásához. Ha nem követett el hibákat, a IDLE egy új ablakot nyit meg szöveggel és egy gombbal, az alábbiak szerint.

1. Miután az első ablakban rákattint a gombra, egy új üzenetablak nyílik meg az Ön által írt szöveggel.
2. Most a Részletek elrejtése/Részletek megjelenítése gombra kattintva kapcsolhatja be a további szövegek láthatóságát.

Amint látható, mivel nem állítottunk be ablakcímet az üzenetmezőben, az alapértelmezett címet a következő adta meg: Python maga.

Most, hogy működik, nézzük meg az előző PyQt5 példához hozzáadott extra kódot.

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

Ez importál néhány további widgetet, amelyeket a PyQt5 példákban használt, nevezetesen a QLabel, QPushButton és 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_()

Itt definiált egy párbeszédpanel nevű metódust, amely létrehoz egy üzenetdoboz widgetet, és beállít néhány szöveget a gombokhoz és más mezőkhöz.

A dialógus metódus a program fő blokkjából hívódik meg, amikor egy adott widgetben (jelen esetben a btn PushButton) megnyomunk egy gombot. Az adott gombon kiváltott kattintási esemény hatására ez a funkció végrehajtódik. Az ilyen függvényt Qt-ben slotnak nevezik, és többet megtudhat róla jelek és a nyílások a következő bekezdésekben.

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

Ez az alkalmazás fő része, és az előző példához hasonlóan először létrehozunk egy QApplication példányt, majd egy egyszerű widgetet, azaz egy QWidget példányt.

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

Két új widgetet adott hozzá ehhez az alkalmazáshoz: QLabel és QPushButton. A QLabel nem szerkeszthető szöveg vagy helyőrzők nyomtatására szolgál egy widgeten belül, míg a QPushButton egy kattintható gomb létrehozására szolgál.

Itt érdemes észrevenni, hogy a címke és a btn objektumok létrehozásakor az ablakobjektumot (w) átadja a QLabel és a QPushButton konstruktorainak. Így működik a beágyazás a PyQt5-ben. Egy másik widgeten belüli widget létrehozásához át kell adnia a szülő widget hivatkozását a gyermek konstruktorának.

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

A move() segítségével beállíthatja a widget pozícióját a szülő widgethez képest. Az első esetben a címke 100 képponttal balról és 130 képponttal az ablak tetejéről kerül áthelyezésre.

Hasonlóképpen, a gomb 110 képpontra kerül az ablak bal oldalától és 150 képpontra az ablak tetejétől. Ez a példa az elrendezések elérésének durva módja, és általában nem használják a termelésben; csak tanulási céllal szerepel itt. A Qt különböző elrendezéseket támogat, amelyeket a PyQt oktatóanyag következő szakaszaiban részletesen látni fog.

btn.clicked.connect(dialog)

Végül pedig íme egy példa a jelekre és a slotokra a Qt-ben. A grafikus felhasználói felület alapú alkalmazásokban a függvények a felhasználó által végrehajtott műveletek alapján hajtódnak végre, például egy elem fölé húzva az egeret, vagy egy gombra kattintva. Ezeket a műveleteket nevezzük események. Emlékezzünk vissza, hogy az app.exec_() metódus átadja a vezérlést a Qt-nek esemény hurok. Erre való az eseményhurok: események figyelésére és válaszként műveletek végrehajtására.

Amikor egy esemény történik, például amikor a felhasználó rákattint egy gombra, a megfelelő Qt widget felveti a jel. Ezek a jelek csatlakoztathatók Python funkciók (mint a párbeszéd funkció ebben a példában), így a funkció akkor kerül végrehajtásra, amikor egy jel aktiválódik. Ezeket a függvényeket ún nyílások Qt nyelven.

Ezt követően egy slot függvény eseményből származó jelre adott válaszának alapvető szintaxisa a következő:

 widget.signal.connect(slot)

Ez azt jelenti, hogy valahányszor egy jel kiváltja a modul, a csatlakoztatott rés funkció végrehajtásra kerül. Összefoglalva, a Qt jeleket és réseket használ az objektumok közötti kommunikációra, valamint az összetevők újrafelhasználhatóságának és interaktivitásának elősegítésére.

Most, hogy tudja, hogyan kell beágyazni a modulokat, és hogyan valósíthat meg interakciókat jelek és helyek segítségével, itt található a PyQt-alkalmazásokban használható hasznos widgetek és egyéb osztályok listája.

Összetevők és widgetek

A PyQt-ban számos widget áll rendelkezésre grafikus felhasználói felületek létrehozásához. A PyQt5 esetében azonban az osztályok különböző modulokba való átrendezése és a licencek átdolgozása történt.

Ezért kulcsfontosságú a PyQt5 szerkezetének átfogó áttekintése. Ebben a részben bemutatjuk, hogyan épül fel a PyQt5 belsőleg, és megismerkedünk a PyQt5 által biztosított különböző modulokkal, könyvtárakkal és API osztályokkal.

PyQt5 címtárstruktúra

Ezeket az alapvető modulokat használja Python's Qt kötés, konkrétan PyQt5.

• Qt: Az alább említett összes osztályt/modult egyetlen modulba egyesíti. Jelentősen megnöveli az alkalmazás által használt memóriát. Ugyanakkor a keretrendszer kezelése egyszerűbb egyetlen modul importálásával.
• QtCore: A többi modul által használt alapvető nem grafikus osztályokat tartalmazza. Itt valósul meg a Qt eseményhurok, a jelek és a slot-kapcsolat stb.
• QtWidgets: A PyQt5-ben elérhető widgetek nagy részét tartalmazza.
• QtGui: GUI összetevőket tartalmaz, és kiterjeszti a QtCore modult.
• QtNetwork: A Qt-n keresztüli hálózati programozás megvalósításához használt osztályokat tartalmazza. Támogatja a TCP szervereket, TCP socketeket, UDP socketeket, SSL-kezelést, hálózati munkameneteket és DNS-kereséseket.
• QtMultimédia: alacsony szintű multimédiás funkciókat biztosít.
• QtSql: SQL adatbázisok adatbázis-integrációját valósítja meg. Támogatja az ODBC-t, MySQL, Oracle, SQLiteés PostgreSQL.

PyQt5 widgetek

Íme a PyQt5 leggyakrabban használt widgetjeinek listája:

• QLineEdit: Ez egy beviteli mező, amely lehetővé teszi egy sor szöveg bevitelét a felhasználó számára.

line = QLineEdit()

• QRadioButton: Ez egy beviteli mező kiválasztható gombbal, hasonlóan a HTML választógombjaihoz.

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

• QComboBox: A kiválasztható elemek listáját tartalmazó legördülő menü megjelenítésére szolgál.

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

• QCheckBox: Kijelölhető négyzet alakú négyzetet jelenít meg a címke előtt, amely ki van jelölve, a rádiógombokhoz hasonlóan.

check = QCheckBox("button title")

• QMenuBar: Egy vízszintes menüsort jelenít meg az ablak tetején. Csak a QMenu osztály objektumait adhatod hozzá ehhez a sávhoz. Ezek a QMenu objektumok tartalmazhatnak továbbá karakterláncokat, QAction objektumokat vagy más QMenu objektumokat.
• QToolBar: Ez egy vízszintes sáv vagy ablaktábla, amely mozgatható az ablakon belül. Tartalmazhat gombokat és egyéb widgeteket.
• QTab: Arra szolgál, hogy egy ablak tartalmát több oldalra bontsa, amelyek a widget tetején található különböző füleken keresztül érhetők el. Két részből áll: a fülsávból és a füloldalból.
• QScrollBar: Görgetősávok létrehozására szolgál, amelyek lehetővé teszik a felhasználó számára, hogy fel és le görgessen egy ablakon belül. Egy mozgatható csúszkából, egy csúszkából áll track, és két gomb a csúszka felfelé vagy lefelé görgetéséhez.

scroll = QScrollBar()

• QSplitter: Az elosztók az ablakok tartalmának szétválasztására szolgálnak, így a widgetek megfelelően vannak csoportosítva, és ne tűnjenek zsúfoltnak. A QSplitter a PyQt5-ben elérhető egyik elsődleges elrendezéskezelő, és a tartalom vízszintes és függőleges felosztására szolgál.
• QDockA dokkolható widget egy alább látható ablak, amelynek két tulajdonsága van: áthelyezhető a főablakon belül, és dokkolható a szülőablakon kívülre, a képernyő egy másik helyére.

Elrendezések és témák

A korábbi PyQt5 példákban csak a move() és resize() metódusokat használta a widgetek pozíciójának beállítására a grafikus felhasználói felületen.

A PyQt azonban robusztus elrendezéskezelő motorral rendelkezik, amellyel fejlett felhasználói felületek hozhatók létre az alkalmazásokhoz. Ebben a részben két fontos osztályt ismerhet meg, amelyeket a Qt az elrendezések létrehozására és kezelésére használ.

1. QBoxelrendezés
2. QGridLayout

QBoxelrendezés

QBoxAz elrendezés az elrendezés gyermekmoduljainak vízszintes vagy függőleges sorba igazítására szolgál. A két érdeklődési osztály, amely a Q-tól öröklődikBoxAz elrendezés a következő:

• QHBoxElrendezés: a gyermek widgetek vízszintes sorba rendezésére szolgál.
• QVBoxElrendezés: a gyermek widgetek függőleges vonalvezetésére szolgál.

Például így van három gomb a QH-hoz igazítvaBoxAz elrendezés kinéz.

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

És így fognak kinézni a QV-benBoxElrendezés.

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

Az egyetlen függvény, amely ezen a ponton magyarázatra szorul, az addWidget() metódus. Widgetek beszúrására szolgál a HBox vagy VBox elrendezés. Más elrendezésekben is használják, ahol eltérő számú paramétert vesz igénybe, amint azt a következő részben látni fogja. A widgetek abban a sorrendben jelennek meg az elrendezésen belül, ahogyan beszúrta őket.

QGridLayout

A QGridLayout olyan interfészek létrehozására szolgál, amelyekben a widgetek rács (például mátrix vagy 2D tömb) formájában vannak elhelyezve. Ha elemeket szeretne beszúrni egy rácselrendezésbe, a mátrixábrázolás segítségével meghatározhatja a rácsban lévő sorok és oszlopok számát, valamint ezen elemek helyzetét.

Például egy 3*3-as rács (vagyis egy három soros és három oszlopos rács) létrehozásához a következő kódot kell beírnia:

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

Ez lesz a kimenet:

A rácsos elrendezésben az addWidget() metódus a következő argumentumokat fogadja el:

• A widget objektum, amelyet hozzá szeretne adni a rácshoz
• Az objektum x-koordinátája
• Az objektum y-koordinátája
• A sorok hossza (alapértelmezett = 0)
• Az oszloptartomány (alapértelmezett = 0)

A jobb megértés érdekében manuálisan is beillesztheti az egyes widgeteket az alábbiak szerint.

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

Így fog kinézni a rács:

A rowspan és colspan paramétereket is átadhatja az addWidget()-nek, hogy egynél több sort vagy oszlopot fedhessen le.

Például,

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

Ezzel létrehoz egy gombot, amely mindkét oszlopon átnyúlik.

témák

A PyQt5 néhány beépített témát tartalmaz, amelyeket az alkalmazásaiban használhat. A setStyle() A QApplication példányon meghívott metódus egy adott téma beállítására szolgál az alkalmazáshoz.

Például a következő kódsor hozzáadása az alkalmazás témáját az alapértelmezettről a Fusion témára módosítja.

app.setStyle("Fusion")

Így fog kinézni az előző példa a Fusion témában.

Egy másik hasznos függvény az alkalmazások témázásához a setPalette() metódus. Íme a kód a különböző widgetek színének megváltoztatásához a setPalette() metódus segítségével.

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

Itt van az eredmény.

A setPalette() metódus használatához először meg kell határoznia egy palettát. Ez a QPalette osztály objektumának létrehozásával történik.

 qp = QPalette()

Figyeljük meg, hogy a QPalette osztály a QtGui modulhoz tartozik, és importálni kell ahhoz, hogy ez működjön. Miután létrehoztuk a QPalette objektumot, a setColor() metódussal adjuk meg annak a widgetnek a nevét, amelynek a színét módosítani szeretnénk, valamint a beállítani kívánt színt.

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

Ez az ablak színét feketére változtatja. Miután meghatároztad a színsémát, a setPalette() függvénnyel alkalmazd a palettát az alkalmazásodra.

app.setPalette(qp)

Csak ennyit kell tennie, ha néhány alapvető témát szeretne létrehozni az alkalmazásához. A PyQt azt is lehetővé teszi, hogy stíluslapokat használjon a widgetek megjelenésének meghatározásához. Ha ismeri a CSS-t, a Qt stíluslapok segítségével könnyedén meghatározhat speciális stílusokat az alkalmazáshoz.

GYIK