Streamlit: Interaktive Data Apps mit Python – einfach erklärt

Allgemein

Streamlit: Interaktive Data Apps mit Python – einfach erklärt

Was ist Streamlit?

Streamlit ist ein Open-Source-Framework, mit dem du in wenigen Minuten interaktive Web-Apps für Daten, Machine Learning und Dashboards bauen kannst – nur mit Python. Statt dich um HTML, CSS oder JavaScript zu kümmern, schreibst du einfache Python-Skripte und bekommst sofort eine funktionierende App.

  • Ideal für Prototyping, Data Science, Reporting
  • Läuft lokal oder in der Cloud
  • Unterstützt gängige Bibliotheken wie Pandas, NumPy, Plotly, Altair, scikit-learn

Offiziell: streamlit.io • Doku: docs.streamlit.io

Warum Streamlit?

  • Schnell: Von der Idee zur App in Minuten
  • Einfach: Widgets wie Slider, Selectbox oder File-Upload mit einer Zeile Code
  • Flexibel: Von einfachen Charts bis zu komplexen ML-Demos
  • Teilbar: App-Link verschicken statt Notebook-Export

Typische Use Cases:

  • Interaktive Dashboards und KPI-Reports
  • Explorative Datenanalyse mit Widgets
  • ML-Demos für Klassifikation, Prognose oder NLP
  • Formulare und kleine Tools für Fachabteilungen

Erste Schritte

Installiere Streamlit und starte deine erste App:

pip install streamlit
streamlit hello

Erstelle eine Datei app.py:

import streamlit as st

st.title("Hallo, Streamlit 👋")
name = st.text_input("Wie heißt du?")
if name:
    st.success(f"Willkommen, {name}!")

Starte die App lokal:

streamlit run app.py

Beispiel-App in 5 Minuten

Hier ein kleines Dashboard mit Eingaben, Chart und Tabelle:

import streamlit as st
import pandas as pd
import numpy as np

st.title("Mini-Dashboard mit Streamlit")

# Sidebar-Filter
st.sidebar.header("Filter")
n = st.sidebar.slider("Anzahl Zeilen", 10, 200, 50)
seed = st.sidebar.number_input("Zufalls-Seed", 0, 9999, 42)

# Daten generieren
rng = np.random.default_rng(int(seed))
df = pd.DataFrame(rng.normal(size=(n, 3)), columns=list("ABC"))

st.subheader("Datenvorschau")
st.dataframe(df)

st.subheader("Linienchart")
st.line_chart(df)

# Einfaches Formular
with st.form("berechnung"):
    faktor = st.number_input("Multiplikationsfaktor", 0.1, 10.0, 1.5)
    submitted = st.form_submit_button("Berechnen")
    if submitted:
        st.write("Ergebnis (Spalte A * Faktor):")
        st.write((df["A"] * faktor).head())

Widgets und Layout

  • Häufige Widgets: st.button, st.slider, st.selectbox, st.text_input, st.file_uploader
  • Layout: st.sidebar, st.columns, st.expander, st.tabs

Beispiel Layout:

col1, col2 = st.columns(2)
with col1:
    st.metric("Umsatz", "€ 12.340", "+5%")
with col2:
    st.metric("Besucher", "1.234", "-2%")

Daten und Visualisierung

Streamlit spielt gut mit Pandas und beliebten Charting-Bibliotheken:

  • Schnelle Charts: st.line_chart, st.bar_chart, st.map
  • Flexibel: st.pyplot (Matplotlib), st.altair_chart (Altair), st.plotly_chart (Plotly)

CSV-Upload und Anzeige:

import pandas as pd
import streamlit as st

uploaded = st.file_uploader("CSV hochladen", type=["csv"])
if uploaded:
    df = pd.read_csv(uploaded)
    st.write("Form & Größe:", df.shape)
    st.dataframe(df.head())

Plotly-Chart:

import plotly.express as px
fig = px.scatter(df, x=df.columns[0], y=df.columns[1]) if uploaded else None
if fig:
    st.plotly_chart(fig, use_container_width=True)

Zustand und Caching

Für reaktive Apps sind State und Cache wichtig:

  • st.session_state: Merkt sich Werte zwischen Interaktionen
  • @st.cache_data: Cacht teure Datenberechnungen
  • @st.cache_resource: Cacht Ressourcen wie Modelle oder DB-Verbindungen

Beispiel:

import streamlit as st
import time

if "count" not in st.session_state:
    st.session_state.count = 0

if st.button("Plus 1"):
    st.session_state.count += 1

st.write("Zähler:", st.session_state.count)

@st.cache_data(ttl=600)
def load_slow_data():
    time.sleep(2)
    return {"status": "fertig"}

st.write(load_slow_data())

Tipp: Nur reine, deterministische Funktionen cachen und Input-Argumente klar halten.

Deployment: App teilen

  • Lokal: streamlit run app.py (Standard-Port 8501)
  • Streamlit Community Cloud: Push zu GitHub und direkt deployen
  • Alternativen: Docker, Hugging Face Spaces, eigene Server

Nützliche Links:

Minimaler requirements.txt:

streamlit
pandas
numpy
plotly

Best Practices

  • Struktur: Teile App in Funktionen/Module, nutze klare Überschriften
  • Performance: Caching verwenden, unnötige Berechnungen vermeiden, Datenquellen effizient anbinden
  • UX: Konsistente Sidebar, sinnvolle Defaults, Tooltips/Help-Texte (help= Parameter)
  • Sicherheit: Keine Secrets hardcoden; stattdessen Umgebungsvariablen oder Secrets-Management nutzen
  • Reproduzierbarkeit: requirements.txt oder pyproject.toml pflegen
  • Tests: Kernlogik in reine Funktionen auslagern und testen

Häufige Fragen (FAQ)

  • Brauche ich Flask/Django? Nein. Streamlit rendert die App eigenständig.
  • Ist Streamlit produktionsreif? Für viele interne Tools, Prototypen und leichte Workloads: ja. Für hochlastige Public-Apps ggf. Load-Balancing/Caching einplanen.
  • Kann ich Authentifizierung nutzen? In der Community Cloud gibt es einfache Optionen; sonst eigene Reverse Proxy/Auth-Lösungen oder Drittanbieter.

Fazit

Streamlit macht den Schritt von der Analyse zur interaktiven Data App extrem einfach. Wer Python beherrscht, kann ohne Web-Framework-Kenntnisse Dashboards, ML-Demos und Tools bauen, teilen und iterativ verbessern. Starte mit einem kleinen Skript, füge Widgets hinzu, cache teure Operationen – und du hast in kurzer Zeit eine überzeugende App.

Mehr Infos:

Bitwarden: Der einfache Einstieg in den Open-Source-Passwortmanager

Nginx-Manager: Einfache Verwaltung von Nginx, Reverse Proxy und SSL

Impressum

Datenschutz