← Blog
Un porte-bloc lavande avec une feuille crème vierge et une pince orange sur fond lavande pâle.
Publié le
2026-11-17

Gradio vs Streamlit : choisir une interface Python

Le choix entre Gradio et Streamlit dépend de la manière dont les utilisateurs interagissent avec votre code Python. Gradio constitue un bon point de départ lorsque l’application repose sur des fonctions reliées à des entrées, des sorties et des événements explicites. Streamlit convient bien à une page composée de contrôles, de résultats, de tableaux et d’explications, construite par un script qui se réexécute au fil des interactions.

Les deux permettent de créer un petit outil de données ou une interface pour un modèle. Gradio ne se limite pas aux démonstrations de machine learning, et Streamlit ne se limite pas aux tableaux de bord. Choisissez selon les interactions et la gestion de l’état dont vous avez besoin, puis évaluez le travail nécessaire pour héberger l’application.

Gradio vs Streamlit : comparer l’exécution

QuestionGradioStreamlit
Comment une action appelle-t-elle Python ?Les composants et leurs événements relient les entrées aux fonctions et aux sorties.Les interactions déclenchent souvent une réexécution du script ; les formulaires et fragments offrent davantage de contrôle.
Comment regrouper les modifications avant le calcul ?Relier le calcul à un bouton ou à un événement choisi.Placer les entrées dans un formulaire et calculer lors de sa soumission.
Où conserver des valeurs propres à une session ?gr.State transmet des valeurs entre les événements d’une session.st.session_state conserve des valeurs entre les réexécutions d’une session.
Que faut-il traiter séparément ?Les objets Python partagés, les tâches longues, les accès et l’hébergement.Les caches partagés, les tâches longues, les accès et l’hébergement.

Le guide Gradio Blocks explique les liens entre entrées, fonctions et sorties. La référence Streamlit sur l’exécution décrit notamment les formulaires et les fragments. Chaque interaction Streamlit n’impose pas un recalcul complet : l’emplacement du calcul et les contrôles utilisés comptent.

Créer le même petit outil de vérification CSV

L’exemple reçoit du texte CSV collé, compte les lignes, additionne une colonne et suit les soumissions réussies dans la session de la page. Il n’utilise ni modèle, ni base de données, ni téléversement de fichier, ni cache partagé, ni API externe. Le calcul commun permet d’observer plus facilement les différences entre les interfaces.

Créez un nouveau dossier et un environnement Python isolé. Les commandes utilisent Windows PowerShell et les versions testées pour cet article :

python -m venv .venv
.venv/Scripts/python.exe -m pip install gradio==6.32.0 streamlit==1.67.0

Enregistrez le code partagé dans review_csv.py. Il accepte exactement les colonnes item,units, au maximum 100 lignes de données et 20 000 caractères. Les unités doivent être écrites avec des chiffres représentant un entier entre zéro et un million. Ces contrôles applicatifs interviennent après la réception du texte par Python ; ils ne limitent pas la taille des requêtes HTTP.

import csv
import io
import re

SAMPLE = "item,units\nalpha,3\nbeta,5\ngamma,2"


def summarize(text):
    if not isinstance(text, str) or not text.strip():
        raise ValueError("Paste CSV text first.")
    if len(text) > 20_000:
        raise ValueError("Use at most 20,000 characters.")
    reader = csv.DictReader(io.StringIO(text), strict=True)
    try:
        if reader.fieldnames != ["item", "units"]:
            raise ValueError("Use exactly the header item,units.")
        count, total = 0, 0
        for row in reader:
            count += 1
            if count > 100:
                raise ValueError("Use at most 100 data rows.")
            if None in row or any(v is None for v in row.values()):
                raise ValueError("Each row needs exactly two fields.")
            if not row["item"].strip() or len(row["item"]) > 80:
                raise ValueError("Each item needs 1 to 80 characters.")
            units = row["units"]
            if not re.fullmatch(r"[0-9]{1,7}", units) or int(units) > 1_000_000:
                raise ValueError("Units must be an integer from 0 to 1,000,000.")
            total += int(units)
        if count == 0:
            raise ValueError("Include at least one data row.")
        return count, total
    except csv.Error as error:
        raise ValueError("The CSV quoting is invalid.") from error


def review(text, accepted):
    try:
        rows, total = summarize(text)
    except ValueError as error:
        return f"Error: {error}", accepted
    accepted += 1
    return f"Accepted review {accepted} | Rows: {rows} | Total units: {total}", accepted

Le format est volontairement restreint. Ce n’est pas un importateur de tableurs généraliste : il ne détecte pas les séparateurs, ne déduit pas les types et n’accepte pas des colonnes arbitraires. Une erreur remplace le résultat affiché sans augmenter le compteur de soumissions réussies. Une répétition valide augmente ce compteur, même si le CSV est identique.

Relier un événement dans Gradio

Enregistrez ce fichier sous le nom gradio_app.py :

import os
os.environ["GRADIO_ANALYTICS_ENABLED"] = "False"

import gradio as gr
from review_csv import SAMPLE, review

with gr.Blocks(analytics_enabled=False) as demo:
    gr.Markdown("# CSV review with Gradio")
    gr.Markdown("Results reflect the last submission. Paste only sample data.")
    accepted = gr.State(0)
    source = gr.Textbox(label="CSV text", value=SAMPLE, lines=6)
    submit = gr.Button("Review CSV")
    output = gr.Textbox(label="Last submitted result", interactive=False)
    submit.click(review, inputs=[source, accepted], outputs=[output, accepted])

if __name__ == "__main__":
    demo.launch(server_name="127.0.0.1", server_port=7865, share=False,
                inbrowser=False)

Le bouton transmet le texte et le compteur de session à review(). Les deux valeurs renvoyées mettent à jour le résultat et le compteur. Aucun gestionnaire ne réagit aux seules modifications de la zone de texte : elles ne lancent donc pas le calcul. Le libellé précise que le résultat appartient à la dernière soumission.

Regrouper les entrées dans un formulaire Streamlit

Enregistrez ce fichier sous le nom streamlit_app.py :

import streamlit as st
from review_csv import SAMPLE, review

st.title("CSV review with Streamlit")
st.caption("Results reflect the last submission. Paste only sample data.")
if "accepted" not in st.session_state:
    st.session_state.accepted = 0
    st.session_state.result = "No submission yet."

with st.form("csv_review"):
    source = st.text_area("CSV text", value=SAMPLE, height=180)
    submitted = st.form_submit_button("Review CSV")

if submitted:
    text, count = review(source, st.session_state.accepted)
    st.session_state.result = text
    st.session_state.accepted = count

st.text("Last submitted result")
st.text(st.session_state.result)

Le script initialise les valeurs de session seulement si elles sont absentes. La branche submitted lance le calcul après soumission ; une simple exécution du script n’augmente pas le compteur. Les formulaires Streamlit regroupent les changements jusqu’à leur soumission.

Exécuter les applications et observer les changements

Démarrez Gradio depuis le dossier de l’exemple :

.venv/Scripts/python.exe gradio_app.py

Ouvrez http://127.0.0.1:7865. Dans un second terminal, démarrez Streamlit :

.venv/Scripts/python.exe -m streamlit run streamlit_app.py --server.address 127.0.0.1 --server.port 8505 --server.headless true --browser.gatherUsageStats false

Ouvrez http://127.0.0.1:8505. Les deux applications écoutent uniquement sur la machine locale. Le partage Gradio est désactivé ; aucun tunnel public n’est créé. Arrêtez chaque serveur avec Ctrl+C à la fin. Ces commandes servent à un exercice local, pas à un déploiement public.

L’exemple prérempli contient trois lignes avec les valeurs 3, 5 et 2. Le bouton Review CSV doit afficher Accepted review 1 | Rows: 3 | Total units: 10. Soumettez à nouveau pour passer à 2. Remplacez une valeur par bad et soumettez : une erreur doit remplacer le résultat. Après correction, la prochaine soumission réussie doit porter le numéro 3. Les libellés du petit outil restent en anglais afin de conserver exactement le code testé.

Vérifications du 17 novembre 2026 : la logique commune a réussi 27 contrôles sous Windows avec Python 3.12.14. Les vérifications dans le navigateur ont couvert les soumissions valides et répétées, les modifications non soumises, les erreurs, leur correction et deux sessions dans des onglets distincts pour chaque application. Le rechargement d’un onglet testé a remis son compteur à zéro. Il s’agit de tests fonctionnels locaux, sans mesure de débit, test d’authentification, audit de sécurité entre utilisateurs, déploiement cloud ou test GPU.

Comportement à examinerCe que l’exemple doit montrer
Première soumission valideTrois lignes, dix unités et un compteur de session à un.
Soumission répétéeLe même total, avec une augmentation du compteur.
Texte modifié mais non soumisLe résultat de la dernière soumission reste affiché.
Unités invalidesUne erreur remplace le résultat ; le compteur de succès ne change pas.
Deux onglets distinctsChaque session conserve son propre résultat et son compteur dans cet exemple.
Rechargement de la pageLes valeurs de session ne constituent pas un historique durable.

Séparer l’état de session des ressources partagées

Un compteur propre à un visiteur ne devrait pas être une variable globale mutable partagée par le serveur. Gradio distingue les états global, de session et du navigateur dans son guide de gestion de l’état. Cet exemple utilise gr.State, sans stockage dans le navigateur ni compteur global partagé.

La référence Session State de Streamlit explique la conservation des valeurs entre réexécutions et leur lien avec la session du navigateur. Conserver une valeur lors d’une réexécution n’en fait pas un enregistrement de base de données. Pour sauvegarder le travail des utilisateurs, définissez explicitement son propriétaire, son stockage, sa durée de conservation et sa récupération.

Le cache est un choix distinct. Les caches de données et les caches de ressources actuels de Streamlit proposent une portée globale ou limitée à une session. Une ressource globale est partagée et doit supporter les accès concurrents. Choisissez cette portée délibérément, surtout pour des données propres à un utilisateur. Les exemples n’emploient aucun cache et n’en testent pas le comportement.

Les calculs longs nécessitent aussi une décision indépendante de l’interface. Soumettre un formulaire ou appeler une fonction ne rend pas une tâche récupérable après l’arrêt du processus. Pour les travaux intensifs sur CPU, notre guide Python multiprocessing présente un exemple séparé de pool de processus. Relier un worker, un statut de tâche, une annulation et une reprise à l’interface demande des tests supplémentaires.

Choisir selon l’application à maintenir

Commencez par Gradio lorsque quelques fonctions et leurs relations entre entrées et sorties décrivent clairement le parcours. Un prototype organisé autour d’événements peut être facile à examiner, puisque chaque action possède des entrées et des sorties explicites. Vérifiez comment la mise en page, l’état et les erreurs évoluent avec le nombre d’interactions.

Commencez par Streamlit lorsque l’application se décrit naturellement comme une page assemblée en Python : contrôles, explications, tableaux et résultats. Le modèle de script peut garder cette page concise, à condition de comprendre les réexécutions et la place de l’état. Utilisez des formulaires ou d’autres contrôles d’exécution lorsque l’interaction le justifie.

Pour une application plus importante, comparez la navigation, l’accessibilité, les autorisations, l’expérience de l’équipe et le coût de maintenance des comportements personnalisés. Construisez un parcours représentatif avant de retenir une bibliothèque. Une petite démonstration établit qu’un parcours fonctionne, pas que tous les besoins futurs seront couverts.

Passer d’une démonstration locale à un hébergement CPU

Aucune de ces bibliothèques d’interface ne rend un GPU nécessaire pour ce calcul CSV. Le serveur exécute Python, tandis que le navigateur présente l’interface. Le guide d’architecture client-serveur Streamlit décrit cette séparation. Si vous ajoutez ensuite de l’inférence, évaluez les besoins du modèle séparément de ceux de l’interface.

Avant d’ouvrir l’application à d’autres personnes, définissez les accès, le chemin réseau, le stockage de l’état et la responsabilité d’exploitation. Vérifiez HTTPS, les connexions, les limites de requête, les mises à jour, les journaux, les redémarrages et la récupération. Un onglet local fonctionnel ne valide pas ces exigences de production.

Le comparatif de l’hébergement d’API, en anglais aide à peser une VM autogérée face à une plateforme gérée. Pour une évaluation privée sur une instance Compute, la documentation Hivenet sur la redirection de ports, en anglais décrit l’accès à un service local par SSH. Cette connexion privée reste distincte d’un déploiement public avec authentification.

Si votre équipe souhaite exploiter l’environnement Python, évaluez le calcul CPU avec Hivenet, page en anglais. Préparez les dépendances, la mémoire observée, le nombre de sessions simultanées attendu, la durée des calculs et les besoins de disponibilité. Testez une charge représentative sur l’instance envisagée. Cet article ne revendique aucun service Gradio ou Streamlit géré, déploiement Hivenet testé ou résultat de capacité.

Votre prochaine charge de travail sur Hivenet.

Choisissez une charge de travail d’IA, de calcul ou de stockage à tester sur Hivenet, ou échangez avec notre équipe sur sa mise en production.