Warum ist Python GUI?

Warum Python statt Ruby, JS, C #?

Einfach zu schreibende Python-Sprache selbst (vs JS)
Funktioniert sowohl unter Windows als auch unter Mac (vs Ruby, C #)
Umfangreiche Bibliothek für Datenanalyse und Bildverarbeitung
C / C ++ - Code kann mit ctypes und Cython aufgerufen werden

Pythons Haupt-GUI-Bibliotheken

tkinter
Standardaufsatz
turtle ――Standard-Anhang ・ Kame ist süß
Kivy --Neu
PyQt5
** Heutige Empfehlung **

Einführung in PyQt5

Qt ist ein OSS-Anwendungsframework

--1992 ~ (derzeit v5.8)

** Hergestellt von C ++ **
** Plattformübergreifend ** (Zeichnen im nativen OS-Stil)
** Reichlich vorhandene Widgets ** _
** Einfach zu bedienende API ** (Signal, Layout, MV)
** Tools ** (IDE, UI Designer)

PyQt5 ist ein Wrapper für Qt5.x.

Ein Tool namens SIP wird verwendet, um den C ++ <=> Python-Teil zu generieren.

Sie können fast alle Funktionen von Qt verwenden
Die benutzerfreundliche API von Qt bleibt unverändert
Mehr pythonisches Schreiben
Konvertieren Sie Zeichenfolgen und Arrays in Python-Typen
Sie können Lambda oder Methode an die Methode übergeben

Beispiel für PyQt5

Platzieren Sie Standard-Widgets

Zeigen Sie den aktuellen Wert der Bildlaufleiste als Zeichenfolge an

from PyQt5.QtWidgets import *
from PyQt5.QtGui import *
from PyQt5.QtCore import *
import sys

class Sample1(QWidget):
    def __init__(self, parent=None):
        super().__init__(parent=parent)

        s = QScrollBar(orientation=Qt.Horizontal)
        t = QLabel()

        s.valueChanged.connect(lambda v: t.setText(str(v)))

        l = QVBoxLayout()
        l.addWidget(s)
        l.addWidget(t)
        self.setLayout(l)

app = QApplication(sys.argv)
s = Sample1()
s.show()
sys.exit(app.exec_())

Beispiel 1

Layout

Ungefähr das gleiche wie .Net usw.
Auch wenn sich die Fenstergröße ändert, wird sie entsprechend erweitert und verkleinert
QHBoxLayout, QVBoxLayout, QGridLayout, etc..

Signal

Jedes Widget hat ein eigenes Signal
Benachrichtigen Sie über Wertänderungen (valueChanged), Klicks ( clicked) usw.
Registrieren Sie die Zielfunktion oder -methode mit .connect --Bebservermuster

→ Verhindern Sie, dass Widgets eng mit der Modellebene gekoppelt werden → Flexibler als die Rückrufmethode

Verbinden Sie die Signale in beide Richtungen

Sie können connect / setValue schleifen
Sie können sich mehrmals mit demselben Signal oder mit mehreren Signalen verbinden.

from PyQt5.QtWidgets import *
from PyQt5.QtGui import *
from PyQt5.QtCore import *
import sys

class Sample2(QWidget):
    def __init__(self, parent=None):
        super().__init__(parent=parent)

        l = QVBoxLayout()
        
        t = QLabel()
        s1 = QScrollBar(orientation=Qt.Horizontal)
        s1.valueChanged.connect(lambda v: t.setText(str(v)))

        s2 = QScrollBar(orientation=Qt.Horizontal)
        s3 = QSpinBox()
        s4 = QSpinBox()
        s5 = QSpinBox()

        s1.valueChanged.connect(s2.setValue)
        s2.valueChanged.connect(s3.setValue)
        s3.valueChanged.connect(s4.setValue)
        s4.valueChanged.connect(s5.setValue)
        s5.valueChanged.connect(s1.setValue)

        l.addWidget(s1)
        l.addWidget(s2)
        l.addWidget(s3)
        l.addWidget(s4)
        l.addWidget(s5)
        l.addWidget(t)

        self.setLayout(l)

app = QApplication(sys.argv)
s = Sample2()
s.show()
sys.exit(app.exec_())

Beispiel 2

Katsura fliegt

Implementiertes Datenmodell-Widget
Sie können auch Signale im Modell definieren


#Daten (aktuelle Karte)
class BoardState:

#Modell-
class BoardModel(QObject):
    stateChanged = pyqtSignal(BoardState)
    def moveKnightTo(self, x, y):
    def rollback(self):

#Widget (jeweils eine Zelle)
class BoardCellWidget(QLabel):
    knightMoved = pyqtSignal(tuple)
    def setState(self, state):

#Ein Widget mit einem Modell und 64 Zellen
class BoardWidget(QWidget):

from PyQt5.QtWidgets import *
from PyQt5.QtGui import *
from PyQt5.QtCore import *
import sys

class BoardState:
    def __init__(self, x, y):
        self._x = x
        self._y = y
        
    def knightIn(self, x, y):
        return (self._x, self._y) == (x, y)
    
    def canKnightMoveTo(self, x, y):
        dx = abs(self._x - x)
        dy = abs(self._y - y)
        return (dx, dy) in [(1, 2), (2, 1)]
        

class BoardModel(QObject):
    stateChanged = pyqtSignal(BoardState)

    def __init__(self, parent=None):
        super().__init__(parent=parent)
        self._states = [BoardState(0, 0)]

    def moveKnightTo(self, x, y):
        newState = BoardState(x, y)
        self._states.append(newState)
        self.stateChanged.emit(newState)

    def rollback(self):
        if len(self._states) <= 1:
            return
        self._states = self._states[:-1]
        self.stateChanged.emit(self._states[-1])

    def state(self):
        return self._states[-1]


class BoardCellWidget(QLabel):
    knightMoved = pyqtSignal(tuple)

    def __init__(self, parent, x, y):
        super().__init__(parent=parent)
        self._x = x
        self._y = y

        self.setMinimumSize(QSize(32, 32))
        self.setMouseTracking(True)
        self.setAcceptDrops(True)

    def setState(self, state):
        self._state = state
        self.update()

    def mousePressEvent(self, event):
        if event.button() == Qt.LeftButton:
            drag = QDrag(self)
            data = QMimeData()
            data.setText("knight")
            drag.setMimeData(data)
            drag.exec()

            event.accept()

    def dropEvent(self, event):
        if self._state.canKnightMoveTo(self._x, self._y):
            self.knightMoved.emit((self._x, self._y))
            event.acceptProposedAction()

    def dragEnterEvent(self, event):
        if self._state.canKnightMoveTo(self._x, self._y):
            event.acceptProposedAction()

    def paintEvent(self, event):
        p = QPainter(self)

        if (self._x + self._y) % 2 == 1:
            p.setBackground(QColor(0xD3, 0x8C, 0x40))
        else:
            p.setBackground(QColor(0xFF, 0xCF, 0x9B))
        p.eraseRect(self.rect())

        rect = QRect(4, 4, self.width() - 8, self.height() - 8)
        if self._state.knightIn(self._x, self._y):
            p.fillRect(rect, Qt.white)
        elif self._state.canKnightMoveTo(self._x, self._y):
            p.fillRect(rect, Qt.green)


class BoardWidget(QWidget):
    def __init__(self, parent=None):
        super().__init__(parent=parent)

        self._model = BoardModel(parent=self)

        l = QGridLayout()
        for x in range(8):
            for y in range(8):
                cell = BoardCellWidget(parent, x, y)
                cell.setState(self._model.state())
                self._model.stateChanged.connect(cell.setState)
                cell.knightMoved.connect(lambda xy: self._model.moveKnightTo(*xy))
                l.addWidget(cell, x, y)

        l1 = QHBoxLayout()
        l1.addLayout(l, 1)
        self._rollback = QPushButton("rollback", parent=self)
        self._rollback.pressed.connect(self._model.rollback)
        l1.addWidget(self._rollback, 0)
        self.setLayout(l1)

app = QApplication(sys.argv)

b = BoardWidget()
b.show()
sys.exit(app.exec_())

Beispiel 3

Ergänzung

Es gibt auch ein DSL namens QML / QtQuick
Sie können einen Browser mit QtWebEngineWidgets einbetten (→ React.js kann auch verwendet werden)
Selbst unter Android können Sie eine App erstellen, indem Sie mit NDK erstellen ―― Früher war es schwierig zu bauen. Jetzt OK mit pip install

Unglücklicherweise

Die Lizenz ist GPL oder bezahlt ―― Gibt es ein Problem für den internen / individuellen Gebrauch? --Installationsarbeiten erforderlich --PyInstaller kann verwendet werden, um ausführbare Dateien für Windows zu generieren
Unter Mac und Linux sollten ähnliche Tools vorhanden sein

Q&A

** Q. ** Warum tritt keine Endlosschleife auf, selbst wenn die Widgets in einer Schleife mit "a.valueChanged.connect (b.setValue)" verbunden sind? ** A. ** valueChanged wird nur ausgegeben," wenn der Wert geändert wird ".

Einführung in die GUI: PyQt5 in Python