PySide6-Tutorial: GUI-Anwendungen mit Python entwickeln

Hand aufs Herz: Nicht-technische Stakeholder oder Endnutzer interessieren sich selten für deine Jupyter Notebooks oder Python-Skripte. Sie wollen mit der Lösung interagieren und die Ergebnisse direkt sehen.

Darum müssen wir unsere Arbeit in Insight-Reports, Dashboards oder Data-Science-Anwendungen übersetzen. Während Berichte, Dashboards und Web-Apps geläufig sind, werden Desktop-Anwendungen seltener genutzt – zu Unrecht.

Stell dir vor, du entwirfst eine App, in der Nutzer Buttons klicken, Formulare ausfüllen und durch Menüs navigieren – alles in einer klaren, angenehmen Oberfläche direkt auf dem Desktop. Wie cool ist das?

In diesem Tutorial stellen wir dir PySide6 vor, helfen bei der Ersteinrichtung und entwickeln deine erste Desktop-App. Außerdem schauen wir uns häufig genutzte Widgets an, binden Visualisierungen aus beliebten Data-Science-Bibliotheken ein und teilen hilfreiche Ressourcen.

Was ist PySide6?

PySide6 ist ein Toolkit, mit dem du mithilfe von Python Softwareanwendungen mit ansprechenden und intuitiven grafischen Oberflächen erstellst.

Es ist wie ein Baukastensystem für Software: Selbst Einsteiger können damit die visuellen und interaktiven Elemente einer App zusammensetzen. Mit PySide6 verwandelst du Ideen in echte, funktionsfähige Anwendungen für Windows, Mac, Linux und sogar mobile Plattformen.

PySide6 einrichten

Wir gehen davon aus, dass Python bereits installiert ist und du mit deiner gewohnten IDE arbeitest. Die Installation ist unkompliziert.

Öffne dein Terminal und führe Folgendes aus – das war’s auch schon.

pip3 install pyside6
Bereitgestellt von

Deine erste PySide6-Anwendung bauen

Nachdem die Bibliothek erfolgreich installiert ist, bauen wir nun deine erste PySide6-App. So prüfen wir gleichzeitig, ob alles läuft, und du bekommst ein Gefühl für Desktop-Anwendungen.

Erstelle eine Python-Datei namens „main.py“ und kopiere den folgenden Code hinein.

import sys
from PySide6.QtWidgets import QApplication, QLabel
app = QApplication(sys.argv)
label = QLabel('Hello, PySide6!')
label.show()
sys.exit(app.exec_())
Bereitgestellt von

Die Code-Erklärung folgt gleich. Führe die Datei zuerst im Terminal so aus:

python3 run main.pyBereitgestellt von

Glückwunsch, deine erste Desktop-App steht! So könnte sie aussehen:

Die Desktop-Anwendung „Hello, PySide6“ (Bild: Autor)

Zerlegen wir nun das einfache PySide6-Skript. Zuerst importieren wir die benötigten Module:

import sys
from PySide6.QtWidgets import QApplication, QLabelBereitgestellt von

• sys ist ein Standardmodul in Python und stellt Zugriff auf Variablen bereit, die vom Interpreter verwendet werden. In einer PySide6-Anwendung nutzen wir es häufig für Kommandozeilenargumente. Mehr dazu in unserem Tutorial zum Parsen von Kommandozeilenargumenten.
• QApplication und QLabel kommen aus PySide6.QtWidgets. QApplication ist die zentrale Verwaltungsklasse für jede GUI-App. QLabel ist ein Widget zur Textanzeige, mit dem wir hier eine kurze Nachricht ausgeben.

Als Nächstes erzeugen wir eine Instanz von QApplication.

app = QApplication(sys.argv)
Bereitgestellt von

Das benötigt jede PySide6-Anwendung. sys.argv übergibt Kommandozeilenargumente an die App. Auch wenn du keine Argumente nutzt, ist sys.argv erforderlich, um die QApplication mit sinnvollen Defaults zu initialisieren.

label = QLabel('Hello, PySide6!')Bereitgestellt von

Dann erstellen wir ein QLabel-Widget mit dem Text „Hello, PySide6!“. Dieser Text erscheint im Anwendungsfenster.

label.show()Bereitgestellt von

Diese Zeile macht das label sichtbar. Standardmäßig sind Widgets in PySide6 unsichtbar, bis du sie explizit anzeigst.

sys.exit(app.exec_())Bereitgestellt von

Zum Schluss startet diese Zeile die Ereignisschleife der Anwendung. Die Methode exec_() von QApplication wechselt in die Hauptschleife, in der Events wie Maus- und Tastatureingaben verarbeitet werden. sys.exit() sorgt beim Schließen für einen sauberen Ausstieg. Die Schleife läuft, bis die QApplication ein Beenden-Signal erhält, etwa beim Schließen des Fensters.

Wie im Output zu sehen, erzeugt unser Skript eine einfache GUI mit einem Fenster, das den Text „Hello, PySide6!“ anzeigt.

PySide6-Widgets in die GUI einbinden

Widgets sind in PySide6 die Bausteine für grafische Oberflächen. Denke an Buttons, Textfelder, Labels, Slider oder Dropdowns – also an alles, womit du in einer Software interagierst.

In der ersten PySide6-App haben wir ein Label-Widget genutzt, um Text anzuzeigen. Beim Bau einer GUI ordnen wir im Kern solche Widgets sinnvoll im Fenster an. Jedes Widget hat dabei seinen Zweck und interagiert anders mit den Nutzern.

Die vollständige Liste der Widgets und ihrer Verwendung findest du in der offiziellen Doku. Die meistgenutzten sind:

• QLabel: Zeigt Text oder Bilder an. Häufig für Hinweise, Meldungen oder Bildanzeigen genutzt.
• QPushButton: Klickbarer Button, um Aktionen auszulösen. Ein Grundbaustein für Formulare, Prozessstarts u. v. m.
• QLineEdit: Eingabe und Bearbeitung einzeiliger Texte. Typisch für Formulare, z. B. für Namen oder Zahlen.
• QComboBox: Kombination aus Dropdown-Liste und Texteingabe. Nutzende können aus Vorgaben wählen oder selbst tippen.
• QCheckBox: Ankreuzfeld zum Aktivieren/Deaktivieren von Optionen oder für Zustimmungen.
• QRadioButton: Für exklusive Auswahlen innerhalb einer Gruppe – genau eine Option wählbar.
• QTextEdit: Mehrzeilige Texteingabe mit mehr Funktionen als QLineEdit, inkl. Formatierung, Copy/Paste und Scrollen.
• QSlider: Schieberegler für Werte innerhalb eines Bereichs, z. B. Lautstärke oder Preisfilter.
• QSpinBox: Zahlenauswahl innerhalb eines Bereichs, veränderbar über kleine Pfeile hoch/runter.
• QProgressBar: Fortschrittsanzeige für Aufgaben, z. B. Uploads oder Downloads.
• QTableWidget: Darstellung tabellarischer Daten mit Zeilen und Spalten – ideal für strukturierte Daten.

Erstellen wir nun eine Anwendung, die diese häufigen Widgets anzeigt:

import sys
from PySide6.QtWidgets import QApplication, QMainWindow, QLabel, QPushButton, QLineEdit, QComboBox, QCheckBox, QRadioButton, QTextEdit, QSlider, QSpinBox, QProgressBar, QTableWidget, QTableWidgetItem, QVBoxLayout, QHBoxLayout, QWidget

class DemoWindow(QMainWindow):
   def __init__(self):
       super().__init__()

       # Main Widget and Layout
       main_widget = QWidget()
       self.setCentralWidget(main_widget)
       main_layout = QVBoxLayout(main_widget)

       # Function to add widget with label
       def add_widget_with_label(layout, widget, label_text):
           hbox = QHBoxLayout()
           label = QLabel(label_text)
           hbox.addWidget(label)
           hbox.addWidget(widget)
           layout.addLayout(hbox)

       # QLabel
       self.label = QLabel('Hello PySide6!')
       add_widget_with_label(main_layout, self.label, 'QLabel:')

       # QPushButton
       self.button = QPushButton('Click Me')
       self.button.clicked.connect(self.on_button_clicked)
       add_widget_with_label(main_layout, self.button, 'QPushButton:')

       # QLineEdit
       self.line_edit = QLineEdit()
       add_widget_with_label(main_layout, self.line_edit, 'QLineEdit:')

       # QComboBox
       self.combo_box = QComboBox()
       self.combo_box.addItems(['Option 1', 'Option 2', 'Option 3'])
       add_widget_with_label(main_layout, self.combo_box, 'QComboBox:')

       # QCheckBox
       self.check_box = QCheckBox('Check Me')
       add_widget_with_label(main_layout, self.check_box, 'QCheckBox:')

       # QRadioButton
       self.radio_button = QRadioButton('Radio Button')
       add_widget_with_label(main_layout, self.radio_button, 'QRadioButton:')

       # QTextEdit
       self.text_edit = QTextEdit()
       add_widget_with_label(main_layout, self.text_edit, 'QTextEdit:')

       # QSlider
       self.slider = QSlider()
       add_widget_with_label(main_layout, self.slider, 'QSlider:')

       # QSpinBox
       self.spin_box = QSpinBox()
       add_widget_with_label(main_layout, self.spin_box, 'QSpinBox:')

       # QProgressBar
       self.progress_bar = QProgressBar()
       add_widget_with_label(main_layout, self.progress_bar, 'QProgressBar:')

       # QTableWidget
       self.table_widget = QTableWidget(5, 3) 
       for i in range(5):
           for j in range(3):
               item = QTableWidgetItem(f"Cell {i+1},{j+1}")
               self.table_widget.setItem(i, j, item)
       add_widget_with_label(main_layout, self.table_widget, 'QTableWidget:')

   def on_button_clicked(self):
       self.label.setText('Button Clicked!')

# Run the application
app = QApplication(sys.argv)
window = DemoWindow()
window.show()
sys.exit(app.exec_())
Bereitgestellt von

Die Ausgabe sieht so aus:

Die Widgets-Desktop-Anwendung (Bild: Autor)

Wir haben erfolgreich eine Desktop-App mit den gängigsten Widgets erstellt. Zur leichteren Orientierung haben wir jedem Widget ein Label beigefügt. Auch wenn das nur ein Beispiel ist, können wir diese Widgets jetzt gezielt für komplexere Anwendungen einsetzen.

Eine Datenvisualisierungs-App mit PySide6, Matplotlib und Seaborn

Für diese App wählen wir zuerst ein bekanntes Datenset und erstellen eigenständige Visualisierungen – wie bei der täglichen explorativen Datenanalyse. Anschließend verpacken wir die Plots in eine Desktop-Anwendung, ähnlich wie wir Berichte und Analysen in interaktive Apps überführen.

Bevor wir starten, stellen wir per Terminal sicher, dass alle Bibliotheken vorhanden sind.

pip3 install matplotlib seabornBereitgestellt von

Schritt 1: Einfache, eigenständige Visualisierungen erstellen

Wir laden das bekannte „Iris-Dataset“, das in der Python-Visualisierungsbibliothek Seaborn nativ verfügbar ist. Mit Seaborn und Matplotlib erzeugen wir die Plots. Eine ausführliche Einführung findest du in unserem Leitfaden zu Visualisierungen mit Seaborn.

import seaborn as sns
import matplotlib.pyplot as plt
# Load the Iris dataset
iris = sns.load_dataset("iris")Bereitgestellt von

Dann erstellen wir folgende Visualisierungen:

plt.figure(figsize=(6, 4))
sns.scatterplot(data=iris, x="sepal_length", y="sepal_width", hue="species")
plt.title("Sepal Length vs Sepal Width")
plt.show()
Bereitgestellt von

Die erste Visualisierung ist ein Scatterplot von Kelchlänge gegen Kelchbreite, eingefärbt nach Spezies.

Visualisierung #1: Kelchlänge vs. Kelchbreite (Bild: Autor)

Die zweite Visualisierung ist ein Histogramm der Blütenblattlänge, nach Spezies eingefärbt.

plt.figure(figsize=(6, 4))
sns.histplot(iris, x="petal_length", hue="species", kde=True)
plt.title("Histogram of Petal Length")
plt.show()
Bereitgestellt von

Das Ergebnis sieht so aus:

Visualisierung #2: Histogramm der Blütenblattlänge (Bild: Autor)

Zum Schluss zeichnen wir ein Boxplot, das die Verteilung der Blütenblattbreite je Spezies zeigt.

plt.figure(figsize=(6, 4))
sns.boxplot(x="species", y="petal_width", data=iris)
plt.title("Box Plot of Petal Width")
plt.show()
Bereitgestellt von

Die Visualisierung sieht so aus:

Diese Plots geben unterschiedliche Einblicke in das Iris-Datenset und zeigen Zusammenhänge und Verteilungen der Merkmale über die Arten hinweg.

Schritt 2: Visualisierungen in die Desktop-App integrieren

Sehen wir uns zuerst den Code an und erklären ihn dann.

import sys
import seaborn as sns
from PySide6.QtWidgets import QApplication, QMainWindow, QVBoxLayout, QWidget
from matplotlib.backends.backend_qt5agg import FigureCanvasQTAgg as FigureCanvas
from matplotlib.figure import Figure

class IrisVisualizer(QMainWindow):
   def __init__(self):
       super().__init__()
       self.setWindowTitle("Iris Dataset Visualizations")
       self.setGeometry(100, 100, 1200, 900)  # x, y, width, height
       self.initUI()

   def initUI(self):
       central_widget = QWidget(self)
       self.setCentralWidget(central_widget)
       layout = QVBoxLayout(central_widget)

       # Adding multiple plots
       self.addScatterPlot(layout)
       self.addHistogram(layout)
       self.addBoxPlot(layout)

   def addPlotCanvas(self, layout, plot_func):
       canvas = FigureCanvas(Figure(figsize=(6, 4)))
       plot_func(canvas.figure)
       layout.addWidget(canvas)

   def addScatterPlot(self, layout):
       def scatter_plot(figure):
           iris = sns.load_dataset("iris")
           ax = figure.add_subplot(111)
           sns.scatterplot(data=iris, x="sepal_length", y="sepal_width", hue="species", ax=ax)
           ax.set_title("Sepal Length vs Sepal Width")

       self.addPlotCanvas(layout, scatter_plot)

   def addHistogram(self, layout):
       def histogram(figure):
           iris = sns.load_dataset("iris")
           ax = figure.add_subplot(111)
           sns.histplot(iris, x="petal_length", hue="species", kde=True, ax=ax)
           ax.set_title("Histogram of Petal Length")

       self.addPlotCanvas(layout, histogram)

   def addBoxPlot(self, layout):
       def box_plot(figure):
           iris = sns.load_dataset("iris")
           ax = figure.add_subplot(111)
           sns.boxplot(x="species", y="petal_width", data=iris, ax=ax)
           ax.set_title("Box Plot of Petal Width")

       self.addPlotCanvas(layout, box_plot)

# Run the application
app = QApplication(sys.argv)
window = IrisVisualizer()
window.show()
sys.exit(app.exec_())
Bereitgestellt von

Die Anwendung ist um die Klasse IrisVisualizer herum aufgebaut, die PySide6s QMainWindow erweitert. Sie richtet das Hauptfenster samt Layout ein und dient als Container für die Visualisierungen. Jeder Plot wird mit FigureCanvasQTAgg aus Matplotlib in die GUI eingebettet, sodass Matplotlib-Figuren als PySide6-Widgets dargestellt werden.

Der Schlüssel der Integration ist die Methode addPlotCanvas. Sie erstellt eine Matplotlib-Figur, zeichnet den Plot darauf und fügt die Figur dem Layout der Anwendung hinzu. Die Methoden addScatterPlot, addHistogram und addBoxPlot definieren die einzelnen Plots – dieselben, die wir zuvor als Standalone-Plots erstellt haben. Das Hauptfenster nutzt ein vertikales Box-Layout (QVBoxLayout), das alle Plots untereinander stapelt.

So sieht die finale Anwendung aus:

Desktop-App mit Visualisierungen des Iris-Datensets (Bild: Autor)

Ist diese Anwendung nicht viel stärker als ein einzelner Plot im Jupyter Notebook? Klar, es ist ein einfaches Beispiel. Aber sobald du die Konzepte hinter solchen Apps verstanden hast, kannst du sie zu vollwertigen Insights-Dashboards oder Data-Science-Anwendungen ausbauen.

Fazit

Dieses Tutorial hat PySide6 vorgestellt – eine Python-Bibliothek, mit der Datenprofis GUI-Desktop-Anwendungen in ihrer vertrautesten Sprache entwickeln: Python. Wir haben PySide6 installiert und unsere erste Desktop-App erstellt.

Anschließend haben wir die gebräuchlichsten Widgets für Desktop-Apps eingebunden.

Zum Schluss haben wir gezeigt, wie du Visualisierungen aus beliebten Bibliotheken wie Seaborn und Matplotlib direkt in PySide6-Anwendungen integrierst.

Für deinen weiteren Lernweg empfehlen wir dir die offizielle Dokumentation. Oder lass deiner Neugier freien Lauf und bau deine eigene Lieblings-App. Alternativ lohnt sich auch unser Tutorial, das GUI-Desktop-Anwendungen in Python mit einer anderen Bibliothek, nämlich Tkinter, erstellt.