Streamlit DataFrame: Anzeigen, Styling und Optimierung von Pandas DataFrames (Aktualisiert für 2025)

In der Welt der Data Science ist die Fähigkeit, Daten zu visualisieren und interaktiv zu untersuchen, von zentraler Bedeutung. Streamlit, eine Python-Bibliothek, hat die Art und Weise, wie wir datenreiche Webanwendungen mit wenigen Zeilen Code erstellen, revolutioniert. Eine der mächtigsten Funktionen von Streamlit ist die nahtlose Integration mit Pandas DataFrames. In diesem Artikel tauchen wir in die Welt der Streamlit DataFrames ein und zeigen, wie Sie Ihre Pandas DataFrames in einer modernen Streamlit-App anzeigen, stylen und optimieren können. Wir behalten einen leicht verständlichen Tutorial-Stil bei — von den Grundlagen bis zu fortgeschrittenen Tipps — und aktualisieren die Inhalte entsprechend Streamlits neuesten Möglichkeiten im Jahr 2025.

Was ist ein Streamlit DataFrame?

Ein Streamlit DataFrame bezieht sich auf die Darstellung eines Pandas DataFrame (oder ähnlicher tabellarischer Daten) innerhalb einer Streamlit-App. Es ist, als würde man eine statische Tabelle aus einem Jupyter notebook in ein interaktives Element einer Webanwendung überführen. Unter der Haube nutzt Streamlit Pandas (und andere Datenstrukturen wie PyArrow oder Polars) zur Datenverwaltung, verpackt diese jedoch in eine webfreundliche Oberfläche. Pandas DataFrames sind zweidimensionale, beschriftete Datenstrukturen, die in der Data Science allgegenwärtig sind. Streamlit baut auf Pandas auf, indem es eine Plattform bereitstellt, auf der DataFrames interaktiv angezeigt und von Benutzern in Echtzeit manipuliert werden können. Anstatt nur rohe Tabellen zu betrachten, können Sie Spalten sortieren, Daten filtern, wichtige Werte hervorheben und sogar Benutzer Daten bearbeiten lassen — alles über Streamlits intuitive Komponenten.

Streamlit DataFrame Tutorial

Haben Sie schon von diesem großartigen Data Analysis & Data Visualisation Tool gehört, das Ihre Streamlit App mühelos in etwas wie Tableau verwandeln kann?

PyGWalker (opens in a new tab) ist eine Python Library, die Ihnen hilft, eine tableau-alternative UI problemlos in Ihre eigene Streamlit-App einzubetten. Schauen Sie sich dieses großartige Video an how to explore data with pygwalker (opens in a new tab), das die detaillierten Schritte zeigt, wie Sie Ihre Streamlit-App mit dieser leistungsstarken Data Visualization Python Library erweitern können!

Einstieg in Streamlit DataFrames

Stellen Sie zunächst sicher, dass Streamlit installiert ist. Sie können es über pip installieren:

pip install streamlit

Importieren Sie Streamlit in Ihrem Python-Skript zusammen mit Pandas für die Datenverarbeitung:

import streamlit as st
import pandas as pd

Erstellen Sie als Nächstes ein einfaches DataFrame, das angezeigt werden soll. Zum Beispiel verwenden wir ein kleines Dataset mit Früchten:

data = {
    "Fruit": ["Apple", "Banana", "Cherry", "Date", "Elderberry"],
    "Quantity": [10, 15, 20, 25, 30],
    "Price": [0.5, 0.25, 0.75, 1.0, 2.0]
}
df = pd.DataFrame(data)

Um dieses DataFrame in einer Streamlit-App anzuzeigen, verwenden Sie die Funktion st.dataframe():

st.dataframe(df)

Wenn Sie Ihre Streamlit-App ausführen (streamlit run your_script.py), sehen Sie Ihr DataFrame als interaktive Tabelle. Sie können die Tabelle durch Klicken auf Spaltenüberschriften sortieren und die Größe der Tabelle durch Ziehen der unteren rechten Ecke ändern. In modernen Streamlit-Versionen verfügt die Tabelle über eine Toolbar, mit der Sie in den Daten suchen, Daten in die Zwischenablage kopieren oder die Daten sogar als CSV herunterladen können. Standardmäßig passt st.dataframe seine Höhe so an, dass bis zu 10 Zeilen angezeigt werden, und Sie können innerhalb der Tabelle scrollen, wenn weitere Zeilen vorhanden sind. Dieses grundlegende Beispiel zeigt, wie einfach der Einstieg ist. Als Nächstes untersuchen wir, wie Sie die Anzeige anpassen und größere Datensätze handhaben können.

DataFrames in Streamlit anzeigen

Wie man ein DataFrame als interaktive Tabelle anzeigt

Wie oben gezeigt, ist das Anzeigen eines DataFrame in Streamlit so einfach wie st.dataframe(df). Es gibt jedoch mehr als nur die Darstellung der Tabelle — Streamlit ermöglicht die Anpassung von Aussehen und Interaktivität des DataFrame. Anpassung der Größe: Sie können die Größe der DataFrame-Komponente an das Layout Ihrer App anpassen. Um beispielsweise die Höhe (in Pixel) der Tabellenanzeige zu begrenzen:

st.dataframe(df, height=300)

Im obigen Code nimmt das DataFrame vertikal 300 Pixel ein (zeigt etwa ~10 Zeilen gleichzeitig). Wenn das DataFrame mehr Zeilen hat, erscheint innerhalb der Tabelle ein Scrollbalken, sodass der Benutzer durch die Daten blättern kann. Ebenso können Sie die Breite steuern. In neueren Versionen akzeptiert st.dataframe einen width-Parameter (oder Sie können width="stretch" verwenden, damit es sich auf die volle Breite des Containers ausdehnt). Zum Beispiel:

st.dataframe(df, width="stretch", height=300)

Dies dehnt die Tabelle auf die volle Breite der App-Spalte/des Containers aus, während die Höhe fixiert bleibt. (Hinweis: Der ältere Parameter use_container_width=True ist in favor von width="stretch" in der aktuellen Streamlit-API veraltet.) Interaktive Funktionen: Die DataFrame-Anzeige in Streamlit ist nicht statisch; sie basiert auf einem interaktiven Data Grid. Benutzer können direkt über die Tabellen-UI folgende Aktionen ausführen:

• Sortieren von Spalten: Klicken Sie auf eine Spaltenüberschrift, um auf- oder absteigend zu sortieren.
• Größe ändern und Spalten neu anordnen: Ziehen Sie Spaltenränder, um die Größe zu ändern, oder ziehen Sie Kopfzeilen, um Spalten neu anzuordnen oder zu fixieren.
• Spalten ausblenden: Verwenden Sie das Spaltenmenü (normalerweise ein Overflow-"⋮"-Menü in der Kopfzeile), um bestimmte Spalten ein- oder auszublenden.
• Suchen: Verwenden Sie das Suchfeld in der Toolbar der Tabelle (oder drücken Sie Ctrl+F/Cmd+F), um Einträge in der gesamten DataFrame zu finden.
• Kopieren & Herunterladen: Wählen Sie Zellen aus und drücken Sie Ctrl+C/Cmd+C zum Kopieren, oder verwenden Sie den Download-Button in der Toolbar, um die Daten als CSV herunterzuladen.

All diese Funktionen sind standardmäßig bei Verwendung von st.dataframe verfügbar und machen es zu einem leistungsstarken Werkzeug zur Datenexploration.

Daten hervorheben und bedingte Formatierung

Oft möchten Sie bestimmte Werte in einem DataFrame hervorheben. Eine praktische Methode hierfür ist die Verwendung von Pandas Styler, um bedingte Formatierung anzuwenden, bevor Sie das DataFrame anzeigen. Streamlit unterstützt das Rendern von Pandas Styler-Objekten, was bedeutet, dass Sie Methoden wie highlight_max, highlight_min, background_gradient usw. verwenden und das gestylte DataFrame an Streamlit übergeben können. Zum Beispiel, um den Maximalwert in jeder Spalte hervorzuheben:

st.dataframe(df.style.highlight_max(axis=0))

In diesem Beispiel wird der größte Wert in jeder Spalte hervorgehoben (mit einem Standard-Hervorhebungsstil). Sie können das Styling weiter anpassen oder andere Styler-Methoden verwenden. Ein weiteres Beispiel: Um einen Farbverlauf basierend auf den Werten in jeder Spalte anzuwenden:

st.dataframe(df.style.background_gradient(cmap="Blues"))

Dies färbt den Hintergrund der Zellen von hell bis dunkelblau entsprechend ihrer Größe, was hilft, Verteilungen auf einen Blick zu erkennen. Streamlit zeigt diese gestylten DataFrames an, wobei zu beachten ist, dass einige erweiterte Styling-Funktionen von Pandas (wie Balkendiagramme oder Tooltips in Zellen) möglicherweise nicht vollständig im Streamlit-Table unterstützt werden. Die gebräuchlichsten Stilmittel für Farben, Text und einfache Formatierungen funktionieren jedoch.

Umgang mit großen DataFrames in Streamlit

Mit großen DataFrames (Tausende oder sogar Millionen von Zeilen) zu arbeiten, kann für jede Webanwendung herausfordernd sein. Die Tabellenkomponente von Streamlit ist auf Leistung ausgelegt und kann sehr große Datensätze durch effiziente Virtualisierung handhaben (es wird nur das gezeichnet, was sichtbar ist) und verwendet unter der Haube ein HTML-Canvas. Dennoch gibt es praktische Überlegungen und Limits beim Umgang mit riesigen Daten:

• Browser- und Netzwerklimits: Die gesamten Daten müssen in der Regel vom Streamlit-Server an den Browser gesendet werden. Extrem große Datensätze können WebSocket-Nachrichtengrößenlimits erreichen oder den Browser-Speicher erschöpfen. Wenn Sie beispielsweise versuchen, ein DataFrame mit einer Million Zeilen zu senden, kann die App damit umgehen, aber die Übertragung und das Rendern im Client kann langsam sein.
• Automatische Optimierungen: Streamlit deaktiviert automatisch bestimmte Funktionen für große Tabellen, um die Reaktionsfähigkeit zu erhalten. Wenn Ihr Dataset z. B. mehr als ~150.000 Zeilen hat, schaltet Streamlit das Spaltensortieren ab, um das Rendern zu beschleunigen. Sehr große Tabellen unterstützen möglicherweise nicht alle interaktiven Funktionen, um Performance-Probleme zu vermeiden.
• Best Practices für große Daten:
  • Anzeige von Datenuntermengen: Anstatt ein riesiges DataFrame vollständig in st.dataframe zu geben, zeigen Sie gefilterte oder stichprobenartige Untermengen. Beispielsweise könnten Sie dem Benutzer erlauben, bestimmte Spalten oder einen Datumsbereich auszuwählen, oder einfach die ersten N Zeilen mit der Option zum Durchblättern anzeigen.
  • Einfache Paginierung implementieren: Sie können manuell eine Paginierungsmechanik erstellen. Ein Ansatz ist, einen Slider oder Number Input für die Seitenzahl zu verwenden und das DataFrame entsprechend zu slicen:

page_size = 100  # rows per page
total_rows = len(df)
total_pages = (total_rows - 1) // page_size + 1
 
page = st.number_input("Page", min_value=1, max_value=total_pages, value=1)
start_idx = (page - 1) * page_size
end_idx = start_idx + page_size
st.write(f"Showing rows {start_idx} to {min(end_idx, total_rows)}")
st.dataframe(df.iloc[start_idx:end_idx])

In diesem Beispiel kann der Benutzer eine Seitenzahl wählen, um jeweils 100 Zeilen anzuzeigen. Das verhindert, dass die App versucht, das gesamte DataFrame auf einmal zu rendern, und verbessert die Reaktionsfähigkeit.

• Verwendung von Lazy-DataFrames: Streamlit kann Datenquellen wie PySpark- oder Snowflake (Snowpark) DataFrames anzeigen. Diese Datenstrukturen ziehen Daten nur bei Bedarf, was bedeutet, dass bei Anwendung von Filtern oder Limits die Verarbeitung auf dem Backend (z. B. in einer Datenbank oder Spark-Engine) stattfinden kann und nur die begrenzten Ergebnisse an Streamlit gesendet werden. Wenn Ihr Datensatz extrem groß ist und in einer Datenbank oder einer Big-Data-Plattform liegt, sollten Sie erwägen, ihn stückweise abzufragen oder solche lazy-evaluation-Methoden zu verwenden, anstatt alles in ein Pandas DataFrame im Speicher zu laden.
• Caching für das Laden von Daten verwenden: (Wir werden das Caching in einem späteren Abschnitt ausführlich behandeln, aber kurz gesagt: Cachen Sie den Datenabruf, damit Sie einen großen Datensatz nicht bei jedem App-Rerun erneut einlesen.)

Wenn Sie diese Strategien beachten, können Sie große Datensätze in Streamlit flüssiger handhaben. Der Schlüssel ist, das Frontend nicht mit zu vielen Daten gleichzeitig zu überlasten und die Performance-Funktionen von Streamlit zu nutzen.

Styling von DataFrames in Streamlit

Daten anzuzeigen ist das eine — lesbar und ansprechend zu machen etwas anderes. Streamlit bietet mehrere Möglichkeiten, Ihr DataFrame zu stylen, von eingebauten Formatierungsoptionen bis hin zu benutzerdefiniertem CSS (mit einigen Einschränkungen). Schauen wir uns an, wie Sie die Darstellung Ihrer Tabellen verbessern können.

Kann ich ein DataFrame in Streamlit per CSS stylen?

Vielleicht fragen Sie sich, ob es möglich ist, benutzerdefiniertes CSS (wie auf einer Webseite) auf das DataFrame in Streamlit anzuwenden. Die kurze Antwort lautet: ja, aber mit Vorsicht. Streamlit erlaubt das Einfügen von HTML/CSS in Ihre App mit st.markdown und dem Flag unsafe_allow_html=True. Das bedeutet, Sie können versuchen, die Elemente der Tabelle mit CSS zu adressieren. Zum Beispiel, um die Hintergrundfarbe der Tabelle zu ändern:

st.markdown(
    """
    <style>
    table { background-color: #f0f0f0; }
    </style>
    """,
    unsafe_allow_html=True
)
st.dataframe(df)

In diesem Snippet fügen wir einen <style>-Block ein, der alle HTML-<table>-Hintergründe auf hellgrau setzt, bevor wir st.dataframe(df) aufrufen. Dies könnte das Styling des DataFrame beeinflussen, wenn das zugrundeliegende Rendering Standard-HTML-Tabellen verwendet. Beachten Sie jedoch:

• Dieser Ansatz ist nicht offiziell unterstützt und kann brechen, wenn sich die interne Implementierung von Streamlit ändert. Moderne st.dataframe-Darstellungen basieren auf einem HTML-Canvas und verwenden nicht unbedingt einfache HTML-Tabellen für die Datenzellen, sodass einige CSS-Selektoren möglicherweise nicht wie erwartet greifen.
• Die Verwendung von unsafe_allow_html=True wird generell nur für schnelle Hacks empfohlen, da sie potenziell Sicherheits- oder Stabilitätsprobleme einführen kann (z. B. wenn Sie versehentlich globales Styling anwenden).

Zusammenfassend lässt sich sagen, dass Sie CSS für kleine Anpassungen (wie Hintergrundfarbe oder Schriftstil) verwenden können, es jedoch besser ist, wann immer möglich auf die eingebauten Styling-Funktionen von Streamlit zurückzugreifen.

Styling von DataFrames mit Pandas und Column Config in Streamlit

Eine robustere Methode, DataFrames in Streamlit zu stylen, ist die Verwendung von Pandas Styler (wie im vorherigen Abschnitt mit highlight_max und background_gradient gezeigt) oder die Streamlit-spezifischen Spaltenkonfigurationsoptionen für die Formatierung. Pandas Styler: Sie können viele Stilfunktionen nutzen, die Pandas bietet. Zum Beispiel:

• df.style.format(format_dict) – um Zahlen oder Datumsangaben in jeder Spalte zu formatieren (z. B. eine Float-Zahl als Prozent oder Währung anzuzeigen).
• df.style.applymap(func) – um eine Stilfunktion elementweise anzuwenden (z. B. negative Zahlen rot färben).
• df.style.set_properties(**props) – um CSS-Eigenschaften auf bestimmte Zellen zu setzen (obwohl nicht alle Eigenschaften in Streamlit übernommen werden).
• df.style.hide(axis="index") – um den Index auszublenden, falls dieser für die Anzeige nicht relevant ist.

Nachdem Sie das DataFrame mit Pandas gestylt haben, übergeben Sie das Styler-Objekt an st.dataframe() wie bei highlight_max. Spaltenkonfiguration: Streamlit (ab v1.22+) hat einen column_config-Parameter für st.dataframe und st.data_editor eingeführt, mit dem Sie steuern können, wie Spalten angezeigt werden. Dies ist eine Python-orientierte Methode, um Dinge wie Folgendes anzugeben:

• Spaltenbeschriftungen (Umbenennen von Spalten für die Anzeige, ohne das DataFrame selbst zu ändern).
• Ausblenden bestimmter Spalten.
• Anzeige von Datentypen (z. B. Markierung einer Spalte als Image, Link, Checkbox, Datetime usw., was die Darstellung verändert).
• Zahlen- oder Datumsformatierung (ähnlich wie Styler, aber über die Streamlit-API).

Beispiel: Angenommen, Ihr DataFrame hat eine Preisspalte und Sie möchten diese als US-Währung anzeigen und eventuell die Spaltenüberschrift ändern:

import streamlit as st
import pandas as pd
 
df = pd.DataFrame({
    "item": ["A", "B", "C"],
    "price": [1.5, 2.0, 3.25]
})
 
st.dataframe(
    df,
    column_config={
        "price": st.column_config.NumberColumn(
            "Price (USD)",
            format="$%.2f"
        )
    }
)

In diesem Snippet:

• Wir benennen die Spalte price für die Anzeige in Price (USD) um.
• Wir formatieren die Zahlen in dieser Spalte mit einem Dollarzeichen und zwei Dezimalstellen.

Dieser Ansatz liefert eine ansprechend formatierte Tabelle ohne benutzerdefiniertes CSS und funktioniert mit dem interaktiven Grid von Streamlit. Sie können Spalten auch ausblenden, indem Sie die Spaltenkonfiguration auf None setzen, oder andere Konfigurationstypen für verschiedene Datentypen verwenden (z. B. Images oder Booleans). Zusammengefasst: Verwenden Sie Pandas Styler oder Streamlits column_config für Styling, da diese stabiler und aussagekräftiger für gängige Aufgaben sind als das Einfügen von rohem CSS.

DataFrame-Optimierung in Streamlit

Wenn Sie komplexere Apps bauen oder mit größeren Datensätzen arbeiten, wird die Performance wichtig. Dieser Abschnitt behandelt, wie Sie DataFrames in Streamlit für Geschwindigkeit und Effizienz optimieren können, mit Fokus auf Caching und Best Practices.

Wie optimiere ich ein Pandas DataFrame in Streamlit?

Optimierung bedeutet hier sowohl die Performance Ihrer App (Ladezeiten, Reaktionsfähigkeit) als auch die effiziente Nutzung von Ressourcen (z. B. Speicher). Hier sind wichtige Strategien:

Verwenden Sie Streamlits Caching für Datenladen und Berechnungen: Eine der einfachsten Methoden, Ihre App zu beschleunigen, ist das Vermeiden wiederholter, teurer Operationen. Wenn Sie einen großen Datensatz aus einer CSV oder einer Datenbank laden, kann das bei jedem App-Run langsam sein. Streamlit bietet Mechanismen zum Cachen, um dies zu vermeiden. In älteren Versionen wurde @st.cache genutzt. In aktuellen Streamlit-Versionen sollten Sie @st.cache_data verwenden, um Funktionen zu cachen, die Daten (wie DataFrames) zurückgeben. Zum Beispiel:

import pandas as pd
import streamlit as st
 
@st.cache_data
def load_data():
    # Imagine this is an expensive operation, e.g., reading a large CSV
    df = pd.read_csv("large_dataset.csv")
    # (You could do additional processing here if needed)
    return df
 
# Use the cached function to load data
df_large = load_data()
st.dataframe(df_large.head(100))  # Display just first 100 rows as an example

Durch die Verwendung von @st.cache_data wird beim ersten Lauf die CSV geladen und das resultierende DataFrame im Cache gespeichert. Bei nachfolgenden Läufen (oder wenn Benutzer die App neu ausführen), solange die Eingaben der Funktion unverändert sind, überspringt Streamlit das erneute Ausführen von load_data() und ruft das DataFrame aus dem Cache ab. Das kann Apps, die wiederholt dieselben Daten benötigen, erheblich beschleunigen.

Optimieren Sie DataFrame-Größe und Datentypen: Große DataFrames lassen sich oft durch passende Datentypen optimieren. Beispielsweise spart die Umwandlung von textuellen Kategoriendaten zu Pandas Categorical Speicher. Spalten, die nur 0/1 oder True/False benötigen, sollten als boolean statt als Integer gespeichert werden. Floating-Point-Spalten, die keine hohe Präzision benötigen, können auf float32 downgecastet werden. Solche pandas-Optimierungen reduzieren den Speicherverbrauch und verbessern indirekt die Performance in Streamlit (wichtig beim Deployment auf ressourcenbeschränkten Servern).

Verwenden Sie effiziente Datenformate: Wenn Sie die Datenquelle kontrollieren, sind binäre Formate wie Parquet oder Arrow oft schneller zu laden als CSV. Streamlit kann Arrow-Tabellen direkt lesen und effizient verarbeiten. Das lässt sich gut mit Caching kombinieren — z. B. können Sie das Ergebnis des Lesens einer Parquet-Datei cachen, die sowieso schneller geladen wird.

Nun betrachten wir Caching und Performance-Tipps noch etwas detaillierter, da Caching so wichtig ist.

Streamlit DataFrame Caching- und Performance-Tipps

Caching ist ein mächtiges Werkzeug in Streamlit, muss aber richtig eingesetzt werden. Hier einige Tipps und Best Practices:

Wählen Sie den richtigen Cache-Decorator: Verwenden Sie @st.cache_data zum Cachen von Datenberechnungen oder Abfragen (Funktionen, die DataFrames, Listen, Dictionaries etc. zurückgeben). Verwenden Sie @st.cache_resource zum Cachen von Singleton-Ressourcen (wie einer DB-Verbindung, einem ML-Modell oder anderen Objekten, die einmal initialisiert und wiederverwendet werden sollen). Das Ersetzen von @st.cache durch den passenden neuen Decorator vermeidet Deprecation-Warnungen und liefert bessere Performance, da die Decorators auf den jeweiligen Use-Case zugeschnitten sind.

Die Eingaben der Funktion sind entscheidend: Gechachte Funktionen werden anhand ihrer Eingabeargumente invalidiert. Wann immer Sie eine gecachte Funktion mit neuen Argumenten aufrufen, wird sie erneut ausgeführt und das neue Ergebnis gecacht. Das ist nützlich für Datenaktualisierungen. Zum Beispiel:

@st.cache_data
def load_data(filename):
    return pd.read_csv(filename)
 
file_choice = st.selectbox("Choose a data file", ["data1.csv", "data2.csv"])
df = load_data(file_choice)
st.dataframe(df.head())

In diesem Fall führt ein Wechsel von "data1.csv" zu "data2.csv" load_data erneut aus und cached das neue Ergebnis separat. Das Zurückwechseln zu "data1.csv" holt das Ergebnis aus dem Cache. Dieses Verhalten stellt sicher, dass Ihre App mehrere Datensätze effizient handhaben kann, ohne unnötig neu zu berechnen.

Vermeiden Sie das Mutieren gecachter Daten: Ein häufiger Fehler ist das Verändern eines gecachten Objekts. Wenn Sie z. B. ein DataFrame cachen und dieses dann in-place modifizieren, bleiben diese Änderungen im Cache über Läufe hinweg bestehen und können unerwartete Ergebnisse verursachen. Mit st.cache_data hilft Streamlit, indem es jedes Mal eine frische Kopie der Daten aus dem Cache zurückgibt, um Mutationsprobleme zu vermeiden. In der Regel benötigen Sie nicht mehr allow_output_mutation=True (eine Option in älteren st.cache-Versionen), da das neue System anders damit umgeht. Falls Sie einen Anwendungsfall haben, in dem Sie ein gecachtes Objekt mutieren müssen, prüfen Sie st.cache_resource, verwenden Sie es aber vorsichtig und dokumentieren Sie das Verhalten.

Cache leeren, wenn nötig: Wenn sich Ihre Daten extern aktualisieren und Sie den Cache auffrischen müssen, können Sie einen Button einbauen, mit dem Benutzer den Cache manuell leeren (st.cache_data.clear() zum Beispiel), oder Sie integrieren eine TTL (time-to-live) oder einen Hash einer externen Datenversion in den Cache-Key. Wenn Sie z. B. wissen, dass Daten täglich aktualisiert werden, können Sie das aktuelle Datum in den Cache-Key aufnehmen oder @st.cache_data(ttl=86400) setzen, damit der Cache nach einem Tag abläuft. So verhindern Sie, dass Benutzer mit veralteten Daten arbeiten.

Limitieren Sie die Rendergröße von DataFrames: Selbst mit Caching kann das Rendern eines riesigen DataFrame im Browser langsam sein. Es ist oft ratsam, zu begrenzen, wie viel eines DataFrame gleichzeitig angezeigt wird. Wir haben bereits die Verwendung des height-Parameters oder manueller Paginierung beschrieben. Eine weitere Taktik ist, nur Zusammenfassungen oder Stichproben eines großen Datensatzes anzuzeigen und Download-Links oder eine optionale Vollansicht auf Anfrage bereitzustellen. Die Streamlit-App sollte sich auf die für die Analyse relevanten Ausschnitte konzentrieren, statt Benutzer (und den Browser) mit einer riesigen Tabelle zu überfluten. Wenn Sie viele Daten anzeigen müssen, können Benutzer weiterhin Such- und Scroll-Funktionen nutzen, aber stellen Sie sicher, dass die App reaktionsfähig bleibt.

Mit diesen Caching- und Performance-Tipps bleibt Ihre Streamlit-App auch bei wachsendem Datenvolumen flott und effizient.

Streamlit DataFrame: Fortgeschrittene Anwendungsfälle

In diesem Abschnitt betrachten wir einige fortgeschrittene (aber häufige) Szenarien, in denen Streamlit DataFrames eine zentrale Rolle spielen: interaktives Filtern von Daten und die Einbindung von DataFrame-Nutzung in einen Machine-Learning-Workflow.

Filtern von DataFrames in Streamlit

Das Filtern von Daten ist ein Kernbestandteil der Datenexploration. Streamlits Widgets machen es einfach, interaktive Filter in Ihre DataFrame-Anzeige einzubauen. Anstatt statische Teilmengen vorzudefinieren, können Sie dem Benutzer erlauben, selbst zu entscheiden, wie gefiltert wird. Angenommen, Sie möchten dem Benutzer erlauben, das df DataFrame nach einem Wertebereich in einer numerischen Spalte zu filtern. Sie können einen Slider für den Bereich und ein Selectbox, um die Spalte auszuwählen, verwenden:

# Assume df is already loaded
column = st.selectbox("Select column to filter", df.columns)
if pd.api.types.is_numeric_dtype(df[column]):
    min_val, max_val = int(df[column].min()), int(df[column].max())
    # Slider to pick a range within [min, max]
    range_values = st.slider(f"Filter {column} between:", min_val, max_val, (min_val, max_val))
    # Filter the dataframe based on slider
    filtered_df = df[(df[column] >= range_values[0]) & (df[column] <= range_values[1])]
else:
    # If non-numeric, maybe use multiselect for categories
    options = st.multiselect(f"Filter values for {column}:", df[column].unique(), default=list(df[column].unique()))
    filtered_df = df[df[column].isin(options)]
 
st.dataframe(filtered_df)

In diesem Beispiel:

• Zuerst lassen wir den Benutzer wählen, welche Spalte gefiltert werden soll.
• Ist die gewählte Spalte numerisch, zeigen wir einen Bereichs-Slider von Minimum bis Maximum der Spalte an; die Auswahl des Benutzers liefert ein (min_val, max_val)-Tupel. Wir filtern dann df auf diesen Bereich.
• Ist die Spalte nicht-numerisch (z. B. Strings/Kategorien), verwenden wir ein multiselect-Widget, mit dem der Benutzer auswählt, welche Werte der Spalte einbezogen werden sollen, und filtern entsprechend.
• Abschließend zeigen wir das filtered_df an.

Dieses Muster lässt sich auf viele Szenarien anpassen: Sie können mehrere Filter gleichzeitig anbieten (einfach weitere Widgets und Bedingungen hinzufügen) oder unterschiedliche Widget-Typen für verschiedene Spalten verwenden (Datepicker für Datums-Spalten, Texteingaben für Text-Suchen usw.). Das Resultat ist eine App, in der Benutzer das DataFrame interaktiv zerschneiden und sofort die gefilterte Tabelle sehen.

DataFrames in Machine-Learning-Apps mit Streamlit

Streamlit eignet sich nicht nur für statische Datenanzeigen — es ist hervorragend für interaktive Machine-Learning-Demos und Dashboards. DataFrames treten in ML-Apps oft auf: um eine Vorschau der Trainingsdaten zu zeigen, Feature-Importance-Scores anzuzeigen oder dem Benutzer das Hochladen neuer Daten für Vorhersagen zu erlauben. Betrachten wir ein einfaches Beispiel: Sie haben einen Datensatz und möchten dem Benutzer ermöglichen, mit einem Button ein Modell (z. B. einen Klassifizierer) zu trainieren und die Ergebnisse anzuzeigen. Sie können ein DataFrame verwenden, um die Daten anzuzeigen, und Streamlit-Widgets, um die Interaktion zu steuern:

from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score
 
# Display the DataFrame (e.g., training dataset preview)
st.dataframe(df)
 
# Let user trigger model training
if st.button("Train Model"):
    # Assume 'target' is the label column in df
    if 'target' not in df.columns:
        st.error("No target column found in data!")
    else:
        # Split the data
        X = df.drop('target', axis=1)
        y = df['target']
        X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
        
        # Train a simple RandomForest model
        model = RandomForestClassifier(n_estimators=100, random_state=42)
        model.fit(X_train, y_train)
        
        # Evaluate the model
        preds = model.predict(X_test)
        accuracy = accuracy_score(y_test, preds)
        
        # Display accuracy result
        st.write(f"**Model Accuracy:** {accuracy*100:.2f}%")

Das passiert in diesem ML-App-Snippet:

• Wir zeigen das DataFrame df, damit der Benutzer die Rohdaten inspizieren kann.
• Wir fügen einen Button mit der Beschriftung "Train Model" hinzu. Wenn der Benutzer darauf klickt, wird der Code im if st.button-Block ausgeführt.
• Wir führen eine einfache Prüfung durch, ob die Spalte target vorhanden ist (das ist unsere Label-Spalte).
• Wir teilen das DataFrame in Features (X) und Target (y) und splitten dann in Trainings- und Testdaten.
• Wir initialisieren einen RandomForestClassifier (aus scikit-learn) und trainieren ihn auf den Trainingsdaten.
• Wir machen Vorhersagen auf dem Testset und berechnen die Accuracy.
• Schließlich zeigen wir das Ergebnis mit st.write in der App an.

Dieses einfache Beispiel zeigt, wie Sie DataFrame-Anzeige mit interaktiven Controls verbinden können, um eine kleine ML-Pipeline in einer Streamlit-App zu bauen. Der Benutzer könnte Hyperparameter anpassen (z. B. Anzahl der Bäume, Test-Size per Slider), verschiedene Modelle wählen und die Ergebnisse sofort sehen. Das DataFrame dient dabei als zentrale Darstellung der Trainingsdaten oder der Resultate (Sie könnten auch ein DataFrame mit Vorhersagen oder fehlklassifizierten Beispielen anzeigen). Mit Streamlits interaktiven DataFrames und Widgets verwandeln Sie ein Script in eine echte App, in der Benutzer in Echtzeit experimentieren können.

Fazit

Streamlit hat es einfacher denn je gemacht, interaktive Daten-Apps zu bauen, und die Integration mit Pandas DataFrames bringt viel Power direkt an Ihre Finger. In diesem Artikel haben wir behandelt, wie man DataFrames in Streamlit anzeigt — von der Grundnutzung bis zur fortgeschrittenen Anpassung. Wir haben gesehen, wie man Daten für bessere Lesbarkeit stylt, wie man große Datensätze effizient handhabt und wie DataFrames in interaktiven Filter- und Machine-Learning-Anwendungsfällen eingesetzt werden. Mit den neuesten Updates in Streamlit (Stand 2025) ist st.dataframe leistungsfähiger und performanter geworden — mit eingebautem Sortieren, Suche, Download und einer schnellen Grid-Rendering-Engine, die beträchtliche Datenmengen bewältigen kann. Wir haben auch st.data_editor für Szenarien erwähnt, in denen Benutzer Daten in der App bearbeiten oder beisteuern sollen. Ob Sie erfahrener Data Scientist oder Anfänger sind: Streamlit bietet eine freundliche und mächtige Plattform, um Data Insights zu teilen. Ein DataFrame, das sonst in einem Notebook statisch wäre, kann in einer Streamlit-App zu einem interaktiven Erkundungswerkzeug werden. Nutzen Sie Caching zur Performance, achten Sie auf die Nutzererfahrung (zeigen Sie die relevante Teildatenmenge, nicht alles auf einmal) und verwenden Sie die Styling-Optionen, um Ihre Daten klar und aussagekräftig zu präsentieren. Probieren Sie diese Techniken in Ihrer eigenen Streamlit-App aus. Machen Sie Ihre DataFrames interaktiv, bauen Sie ein Dashboard darum herum oder erschaffen Sie die nächste großartige Data-Science-Webapp. Die Möglichkeiten sind grenzenlos, wenn Sie Pandas und Streamlit kombinieren!

Haben Sie schon von diesem großartigen Data Analysis & Data Visualisation Tool gehört, das Ihre Streamlit App in Tableau verwandelt?

PyGWalker (opens in a new tab) ist eine Python Library, die Ihnen hilft, eine tableau-alternative UI mühelos in Ihre eigene Streamlit-App einzubetten.

(opens in a new tab)

Häufig gestellte Fragen

Wie kann ich ein DataFrame in Streamlit stylen? – Sie können ein DataFrame sowohl mit Pandas-Styling als auch mit Streamlits Anzeigeoptionen stylen. Verwenden Sie zum Beispiel Pandas Styler-Methoden wie highlight_max oder background_gradient, um Farbhighlights hinzuzufügen. Sie können auch benutzerdefiniertes CSS über st.markdown (mit unsafe_allow_html=True) anwenden, um einfache Stiländerungen vorzunehmen (dies ist jedoch fortgeschritten und eingeschränkt). Zusätzlich sollten Sie column_config in st.dataframe nutzen, um Spalten zu formatieren (z. B. Zahlenformatierung, Ausblenden des Index) — das ist oft der unkomplizierteste Weg.

Wie kann ich ein DataFrame in Streamlit filtern? – Streamlit stellt interaktive Widgets bereit, die das Filtern erleichtern. Verwenden Sie Dropdowns (st.selectbox oder st.multiselect) für kategoriale Filter, Slider (st.slider) für numerische Bereiche, Texteingaben für Textsuchen usw. Nutzen Sie die Werte dieser Widgets, um Ihr DataFrame zu subsetten (z. B. df[df[column] == value] oder mit pandas-boolean-indexing für Bereiche). Die App aktualisiert sich in Echtzeit, wenn der Benutzer die Widgets anpasst und zeigt die gefilterten Daten an.

Kann ich Bilder innerhalb eines DataFrame in Streamlit anzeigen? – Streamlit kann Bilder darstellen, jedoch nicht direkt innerhalb von st.dataframe-Zellen (Stand heute). Ein gängiger Ansatz ist, eine Spalte im DataFrame mit Bild-URLs oder Dateipfaden zu haben. Anstatt die Bilder in die Tabelle einzubetten, iterieren Sie durch das DataFrame und verwenden st.image() für jedes Bild (oder st.columns, um ein Grid zu erstellen). Alternativ können Sie bei kleinen Thumbnail-URLs die Spaltenkonfiguration verwenden, um eine Spalte als Image-Spalte zu markieren (sofern diese Funktion verfügbar ist), wodurch Bilder direkt angezeigt werden könnten. Generell werden Bilder jedoch eher über separate Streamlit-Aufrufe gehandhabt als in st.dataframe. Stellen Sie sicher, dass die Bilddaten zugänglich sind (als URL oder hochgeladene Datei), damit st.image sie anzeigen kann.