Python
Shiny Python: Ein Anfängerleitfaden zur mühelosen Datenvisualisierung

Shiny Python: Ein Anfängerleitfaden zur mühelosen Datenvisualisierung

MoeNagy Dev

Was ist Shiny Python?

Shiny Python ist ein leistungsfähiges Framework zum Erstellen interaktiver Webanwendungen mit der Programmiersprache Python. Es bietet eine Reihe von Werkzeugen und Komponenten, mit denen Entwickler mühelos dynamische, datengesteuerte Webanwendungen erstellen können.

Shiny Python wird oft mit anderen beliebten Python-Webframeworks wie Flask und Django verglichen, unterscheidet sich jedoch durch seinen Fokus auf den Aufbau hochinteraktiver und reaktionsfähiger Benutzeroberflächen (UI) für Datenvisualisierung, -analyse und -exploration.

Vorteile der Verwendung von Shiny Python für die Webentwicklung

  1. Interaktive Benutzeroberfläche: Shiny Python ermöglicht es Ihnen, interaktive Benutzeroberflächen zu erstellen, die auf Benutzereingaben reagieren und sich in Echtzeit aktualisieren, um ein nahtloses und ansprechendes Benutzererlebnis zu bieten.

  2. Schnelle Prototypenerstellung: Mit Shiny Python können Sie schnell Webanwendungen erstellen und iterative Entwicklungs- und Testphasen durchführen.

  3. Integration von Python-Bibliotheken: Shiny Python ermöglicht es Ihnen, das umfangreiche Ökosystem von Python-Bibliotheken und Modulen zur Datenverarbeitung, -analyse und -visualisierung zu nutzen, was es zu einem leistungsstarken Werkzeug für den Aufbau datengesteuerter Anwendungen macht.

  4. Reaktive Programmierung: Shiny Pythons reaktives Programmiermodell vereinfacht die Verwaltung des Anwendungszustands und die Koordination zwischen der Benutzeroberfläche und der serverseitigen Logik.

  5. Bereitstellung und Hosting: Shiny Python-Anwendungen können problemlos auf verschiedenen Hosting-Plattformen, einschließlich Cloud-Services, bereitgestellt werden, was es zu einer vielseitigen Wahl für die Webentwicklung macht.

Erste Schritte mit Shiny Python

Installation von Shiny Python und seinen Abhängigkeiten

Um mit Shiny Python zu beginnen, müssen Sie Python auf Ihrem System installiert haben. Shiny Python basiert auf dem Dash-Framework, daher müssen Sie auch die erforderlichen Abhängigkeiten installieren.

Sie können Shiny Python und seine Abhängigkeiten mit pip, dem Paketinstaller für Python, installieren:

pip install shiny

Dadurch werden Shiny Python und seine erforderlichen Abhängigkeiten, einschließlich Dash, Flask und Plotly, installiert.

Einrichten eines neuen Shiny Python-Projekts

Nachdem Sie Shiny Python installiert haben, können Sie ein neues Projekt erstellen, indem Sie ein Verzeichnis für Ihre Anwendung einrichten. In diesem Verzeichnis haben Sie normalerweise folgende Struktur:

my_shiny_app/
├── app.py
├── requirements.txt
└── assets/
    ├── styles.css
    └── images/
        └── logo.png

Die Datei app.py ist der Haupt-Einstiegspunkt für Ihre Shiny Python-Anwendung, in der Sie die Benutzeroberfläche und die Serverlogik definieren. Die Datei requirements.txt enthält die Python-Pakete, die für Ihre Anwendung erforderlich sind und für die Bereitstellung verwendet werden können. Das Verzeichnis assets wird verwendet, um statische Dateien, wie CSS-Stylesheets und Bilder, die Ihre Anwendung benötigen könnte, zu speichern.

Verständnis der Shiny Python-Verzeichnisstruktur

Die Shiny Python-Verzeichnisstruktur folgt einem ähnlichen Muster wie andere Python-Webframeworks, enthält jedoch einige zusätzliche, spezifische Komponenten für Shiny Python:

  • app.py: Dies ist der Haupt-Einstiegspunkt Ihrer Shiny Python-Anwendung, in dem Sie die Benutzeroberfläche und die Serverlogik definieren.
  • ui.py: Diese Datei enthält die Definition der Benutzeroberfläche, einschließlich des Layouts, der Eingaben und Ausgaben.
  • server.py: Diese Datei definiert die serverseitige Logik, wie z.B. die Verarbeitung von Benutzereingaben und die Aktualisierung des Anwendungszustands.
  • callbacks.py: Diese Datei enthält die Callback-Funktionen, die die Benutzeroberfläche mit der Serverlogik verbinden.
  • models.py: Wenn Ihre Anwendung Datenmodelle oder Interaktionen mit Datenbanken verwendet, können Sie diese in dieser Datei definieren.
  • utils.py: Diese Datei kann Hilfsfunktionen oder Dienstprogramme enthalten, die in Ihrer Anwendung verwendet werden.
  • assets/: Dieses Verzeichnis enthält statische Dateien wie CSS, JavaScript und Bilder, die Ihre Anwendung möglicherweise benötigt.

Die Trennung der Aufgaben zwischen den Dateien ui.py, server.py und callbacks.py dient dazu, Ihre Shiny Python-Anwendung organisiert und wartbar zu halten, wenn sie an Komplexität zunimmt.

Erstellen einer einfachen Shiny Python-Anwendung

Beginnen wir mit dem Aufbau einer einfachen Shiny Python-Anwendung, die es Benutzern ermöglicht, eine Zahl einzugeben und das Quadrat dieser Zahl anzuzeigen.

Erstellung der Benutzeroberfläche (UI) mit Shiny Python-Komponenten

In der Datei ui.py definieren wir die Benutzeroberfläche für unsere Anwendung:

from shiny import ui
 
app_ui = ui.page_fluid(
    ui.layout_sidebar(
        ui.panel_sidebar(
            ui.input_numeric("number", "Geben Sie eine Zahl ein", value=0, min_value=0, max_value=100)
        ),
        ui.panel_main(
            ui.output_text_verbatim("output_text")
        )
    )
)

In diesem Beispiel verwenden wir die Funktion ui.page_fluid(), um ein Seitenlayout mit flüssiger Breite zu erstellen. Innerhalb der Seite verwenden wir ui.layout_sidebar(), um ein Seitenleisten- und Hauptfensterlayout zu erstellen.

Die Seitenleisten-Panel enthält ein numerisches Eingabefeld mit ui.input_numeric(), in dem der Benutzer eine Zahl eingeben kann. Das Hauptfenster enthält einen Textausgabebereich mit ui.output_text_verbatim(), in dem wir das Quadrat der Eingabe des Benutzers anzeigen werden.

Definieren der Serverlogik und Verarbeiten von Benutzerinteraktionen

Erstellen Sie nun die Datei server.py, um die serverseitige Logik zu definieren:

from shiny import App, Inputs, Outputs, Session
 
def server(input, output, session):
    @Outputs("output_text")
    def square_number():
        number = input.number()
        return f"Das Quadrat von {number} ist {number ** 2}"
 
app = App(server, ui)

In der Funktion server() definieren wir einen reaktiven Ausdruck square_number(), der die vom Benutzer eingegebene Zahl quadriert und das Ergebnis als String zurückgibt. Der Outputs()-Decorator wird verwendet, um diese Serverfunktion mit der Ausgabe output_text in der Benutzeroberfläche zu verbinden.

Anwendungsrendering und lokale Ausführung

Um die Shiny Python-Anwendung auszuführen, müssen wir eine app.py-Datei erstellen, die Benutzeroberfläche und Serverlogik zusammenführt:

from shiny import App, get_app, run_app
from ui import app_ui
from server import server
 
app = App(app_ui, server)
 
if __name__ == "__main__":
    run_app(app)

In dieser app.py-Datei importieren wir die Definitionen app_ui und server aus den entsprechenden Dateien und erstellen dann eine neue App-Instanz, indem wir sie dem App()-Konstruktor übergeben.

Schließlich rufen wir die Funktion run_app() auf, um die Shiny Python-Anwendung zu starten und für die lokale Entwicklung verfügbar zu machen.

Sie können die Anwendung ausführen, indem Sie die app.py-Datei ausführen:

python app.py

Dadurch wird die Shiny Python-Anwendung gestartet und in Ihrem Standard-Webbrowser geöffnet, wo Sie mit der Anwendung interagieren und das Quadrat der eingegebenen Zahl sehen können.

Shiny Python UI-Komponenten

Shiny Python bietet eine Vielzahl von Benutzeroberflächenkomponenten (UI-Komponenten), die Sie verwenden können, um Ihre Webanwendungen zu erstellen. Diese Komponenten umfassen Eingabe-, Ausgabe-, Layout- und weitere Komponenten.

Überblick über die verfügbaren UI-Komponenten

Einige der häufig verwendeten Shiny Python UI-Komponenten sind:

  • Eingaben: ui.input_text(), ui.input_numeric(), ui.input_slider(), ui.input_checkbox(), ui.input_date() und mehr.
  • Ausgaben: ui.output_text(), ui.output_table(), ui.output_plot(), ui.output_download() und mehr.
  • Layouts: ui.layout_sidebar(), ui.layout_grid(), ui.layout_row(), ui.layout_column() und mehr.
  • Container: ui.panel_sidebar(), ui.panel_main(), ui.tab_panel(), ui.accordion_panel() und mehr.

Jede dieser Komponenten hat ihren eigenen Satz von Eigenschaften und Optionen, die Sie verwenden können, um das Aussehen und Verhalten Ihrer Anwendung anzupassen.

Anpassen des Aussehens und Verhaltens von UI-Komponenten

Sie können das Aussehen und Verhalten von Shiny Python UI-Komponenten anpassen, indem Sie ihre verschiedenen Eigenschaften festlegen. Zum Beispiel können Sie mit der Komponente ui.input_text() die Eigenschaften label, value, placeholder und andere festlegen, um das Aussehen und die Funktionalität des Eingabefelds zu steuern.

Hier ist ein Beispiel für das Anpassen des Aussehens eines Texteingabefelds:

ui.input_text(
    "name",
    "Geben Sie Ihren Namen ein",
    value="John Doe",
    placeholder="Geben Sie hier Ihren Namen ein",
    style={"width": "300px", "font-size": "16px"}
)

In diesem Beispiel setzen wir die Eigenschaften label, value, placeholder und style der Komponente ui.input_text() ein, um ihr Aussehen anzupassen.

Organisation und Strukturierung der Benutzeroberfläche für komplexe Anwendungen

Wenn Ihre Shiny Python-Anwendung an Komplexität zunimmt, ist es wichtig, die Benutzeroberfläche so zu organisieren und zu strukturieren, dass sie einfach zu verwalten und zu pflegen ist.

Ein häufiger Ansatz besteht darin, Layoutkomponenten wie ui.layout_sidebar(), ui.layout_grid() und ui.tab_panel() zu verwenden, um eine gut strukturierte und intuitive Benutzeroberfläche zu erstellen. Sie können auch Containerkomponenten wie ui.panel_sidebar() und ui.panel_main() verwenden, um verwandte UI-Elemente zusammenzufassen.

Hier ist ein Beispiel für eine komplexere Benutzeroberflächenstruktur:

app_ui = ui.page_fluid(
    ui.layout_sidebar(
        ui.panel_sidebar(
            ui.input_text("name", "Geben Sie Ihren Namen ein"),
            ui.input_numeric("age", "Geben Sie Ihr Alter ein", min_value=0, max_value=120)
        ),
        ui.panel_main(
            ui.tab_panel(
                ui.tab("Überblick", ui.output_text_verbatim("overview_text")),
                ui.tab("Diagramme",
                    ui.layout_grid(
                        ui.output_plot("plot1"),
                        ui.output_plot("plot2")
                    )
                ),
                ui.tab("Herunterladen", ui.output_download("download_button"))
            )
        )
    )
)

In diesem Beispiel verwenden wir ein Seitenleistenlayout mit Eingabefeldern im Seitenleistenpanel und ein tabellarisches Layout im Hauptpanel. Das tabellarische Layout enthält drei Registerkarten: "Überblick", "Diagramme" und "Herunterladen", jeweils mit einer eigenen Reihe von Ausgaben.

Durch die Organisation der Benutzeroberfläche auf diese Weise können Sie komplexe und intuitive Anwendungen erstellen, die einfach zu navigieren und zu pflegen sind.

Shiny Python-Serverfunktionen

Die serverseitige Logik einer Shiny Python-Anwendung wird in der Datei server.py definiert. Hier werden Benutzereingaben behandelt, Datenverarbeitung und -analyse durchgeführt und der Anwendungsstatus aktualisiert.

Behandlung von Benutzereingaben und Aktualisierung des Anwendungsstatus

In der serverseitigen Logik können Sie Funktionen definieren, die auf Benutzereingaben reagieren und den Anwendungsstatus entsprechend aktualisieren. Diese Funktionen sind in der Regel mit dem Inputs()-Decorator versehen, der sie mit den entsprechenden Eingabekomponenten in der Benutzeroberfläche verbindet.

Hier ist ein Beispiel für eine Serverfunktion, die eine Texteingabe behandelt und den Anwendungsstatus aktualisiert:

from shiny import Inputs, Outputs
 
def server(input, output, session):
    @Inputs("name")
    def greet_user():
        name = input.name()
        return f"Hallo, {name}!"
 
    @Outputs("greeting")
    def display_greeting():
        return greet_user()

In diesem Beispiel ist die Funktion greet_user() mit Inputs("name") dekoriert, was bedeutet, dass sie aufgerufen wird, wenn der Benutzer den Wert der Eingabe "name" ändert. Die Funktion nimmt den Namen des Benutzers, fügt ihm eine Begrüßung hinzu und gibt das Ergebnis zurück.

Die Funktion display_greeting() ist mit Outputs("greeting") dekoriert, was bedeutet, dass ihr Rückgabewert verwendet wird, um die Ausgabe "greeting" in der Benutzeroberfläche zu aktualisieren.

Durchführen von Datenverarbeitung und -analyse auf dem Server

Shiny Python ermöglicht es Ihnen, Ihre Anwendung mit verschiedenen Python-Bibliotheken und -Modulen für die Datenverarbeitung, Analyse und Visualisierung zu integrieren. Dies kann innerhalb der Server-Logik erfolgen.

Hier ist ein Beispiel für eine Server-Funktion, die eine einfache Datenanalyse durchführt und ein Diagramm erstellt:

import pandas as pd
from shiny import Inputs, Outputs, session
 
def server(input, output, session):
    @Inputs("dataset")
    def analyze_dataset(dataset):
        df = pd.read_csv(dataset)
        summary = df.describe()
        return summary
 
    @Outputs("dataset_summary")
    def display_dataset_summary():
        summary = analyze_dataset(session.userData.get("dataset", None))
        return summary.to_html()
 
    @Outputs("dataset_plot")
    def plot_dataset():
        df = pd.read_csv(session.userData.get("dataset", None))
        return df.plot()

In diesem Beispiel wird die Methode analyze_dataset definiert, die eine CSV-Datei einliest und eine Zusammenfassung der Daten zurückgibt. Die Methode display_dataset_summary verwendet diese Methode, um die Zusammenfassung als HTML-Tabelle zurückzugeben. Die Methode plot_dataset liest die CSV-Datei erneut ein und erstellt ein Diagramm daraus.

In this example, the analyze_dataset function reads a CSV file and returns a summary of the data. The display_dataset_summary function uses this function to return the summary as an HTML table. The plot_dataset function reads the CSV file again and generates a plot from it.

Datenstrukturen

Listen

Listen sind eine der grundlegenden Datenstrukturen in Python. Sie sind geordnete Sammlungen von Elementen unterschiedlicher Datentypen. Hier ist ein Beispiel:

fruits = ['apple', 'banana', 'cherry']
print(fruits)  # Output: ['apple', 'banana', 'cherry']

Sie können auf einzelne Elemente in einer Liste zugreifen, indem Sie ihren Index verwenden, der bei 0 beginnt:

print(fruits[0])  # Output: 'apple'
print(fruits[1])  # Output: 'banana'

Sie können auch Elemente in einer Liste ändern:

fruits[1] = 'orange'
print(fruits)  # Output: ['apple', 'orange', 'cherry']

Listen haben viele integrierte Methoden, die es Ihnen ermöglichen, verschiedene Operationen wie das Hinzufügen, Entfernen und Sortieren von Elementen durchzuführen.

Tupel

Tupel ähneln Listen, können jedoch nach ihrer Erstellung nicht mehr geändert werden, d.h. sie sind unveränderlich. Tupel werden mit Klammern anstelle von eckigen Klammern definiert:

point = (3, 4)
print(point)  # Output: (3, 4)

Tupel können nützlich sein, wenn Sie einen festen Satz von Werten speichern möchten, z.B. die Koordinaten eines Punktes oder die Abmessungen eines Rechtecks.

Wörterbücher

Wörterbücher sind ungeordnete Sammlungen von Schlüssel-Wert-Paaren. Sie ermöglichen es Ihnen, Daten schnell mithilfe eines eindeutigen Schlüssels für jeden Wert zu speichern und abzurufen. Hier ist ein Beispiel:

person = {
    'name': 'John Doe',
    'age': 30,
    'city': 'New York'
}
print(person['name'])  # Output: 'John Doe'
print(person['age'])  # Output: 30

Sie können Schlüssel-Wert-Paare in einem Wörterbuch hinzufügen, ändern und entfernen:

person['email'] = 'john.doe@example.com'
person['age'] = 31
del person['city']
print(person)  # Output: {'name': 'John Doe', 'age': 31, 'email': 'john.doe@example.com'}

Wörterbücher sind sehr vielseitig und können zur Darstellung einer Vielzahl von Datenstrukturen verwendet werden, von einfachen Schlüssel-Wert-Speichern bis hin zu komplexeren verschachtelten Strukturen.

Mengen

Mengen sind ungeordnete Sammlungen von eindeutigen Elementen. Sie eignen sich gut für Operationen wie Vereinigung, Schnittmenge und Differenz auf Datenkollektionen. Hier ist ein Beispiel:

colors = {'red', 'green', 'blue'}
print(colors)  # Output: {'red', 'green', 'blue'}
 
# Hinzufügen eines Elements zu einer Menge
colors.add('yellow')
print(colors)  # Output: {'red', 'green', 'blue', 'yellow'}
 
# Entfernen eines Elements aus einer Menge
colors.remove('green')
print(colors)  # Output: {'red', 'blue', 'yellow'}

Mengen sind besonders nützlich, um doppelte Werte aus einer Sammlung zu entfernen oder mengenbasierte Operationen durchzuführen.

Kontrollstrukturen

Bedingte Anweisungen

Bedingte Anweisungen in Python ermöglichen es Ihnen, Code basierend auf bestimmten Bedingungen auszuführen. Die häufigste bedingte Anweisung ist die if-elif-else-Anweisung:

x = 10
if x > 0:
    print("x ist positiv")
elif x < 0:
    print("x ist negativ")
else:
    print("x ist null")

Sie können auch den ternären Operator verwenden, der eine kürzere Möglichkeit bietet, einfache if-else-Anweisungen zu schreiben:

age = 18
is_adult = "Ja" if age >= 18 else "Nein"
print(is_adult)  # Output: "Ja"

Schleifen

Schleifen in Python ermöglichen es Ihnen, einen Codeblock wiederholt auszuführen. Die beiden häufigsten Arten von Schleifen sind for-Schleifen und while-Schleifen.

Eine for-Schleife wird verwendet, um über eine Sequenz zu iterieren (wie eine Liste, ein Tupel oder ein String):

fruits = ['apple', 'banana', 'cherry']
for fruit in fruits:
    print(fruit)

Eine while-Schleife wird verwendet, um einen Codeblock so lange auszuführen, wie eine bestimmte Bedingung wahr ist:

count = 0
while count < 5:
    print(count)
    count += 1

Sie können auch die Anweisungen break und continue verwenden, um den Ablauf einer Schleife zu steuern:

for i in range(10):
    if i == 5:
        break  # Beendet die Schleife, wenn i gleich 5 ist
    if i % 2 == 0:
        continue  # Überspringt die aktuelle Iteration, wenn i gerade ist
    print(i)  # Output: 1, 3, 7, 9

Funktionen

Funktionen in Python sind Blöcke von wiederverwendbarem Code, die eine bestimmte Aufgabe ausführen. Sie können Argumente entgegennehmen und Werte zurückgeben. Hier ist ein einfaches Beispiel:

def begrüßen(name):
    print(f"Hallo, {name}!")
 
begrüßen("Alice")  # Output: "Hallo, Alice!"

Sie können auch Funktionen mit Standardargumenten und variablen Argumenten definieren:

def fläche_berechnen(länge, breite, höhe=1):
    return länge * breite * höhe
 
print(fläche_berechnen(2, 3))  # Output: 6
print(fläche_berechnen(2, 3, 4))  # Output: 24

Funktionen können auch rekursiv sein, d.h. sie können sich selbst aufrufen, um ein Problem zu lösen:

def fakultät(n):
    if n == 0:
        return 1
    else:
        return n * fakultät(n-1)
 
print(fakultät(5))  # Output: 120

Module und Pakete

Die umfangreiche Standardbibliothek von Python und Drittanbieterpakete bieten eine Vielzahl von Funktionen, die Sie in Ihren Programmen verwenden können. Um ein Modul oder Paket zu verwenden, müssen Sie es importieren.

Hier ist ein Beispiel für das Importieren des math-Moduls und die Verwendung seiner Funktionen:

import math
 
print(math.pi)  # Output: 3.141592653589793
print(math.sqrt(16))  # Output: 4.0

Sie können auch bestimmte Funktionen oder Attribute aus einem Modul importieren:

```python
from math import pi, sqrt
 
print(pi)  # Ausgabe: 3.141592653589793
print(sqrt(16))  # Ausgabe: 4.0

Zusätzlich kannst du eigene Module und Pakete erstellen, um deinen Code zu organisieren und wiederzuverwenden.

Fazit

In diesem Tutorial hast du verschiedene Datenstrukturen, Kontrollflussanweisungen, Funktionen und Module in Python kennengelernt. Dies sind die grundlegenden Bausteine eines jeden Python-Programms. Mit diesem Wissen kannst du komplexere und leistungsstärkere Anwendungen schreiben. Denke daran, dass der Schlüssel zum Erlernen eines versierten Python-Programmierers darin besteht, zu üben, zu experimentieren und weiter zu lernen. Viel Glück!

MoeNagy Dev