Streamlit DataFrame : Afficher, styliser et optimiser les DataFrames Pandas (Mise à jour 2025)

Dans le domaine de la data science, la capacité à visualiser et à interagir avec vos données est primordiale. Streamlit, une bibliothèque Python, a révolutionné la façon de créer des applications web riches en données avec seulement quelques lignes de code. L'une des fonctionnalités les plus puissantes de Streamlit est son intégration fluide avec les DataFrames Pandas. Dans cet article, nous explorerons le monde des DataFrames Streamlit, en montrant comment afficher, styliser et optimiser vos DataFrames Pandas dans une application Streamlit moderne. Nous garderons un style tutoriel facile à suivre — des usages basiques aux astuces avancées — mis à jour pour refléter les dernières capacités de Streamlit en 2025.

Qu'est-ce qu'un Streamlit DataFrame ?

Un Streamlit DataFrame désigne l'affichage d'un DataFrame Pandas (ou d'autres données tabulaires similaires) au sein d'une application Streamlit. C'est comme extraire un tableau statique d'un notebook Jupyter et le faire vivre en tant qu'élément interactif dans une application web. Sous le capot, Streamlit s'appuie sur Pandas (et d'autres structures comme PyArrow ou Polars) pour gérer les données, mais il enveloppe ces structures dans une interface web conviviale. Les DataFrames Pandas sont des structures de données bidimensionnelles et étiquetées, omniprésentes en data science. Streamlit complète Pandas en fournissant une plateforme où les DataFrames peuvent être affichés et manipulés de façon interactive par les utilisateurs en temps réel. Plutôt que de voir uniquement des tableaux bruts, vous pouvez trier des colonnes, filtrer les données, mettre en évidence des valeurs importantes, et même permettre aux utilisateurs de modifier des données — le tout via les composants intuitifs de Streamlit.

Tutoriel Streamlit DataFrame

Connaissez-vous cet outil génial d'analyse et de visualisation de données, qui peut facilement transformer votre application Streamlit en Tableau ?

PyGWalker (opens in a new tab) est une bibliothèque Python qui vous aide à intégrer facilement une interface alternative à Tableau dans votre propre application Streamlit sans effort. Découvrez cette vidéo incroyable how to explore data with pygwalker (opens in a new tab) montrant les étapes détaillées pour enrichir votre application Streamlit avec cette puissante Data Visualization Python Library !

Premiers pas avec les DataFrames Streamlit

Tout d'abord, assurez-vous que Streamlit est installé. Vous pouvez l'installer via pip :

pip install streamlit

Importez Streamlit dans votre script Python, ainsi que Pandas pour la manipulation des données :

import streamlit as st
import pandas as pd

Ensuite, créez un DataFrame simple à afficher. Par exemple, utilisons un petit jeu de données sur des fruits :

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)

Maintenant, pour afficher ce DataFrame dans une application Streamlit, utilisez la fonction st.dataframe() :

st.dataframe(df)

Lorsque vous lancez votre application Streamlit (streamlit run your_script.py), vous verrez votre DataFrame rendu comme une table interactive. Vous pouvez trier la table en cliquant sur les en-têtes de colonnes, et redimensionner la table en faisant glisser son coin inférieur droit. Dans les versions récentes de Streamlit, la table est accompagnée d'une barre d'outils qui permet de rechercher dans les données, copier les données dans le presse-papiers et même télécharger les données au format CSV. Par défaut, st.dataframe ajuste sa hauteur pour afficher jusqu'à 10 lignes et permet de faire défiler la table si elle en contient davantage. Cet exemple de base montre à quel point il est simple de commencer. Nous verrons ensuite comment personnaliser l'affichage et gérer des jeux de données plus volumineux.

Afficher des DataFrames dans Streamlit

Comment afficher un DataFrame en tant que table interactive

Comme montré ci-dessus, afficher un DataFrame dans Streamlit est aussi simple que d'appeler st.dataframe(df). Cependant, il y a plus que simplement afficher le tableau — Streamlit permet de personnaliser l'apparence et l'interactivité du DataFrame. Personnalisation de la taille : vous pouvez définir la taille du composant DataFrame pour l'adapter à la mise en page de votre application. Par exemple, pour limiter la hauteur (en pixels) de l'affichage du tableau :

st.dataframe(df, height=300)

Dans le code ci‑dessus, le DataFrame occupera un espace vertical de 300 pixels (montrant environ ~10 lignes à la fois). Si le DataFrame contient plus de lignes, une barre de défilement apparaîtra à l'intérieur du tableau pour que l'utilisateur puisse parcourir les données. De même, vous pouvez contrôler la largeur. Dans les versions récentes, st.dataframe accepte un paramètre width (ou vous pouvez utiliser width="stretch" pour l'étirer à la largeur du conteneur). Par exemple :

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

Cela étirera le tableau sur toute la largeur de la colonne/conteneur de l'application tout en fixant la hauteur. (Remarque : l'ancien paramètre use_container_width=True est désormais déprécié au profit de width="stretch" dans l'API Streamlit la plus récente.) Fonctionnalités interactives : l'affichage du DataFrame dans Streamlit n'est pas statique ; il est alimenté par une grille de données interactive. Les utilisateurs peuvent effectuer les actions suivantes directement dans l'interface :

• Trier les colonnes : cliquer sur un en-tête de colonne pour trier par ordre croissant/décroissant.
• Redimensionner et réorganiser les colonnes : faire glisser les bordures des colonnes pour les redimensionner, ou faire glisser les en-têtes pour réordonner ou épingler des colonnes.
• Masquer des colonnes : utiliser le menu de colonne (généralement un menu "⋮" en en-tête) pour masquer/afficher des colonnes spécifiques.
• Rechercher : utiliser la boîte de recherche dans la barre d'outils du tableau (ou appuyer sur Ctrl+F/Cmd+F) pour trouver des entrées dans l'ensemble du DataFrame.
• Copier et télécharger : sélectionner des cellules et appuyer sur Ctrl+C/Cmd+C pour copier, ou utiliser le bouton de téléchargement dans la barre d'outils pour télécharger les données en CSV.

Toutes ces fonctionnalités sont disponibles par défaut avec st.dataframe, faisant de celui-ci un outil puissant pour explorer les données.

Mise en évidence des données et formatage conditionnel

Souvent, vous voudrez attirer l'attention sur certaines valeurs du DataFrame. Une façon pratique de le faire est d'utiliser Pandas Styler pour appliquer un formatage conditionnel avant d'afficher le DataFrame. Streamlit prend en charge le rendu des objets Pandas Styler, ce qui signifie que vous pouvez utiliser des méthodes comme highlight_max, highlight_min, background_gradient, etc., puis passer le DataFrame stylisé à Streamlit. Par exemple, pour mettre en évidence la valeur maximale dans chaque colonne :

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

Dans cet exemple, la plus grande valeur de chaque colonne sera mise en évidence (avec un style de surlignage par défaut). Vous pouvez personnaliser davantage le style ou utiliser différentes méthodes de Styler. Autre exemple : appliquer un dégradé de couleur en fonction des valeurs de chaque colonne :

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

Cela colorera l'arrière-plan des cellules du plus clair au plus foncé en bleu selon leur magnitude, ce qui aide à visualiser la distribution en un coup d'œil. Streamlit affichera ces DataFrames stylisés, bien que certaines fonctionnalités avancées de Pandas (comme les barres intégrées ou les info-bulles dans les cellules) puissent ne pas être entièrement prises en charge dans le tableau Streamlit. Les styles les plus courants pour les couleurs, le texte et le formatage basique fonctionneront toutefois.

Gérer des DataFrames volumineux dans Streamlit

Travailler avec des DataFrames volumineux (des milliers voire des millions de lignes) peut être un défi pour toute application web. Le composant de tableau de Streamlit est conçu pour la performance et peut gérer des ensembles de données très importants en utilisant une virtualisation efficace (rendant uniquement ce qui est visible) et un canvas HTML sous le capot. Cependant, il existe toujours des considérations pratiques et des limites lorsque l'on traite de très grandes données :

• Limites du navigateur et du réseau : les données doivent typiquement être envoyées du serveur Streamlit vers le navigateur. Des ensembles de données extrêmement volumineux peuvent atteindre les limites de taille des messages WebSocket ou épuiser la mémoire du navigateur. Par exemple, si vous essayez d'envoyer un DataFrame d'un million de lignes, l'application peut le gérer, mais la transmission et le rendu côté client peuvent être lents.
• Optimisations automatiques : Streamlit désactivera automatiquement certaines fonctionnalités pour les tableaux volumineux afin de conserver la réactivité. Par exemple, si votre jeu de données dépasse ~150 000 lignes, Streamlit désactive le tri des colonnes pour accélérer le rendu. Les très grands tableaux peuvent ne pas supporter toutes les fonctionnalités interactives pour éviter des problèmes de performance.
• Bonnes pratiques pour les grandes données :
  • Afficher des sous-ensembles de données : plutôt que d'envoyer un DataFrame immense dans st.dataframe d'un seul coup, envisagez d'afficher un sous-ensemble filtré ou échantillonné. Par exemple, laissez l'utilisateur choisir un sous-ensemble de colonnes ou une plage de dates à visualiser, ou affichez simplement les N premières lignes avec une option de pagination.
  • Implémenter une pagination simple : vous pouvez créer manuellement un mécanisme de pagination. Une approche consiste à utiliser un slider ou un input numérique pour l'index de page, et découper le DataFrame en conséquence :

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])

Dans cet exemple, l'utilisateur peut sélectionner un numéro de page pour voir un bloc de 100 lignes à la fois. Cela évite que l'application tente de rendre l'intégralité du DataFrame d'un coup, améliorant la réactivité.

• Tirer parti des dataframes "paresseux" : Streamlit peut afficher des données depuis des sources comme PySpark ou Snowflake (Snowpark) DataFrames. Ces structures ne récupèrent les données que lorsque c'est nécessaire, ce qui signifie que si vous appliquez des filtres ou des limites, le traitement peut avoir lieu côté backend (par exemple, dans une base de données ou un moteur Spark) et seuls les résultats limités sont envoyés à Streamlit. Si votre jeu de données est extrêmement grand et réside dans une base ou une plateforme big data, envisagez de le requêter par morceaux ou d'utiliser ces méthodes d'évaluation paresseuse plutôt que de tout charger en mémoire dans un DataFrame Pandas.
• Utiliser la mise en cache pour le chargement des données : (Nous aborderons la mise en cache en détail dans une section ultérieure, mais en résumé, mettez en cache l'étape de récupération des données pour ne pas relire un grand fichier à chaque rerun de l'app.)

En respectant ces stratégies, vous pourrez traiter plus sereinement les grands jeux de données dans Streamlit. L'essentiel est d'éviter de submerger le frontend avec trop de données à la fois et de tirer parti des fonctionnalités de performance de Streamlit.

Styliser les DataFrames dans Streamlit

Afficher des données, c'est une chose — les rendre lisibles et esthétiques en est une autre. Streamlit propose plusieurs manières de styliser votre DataFrame, des options de formatage intégrées aux astuces CSS personnalisées (avec quelques précautions). Voyons comment améliorer l'apparence de vos tableaux.

Puis-je styliser un DataFrame avec du CSS dans Streamlit ?

Vous vous demandez peut-être s'il est possible d'appliquer des styles CSS personnalisés (comme sur une page web) au DataFrame dans Streamlit. La réponse courte est oui, mais avec prudence. Streamlit permet d'injecter du HTML/CSS dans votre application via st.markdown avec le paramètre unsafe_allow_html=True. Cela signifie que vous pouvez tenter de cibler les éléments du tableau avec du CSS. Par exemple, pour changer la couleur d'arrière-plan du tableau :

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

Dans cet extrait, nous insérons un bloc <style> qui définit l'arrière-plan de toutes les balises HTML <table> en gris clair avant d'appeler st.dataframe(df). Cela peut affecter le style du DataFrame si le rendu sous-jacent utilise des éléments de type table HTML. Cependant, gardez à l'esprit :

• Cette approche n'est pas officiellement supportée et peut casser si l'implémentation interne de Streamlit change. En fait, le st.dataframe moderne est basé sur un canvas HTML et n'utilise pas nécessairement une simple table HTML pour les cellules de données, donc certains sélecteurs CSS peuvent ne pas s'appliquer comme prévu.
• L'utilisation de unsafe_allow_html=True est généralement déconseillée sauf pour des hacks rapides, car cela peut potentiellement introduire des problèmes de sécurité ou de stabilité (par exemple si vous stylisez quelque chose globalement par erreur).

En résumé, bien que vous puissiez utiliser du CSS pour des ajustements mineurs (comme définir une couleur d'arrière-plan ou une police), il est préférable d'utiliser les fonctionnalités intégrées de Streamlit lorsque cela est possible.

Stylisation des DataFrames avec Pandas et column_config

Une façon plus robuste de styliser les DataFrames dans Streamlit est d'utiliser Pandas Styler (comme montré précédemment avec highlight_max et background_gradient) ou les options de configuration de colonnes de Streamlit. Pandas Styler : vous pouvez appliquer de nombreuses fonctions de stylisation proposées par Pandas. Par exemple :

• df.style.format(format_dict) – pour formater les nombres ou les dates de chaque colonne (par ex. afficher un float en pourcentage ou en devise).
• df.style.applymap(func) – pour appliquer une fonction de style élément par élément (par ex. colorer en rouge les nombres négatifs).
• df.style.set_properties(**props) – pour définir des propriétés CSS sur certaines cellules (bien que toutes ne se transmettent pas forcément à Streamlit).
• df.style.hide(axis="index") – pour masquer l'index si celui-ci n'est pas pertinent pour l'affichage.

Après avoir stylisé le DataFrame avec Pandas, vous passez l'objet Styler à st.dataframe() comme nous l'avons fait avec highlight_max. Configuration des colonnes : Streamlit (à partir de v1.22+) a introduit un paramètre column_config pour st.dataframe et st.data_editor qui permet de personnaliser l'affichage des colonnes. C'est une manière pythonique de spécifier des éléments tels que :

• Les étiquettes des colonnes (renommer les colonnes pour l'affichage sans modifier le DataFrame lui-même).
• Masquer des colonnes spécifiques.
• Définir le rendu des types de données (par ex. marquer une colonne comme Image, Link, Checkbox, Datetime, etc., ce qui change la façon dont les valeurs sont rendues).
• Formater les nombres ou les dates (similaire à Styler mais via l'API Streamlit).

Par exemple, supposons que votre DataFrame contient une colonne de prix et que vous souhaitez les afficher en devise USD et renommer l'en-tête :

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"
        )
    }
)

Dans cet extrait :

• Nous avons renommé la colonne price en Price (USD) pour l'affichage.
• Nous avons formaté les nombres de cette colonne pour afficher un signe dollar et deux décimales.

Cette approche produit un tableau bien formaté sans recourir au CSS personnalisé, et fonctionne avec la grille interactive de Streamlit. Vous pouvez également masquer des colonnes en définissant leur configuration sur None, ou utiliser d'autres types de configuration pour différents types de données (images, booléens, etc.). En résumé, utilisez Pandas Styler ou la configuration de colonnes de Streamlit lorsque c'est possible, car ce sont des méthodes plus stables et expressives pour les tâches courantes que d'injecter du CSS brut.

Optimiser les DataFrames dans Streamlit

Au fur et à mesure que vous construisez des applications plus complexes ou que vous travaillez avec des jeux de données plus importants, la performance devient cruciale. Cette section couvre la façon d'optimiser l'utilisation des DataFrames dans Streamlit pour la rapidité et l'efficacité, en se concentrant sur la mise en cache et les bonnes pratiques.

Comment optimiser un DataFrame Pandas dans Streamlit

L'optimisation ici signifie à la fois améliorer les performances de votre application (temps de chargement, réactivité) et optimiser l'utilisation des ressources (comme la mémoire). Voici quelques stratégies clés :

Utiliser la mise en cache de Streamlit pour le chargement et les calculs : l'une des façons les plus simples d'accélérer votre application est d'éviter de répéter des opérations coûteuses. Si vous avez un grand jeu de données stocké dans un CSV ou une base, le recharger à chaque exécution de l'app peut être lent. Streamlit fournit un mécanisme de cache pour y remédier. Dans les anciennes versions, on utilisait @st.cache. Dans Streamlit actuel, vous devez utiliser @st.cache_data pour mettre en cache les fonctions qui retournent des données (comme des DataFrames). Par exemple :

import pandas as pd
import streamlit as st
 
@st.cache_data
def load_data():
    # Imaginez que c'est une opération coûteuse, par ex. lecture d'un CSV volumineux
    df = pd.read_csv("large_dataset.csv")
    # (Vous pouvez effectuer un traitement supplémentaire ici si nécessaire)
    return df
 
# Utiliser la fonction cachée pour charger les données
df_large = load_data()
st.dataframe(df_large.head(100))  # Afficher uniquement les 100 premières lignes à titre d'exemple

En utilisant @st.cache_data, la première exécution chargera le CSV et stockera le DataFrame résultant en cache. Lors des exécutions suivantes (ou quand les utilisateurs relancent l'app), tant que les entrées de la fonction n'ont pas changé, Streamlit évitera de réexécuter load_data() et récupérera le DataFrame depuis le cache. Cela peut accélérer significativement les applications qui ont besoin des mêmes données de façon répétée.

Optimiser la taille et les types de DataFrame : les DataFrames volumineux peuvent parfois être optimisés en utilisant des types de données appropriés. Par exemple, si vous avez des données textuelles catégorielles, les convertir en type Pandas Categorical peut économiser de la mémoire. Si vous avez des colonnes qui ne nécessitent que 0/1 ou True/False, utilisez des booléens au lieu d'entiers. Les nombres à virgule qui n'ont pas besoin d'une haute précision peuvent être downcastés en float32. Ces optimisations Pandas réduisent l'utilisation mémoire, ce qui peut indirectement améliorer la performance dans Streamlit (important si vous déployez sur des serveurs avec peu de ressources).

Utiliser des formats de données efficaces : si vous contrôlez la source des données, utiliser des formats binaires comme Parquet ou Arrow peut rendre le chargement plus rapide que le CSV. Streamlit peut lire directement des tables Arrow et les gérer efficacement. Cela s'intègre aussi avec la mise en cache — par exemple, vous pouvez mettre en cache le résultat de la lecture d'un fichier Parquet, qui est lui-même rapide à charger.

Regardons maintenant de plus près la mise en cache et d'autres conseils de performance, car la mise en cache est essentielle pour l'optimisation.

Mise en cache et conseils de performance pour les DataFrames Streamlit

La mise en cache est un outil puissant dans Streamlit, mais il est important de l'utiliser correctement. Voici quelques astuces et bonnes pratiques :

Choisir le bon décorateur de cache : utilisez @st.cache_data pour mettre en cache les calculs de données ou les requêtes (fonctions qui retournent des données comme des DataFrames, listes, dictionnaires, etc.). Utilisez @st.cache_resource pour mettre en cache des ressources singleton (comme une connexion à une base, un modèle ML, ou tout objet devant être initialisé une fois et réutilisé). Remplacer @st.cache par le décorateur adéquat évitera les avertissements de dépréciation et fournira de meilleures performances adaptées au cas d'utilisation.

Les entrées de la fonction comptent : les fonctions cachées sont invalidées en fonction de leurs arguments. Chaque fois que vous appelez une fonction mise en cache avec une nouvelle valeur d'argument, elle s'exécutera à nouveau et stockera le nouveau résultat. Cela peut être utile pour la mise à jour des données. Par exemple :

@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())

Dans ce scénario, si l'utilisateur passe de "data1.csv" à "data2.csv", load_data s'exécutera de nouveau pour le nouveau nom de fichier et mettra en cache ce résultat séparément. Revenir à "data1.csv" récupérera alors le cache. Ce comportement permet à votre app de gérer efficacement plusieurs ensembles de données sans recalculs inutiles.

Éviter de muter des données mises en cache : un piège courant est de modifier un objet mis en cache. Par exemple, si vous mettez en cache un DataFrame puis que vous le modifiez en place, ces modifications persisteront dans l'objet en cache entre les exécutions, ce qui peut conduire à des comportements inattendus. Avec st.cache_data, Streamlit aide à éviter cela en retournant une copie fraîche des données à chaque appel (depuis le cache) pour prévenir les problèmes de mutation. Vous n'aurez généralement plus besoin de l'ancien allow_output_mutation=True (option de st.cache) car le nouveau système gère cela différemment. Si vous avez un cas d'utilisation où vous devez cacher un objet mutable, envisagez st.cache_resource, mais faites-le avec précaution et documentez ce comportement.

Vider le cache lorsque nécessaire : si vos données sont mises à jour en externe et que vous devez rafraîchir le cache, vous pouvez ajouter un bouton pour que les utilisateurs effacent manuellement le cache (st.cache_data.clear() par exemple), ou incorporer un TTL (time-to-live) du cache ou le hash d'une version externe des données. Par exemple, si vous savez que les données se mettent à jour quotidiennement, vous pouvez inclure la date actuelle dans la clé de cache ou définir @st.cache_data(ttl=86400) pour expirer après un jour. Cela évite aux utilisateurs d'être bloqués avec des données obsolètes.

Limiter la taille d'affichage du DataFrame : même avec la mise en cache, rendre un DataFrame énorme peut être lent côté navigateur. Il est souvent judicieux de limiter la quantité de DataFrame affichée à la fois. Nous avons évoqué l'utilisation du paramètre height ou la pagination manuelle plus haut. Une autre tactique simple est d'afficher uniquement des résumés ou des échantillons d'un grand jeu de données, et de fournir des liens de téléchargement ou une vue complète sur demande. L'application Streamlit doit se concentrer sur ce qui est pertinent pour l'analyse de l'utilisateur à un moment donné, au lieu d'afficher tout d'un coup. Si vous devez montrer beaucoup de données, les utilisateurs peuvent toujours utiliser la recherche et le défilement, mais assurez-vous que l'application reste réactive.

En suivant ces conseils de mise en cache et de performance, votre application Streamlit restera fluide et efficace même lorsque vos données grandissent.

Streamlit DataFrame : cas d'utilisation avancés

Dans cette section, explorons quelques scénarios avancés (mais courants) où les DataFrames Streamlit jouent un rôle crucial : le filtrage interactif des données et l'intégration des DataFrames dans un workflow de machine learning.

Filtrage des DataFrames dans Streamlit

Filtrer des données est au cœur de l'exploration de données. Les widgets Streamlit facilitent l'ajout de filtres interactifs à l'affichage d'un DataFrame. Au lieu de définir des sous-ensembles statiques, vous pouvez laisser l'utilisateur choisir comment filtrer le DataFrame. Par exemple, supposons que vous souhaitiez permettre à l'utilisateur de filtrer le DataFrame df en sélectionnant une plage de valeurs dans l'une des colonnes numériques. Vous pouvez utiliser un slider pour la plage et un selectbox pour choisir la colonne à filtrer :

# 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)

Dans cet exemple :

• On laisse d'abord l'utilisateur choisir la colonne à filtrer.
• Si la colonne choisie est numérique, on affiche un curseur de plage allant du min au max de la colonne, et la sélection de l'utilisateur fournit un tuple (min_val, max_val). On filtre ensuite df sur cette plage.
• Si la colonne est non numérique (par ex. des chaînes/catégories), on utilise un widget multiselect pour laisser l'utilisateur choisir les valeurs à inclure, puis on filtre en conséquence.
• Enfin, on affiche le filtered_df.

Ce modèle peut être adapté à de nombreux scénarios : vous pouvez ajouter plusieurs filtres simultanément (il suffit d'ajouter d'autres widgets et conditions), ou utiliser différents types de widgets pour différentes colonnes (pickers de dates pour les colonnes date, input texte pour des recherches partielle, etc.). Le résultat est une application où les utilisateurs peuvent trancher et découper le DataFrame à la volée et voir immédiatement la table se mettre à jour pour ne montrer que les données correspondant à leurs critères.

DataFrames Streamlit dans des applications de machine learning

Streamlit n'est pas seulement pour l'affichage statique — il est excellent pour construire des démonstrations interactives de machine learning et des dashboards. Les DataFrames apparaissent souvent dans les applis ML : par exemple pour montrer un aperçu des données d'entraînement, afficher les scores d'importance des features, ou permettre à l'utilisateur de téléverser de nouvelles données pour des prédictions. Prenons un exemple simple : vous disposez d'un dataset et vous voulez permettre à l'utilisateur d'entraîner un modèle (par ex. un classifieur) d'un clic, puis d'afficher les résultats. Vous pouvez utiliser un DataFrame pour montrer les données et des widgets Streamlit pour piloter l'interaction :

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}%")

Voici ce qui se passe dans cet extrait d'application ML :

• On affiche le DataFrame df pour que l'utilisateur puisse inspecter les données brutes.
• On ajoute un bouton "Train Model". Quand l'utilisateur clique dessus, le bloc sous if st.button s'exécute.
• On vérifie rapidement qu'il existe une colonne target à prédire (la variable cible).
• On sépare le DataFrame en features (X) et target (y), puis en ensembles d'entraînement et de test.
• On instancie un RandomForestClassifier (de scikit-learn) et on l'entraîne sur les données d'entraînement.
• On effectue des prédictions sur l'ensemble de test et on calcule la précision (accuracy).
• Enfin, on affiche la précision avec st.write.

Cet exemple simple illustre comment intégrer l'affichage d'un DataFrame avec des contrôles interactifs pour créer un mini pipeline de machine learning dans une application Streamlit. L'utilisateur pourrait ajuster des hyperparamètres (par ex. nombre d'arbres, ratio test/train via des sliders), ou choisir différents modèles, et voir rapidement les résultats. Le DataFrame est central pour présenter les données utilisées pour l'entraînement ou les résultats (vous pourriez aussi afficher un DataFrame des prédictions ou des exemples mal classés, etc.). Avec le DataFrame interactif et les widgets de Streamlit, vous transformez un script en une vraie application où l'on peut expérimenter en temps réel.

Conclusion

Streamlit a rendu plus simple que jamais la création d'applications de données interactives, et son intégration avec les DataFrames Pandas met beaucoup de puissance à portée de main. Dans cet article, nous avons vu comment afficher des DataFrames dans Streamlit, de l'usage basique aux personnalisations avancées. Nous avons vu comment styliser les données pour une meilleure lisibilité, comment gérer efficacement les jeux de données volumineux, et comment les DataFrames s'intègrent dans des cas d'usage interactifs comme le filtrage et le machine learning. Avec les dernières mises à jour de Streamlit (en 2025), st.dataframe est plus capable et performant qu'auparavant — offrant tri intégré, recherche, téléchargement et un rendu en grille rapide qui peut gérer des volumes de données conséquents. Nous avons aussi évoqué st.data_editor pour les scénarios où vous avez besoin que les utilisateurs éditent ou contribuent des données via l'app. Que vous soyez data scientist confirmé ou débutant, Streamlit fournit une plateforme accessible et puissante pour partager des insights. Un DataFrame qui serait statique dans un notebook peut devenir un outil d'exploration interactif dans une application Streamlit. En continuant votre parcours, pensez à tirer parti de la mise en cache pour la performance, à soigner l'expérience utilisateur (montrer le sous-ensemble le plus pertinent, pas tout à la fois) et à utiliser les options de stylisation pour rendre vos données parlantes. Allez-y — essayez ces techniques dans votre propre application Streamlit. Transformez vos DataFrames en tables interactives, construisez un dashboard autour d'eux, ou créez la prochaine super application data science. Les possibilités sont infinies lorsque vous combinez Pandas et Streamlit !

Connaissez-vous cet outil génial d'analyse et de visualisation de données, qui transforme votre application Streamlit en Tableau ?

PyGWalker (opens in a new tab) est une bibliothèque Python qui vous aide à intégrer facilement une interface alternative à Tableau dans votre propre application Streamlit sans effort.

(opens in a new tab)

Foire aux questions

Comment puis-je styliser un DataFrame dans Streamlit ? – Vous pouvez styliser un DataFrame en utilisant à la fois le styling Pandas et les options d'affichage de Streamlit. Par exemple, utilisez les méthodes de Pandas Styler comme highlight_max ou background_gradient pour ajouter des surlignages de couleur. Vous pouvez aussi appliquer du CSS personnalisé via st.markdown (avec unsafe_allow_html=True) pour ajuster des styles simples (bien que cela soit avancé et limité). De plus, profitez de column_config dans st.dataframe pour formater les colonnes (par ex. formatage numérique, masquer l'index) de manière simple.

Comment puis-je filtrer un DataFrame dans Streamlit ? – Streamlit propose des widgets interactifs qui facilitent le filtrage. Vous pouvez utiliser des dropdowns (st.selectbox ou st.multiselect) pour des filtres catégoriels, des sliders (st.slider) pour des plages numériques, des champs texte pour la recherche textuelle, etc. Dans votre code, utilisez les valeurs de ces widgets pour sous-ensemble votre DataFrame (par exemple, df[df[column] == value] ou en utilisant l'indexation booléenne pandas pour des plages). L'application se mettra à jour en temps réel lorsque l'utilisateur ajustera les widgets, affichant les données filtrées.

Puis-je afficher des images à l'intérieur d'un DataFrame dans Streamlit ? – Streamlit peut afficher des images, mais pas directement dans les cellules de st.dataframe pour le moment. Une approche courante consiste à avoir une colonne dans votre DataFrame contenant des URLs d'images ou des chemins de fichiers. Plutôt que d'essayer d'insérer les images dans le tableau, vous parcourrez le DataFrame et utiliserez st.image() pour chaque image (ou utilisez st.columns pour les disposer en grille). Alternativement, si vous avez de petites miniatures accessibles par URL, vous pouvez utiliser la configuration de colonne pour marquer cette colonne comme Image (lorsque cette fonctionnalité est activée) ce qui peut afficher les images directement. Mais en général, vous gérerez les images via des appels Streamlit séparés plutôt qu'en les embarquant dans un st.dataframe. N'oubliez pas que toute donnée image doit être accessible (soit via une URL, soit via un fichier téléversé) pour que st.image puisse l'afficher.