Python
Shiny Python : Un guide pour débutants sur la visualisation de données sans effort

Shiny Python : Un guide pour débutants sur la visualisation de données sans effort

MoeNagy Dev

Qu'est-ce que Shiny Python ?

Shiny Python est un framework puissant pour créer des applications web interactives en utilisant le langage de programmation Python. Il offre un ensemble d'outils et de composants qui permettent aux développeurs de créer des applications web dynamiques et basées sur les données avec un effort minimal.

Shiny Python est souvent comparé à d'autres frameworks web populaires de Python comme Flask et Django, mais il se distingue par son accent sur la création d'interfaces utilisateur (UI) hautement interactives et réactives pour la visualisation, l'analyse et l'exploration de données.

Avantages de l'utilisation de Shiny Python pour le développement web

  1. Interface utilisateur interactive : Shiny Python facilite la création d'interfaces utilisateur interactives qui répondent aux actions de l'utilisateur et se mettent à jour en temps réel, offrant une expérience utilisateur fluide et engageante.

  2. Prototypage rapide : Avec Shiny Python, vous pouvez rapidement construire et itérer sur des applications web, permettant un développement et un test plus rapides des idées.

  3. Intégration des bibliothèques de Python : Shiny Python vous permet de tirer parti de l'écosystème étendu des bibliothèques et modules Python pour le traitement, l'analyse et la visualisation des données, ce qui en fait un outil puissant pour la construction d'applications basées sur les données.

  4. Programmation réactive : Le modèle de programmation réactive de Shiny Python simplifie la gestion de l'état de l'application et la coordination entre l'interface utilisateur et la logique côté serveur.

  5. Déploiement et hébergement : Les applications Shiny Python peuvent être facilement déployées sur différentes plates-formes d'hébergement, y compris les services cloud, ce qui en fait un choix polyvalent pour le développement web.

Commencer avec Shiny Python

Installation de Shiny Python et de ses dépendances

Pour commencer avec Shiny Python, vous devez avoir Python installé sur votre système. Shiny Python est construit sur la base du framework Dash, vous devrez donc également installer les dépendances nécessaires.

Vous pouvez installer Shiny Python et ses dépendances en utilisant pip, l'installateur de packages Python :

pip install shiny

Cela installera Shiny Python et ses dépendances requises, y compris Dash, Flask et Plotly.

Configuration d'un nouveau projet Shiny Python

Une fois que vous avez installé Shiny Python, vous pouvez créer un nouveau projet en configurant un répertoire pour votre application. À l'intérieur de ce répertoire, vous aurez généralement la structure suivante :

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

Le fichier app.py est le point d'entrée principal de votre application Shiny Python, où vous définirez l'interface utilisateur et la logique côté serveur. Le fichier requirements.txt répertorie les packages Python requis pour votre application, qui peuvent être utilisés pour le déploiement. Le répertoire assets est utilisé pour stocker tous les fichiers statiques, tels que les feuilles de style CSS et les images, dont votre application pourrait avoir besoin.

Comprendre la structure des répertoires Shiny Python

La structure des répertoires Shiny Python suit un schéma similaire à celui des autres frameworks web Python, mais avec quelques composants supplémentaires spécifiques à Shiny Python :

  • app.py : Il s'agit du point d'entrée principal de votre application Shiny Python, où vous définissez l'interface utilisateur et la logique côté serveur.
  • ui.py : Ce fichier contient la définition de l'interface utilisateur, y compris la disposition, les entrées et les sorties.
  • server.py : Ce fichier définit la logique côté serveur, telle que la gestion des entrées utilisateur et la mise à jour de l'état de l'application.
  • callbacks.py : Ce fichier contient les fonctions de rappel qui relient l'interface utilisateur à la logique côté serveur.
  • models.py : Si votre application utilise des modèles de données ou des interactions avec une base de données, vous pouvez les définir dans ce fichier.
  • utils.py : Ce fichier peut contenir toutes les fonctions d'aide ou utilitaires utilisés dans votre application.
  • assets/ : Ce répertoire contient tous les fichiers statiques, tels que CSS, JavaScript et images, dont votre application pourrait avoir besoin.

La séparation des responsabilités entre les fichiers ui.py, server.py et callbacks.py permet de maintenir l'organisation et la maintenabilité de votre application Shiny Python à mesure qu'elle se développe en complexité.

Construction d'une application Shiny Python simple

Commençons par construire une application Shiny Python simple qui permet aux utilisateurs de saisir un nombre et affiche le carré de ce nombre.

Création de l'interface utilisateur (UI) avec des composants Shiny Python

Dans le fichier ui.py, nous allons définir l'interface utilisateur de notre application :

from shiny import ui
 
app_ui = ui.page_fluid(
    ui.layout_sidebar(
        ui.panel_sidebar(
            ui.input_numeric("number", "Entrez un nombre", value=0, min_value=0, max_value=100)
        ),
        ui.panel_main(
            ui.output_text_verbatim("output_text")
        )
    )
)

Dans cet exemple, nous utilisons la fonction ui.page_fluid() pour créer une mise en page de page à largeur fluide. À l'intérieur de la page, nous utilisons ui.layout_sidebar() pour créer une mise en page avec une barre latérale et un panneau principal.

Le panneau latéral contient un champ de saisie numérique en utilisant ui.input_numeric(), où l'utilisateur peut entrer un nombre. Le panneau principal contient une aire de texte de sortie en utilisant ui.output_text_verbatim(), où nous afficherons le carré de la saisie de l'utilisateur.

Définition de la logique côté serveur et gestion des interactions utilisateur

Maintenant, créons le fichier server.py pour définir la logique côté serveur :

from shiny import App, Inputs, Outputs, Session
 
def server(input, output, session):
    @Outputs("output_text")
    def square_number():
        number = input.number()
        return f"Le carré de {number} est {number ** 2}"
 
app = App(server, ui)

Dans la fonction server(), nous définissons une expression réactive square_number() qui prend le nombre entré par l'utilisateur, calcule son carré, et renvoie le résultat sous forme de chaîne de caractères. Le décorateur Outputs() est utilisé pour connecter cette fonction serveur à la sortie output_text dans l'interface utilisateur.

Rendu de l'application et exécution en local

Pour exécuter l'application Shiny Python, nous devons créer un fichier app.py qui rassemble l'interface utilisateur et la logique serveur :

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)

Dans ce fichier app.py, nous importons les définitions app_ui et server des fichiers respectifs, puis nous créons une nouvelle instance App en les passant au constructeur App().

Enfin, nous appelons la fonction run_app() pour démarrer l'application Shiny Python et la rendre disponible pour le développement local.

Vous pouvez exécuter l'application en exécutant le fichier app.py :

python app.py

Cela démarrera l'application Shiny Python et l'ouvrira dans votre navigateur web par défaut, où vous pourrez interagir avec l'application et voir le carré du nombre que vous entrez.

Composants d'interface utilisateur Shiny Python

Shiny Python offre une large gamme de composants d'interface utilisateur (UI) que vous pouvez utiliser pour construire vos applications web. Ces composants incluent des entrées, des sorties, des mises en page, et bien plus encore.

Aperçu des composants d'interface utilisateur disponibles

Certains des composants d'interface utilisateur Shiny Python couramment utilisés incluent :

  • Entrées : ui.input_text(), ui.input_numeric(), ui.input_slider(), ui.input_checkbox(), ui.input_date(), et plus encore.
  • Sorties : ui.output_text(), ui.output_table(), ui.output_plot(), ui.output_download(), et plus encore.
  • Mises en page : ui.layout_sidebar(), ui.layout_grid(), ui.layout_row(), ui.layout_column(), et plus encore.
  • Conteneurs : ui.panel_sidebar(), ui.panel_main(), ui.tab_panel(), ui.accordion_panel(), et plus encore.

Chacun de ces composants a son propre ensemble de propriétés et d'options que vous pouvez utiliser pour personnaliser l'apparence et le comportement de votre application.

Personnaliser l'apparence et le comportement des composants d'interface utilisateur

Vous pouvez personnaliser l'apparence et le comportement des composants d'interface utilisateur Shiny Python en définissant leurs différentes propriétés. Par exemple, avec le composant ui.input_text(), vous pouvez définir les propriétés label, value, placeholder, et autres pour contrôler l'apparence et la fonctionnalité du champ de saisie.

Voici un exemple de personnalisation de l'apparence d'un champ de saisie de texte :

ui.input_text(
    "name",
    "Entrez votre nom",
    value="John Doe",
    placeholder="Saisissez votre nom ici",
    style={"width": "300px", "font-size": "16px"}
)

Dans cet exemple, nous définissons les propriétés label, value, placeholder, et style du composant ui.input_text() pour personnaliser son apparence.

Organiser et structurer l'interface utilisateur pour les applications complexes

À mesure que votre application Shiny Python devient plus complexe, il est important d'organiser et de structurer l'interface utilisateur de manière à la rendre facile à gérer et à maintenir.

Une approche courante consiste à utiliser des composants de mise en page tels que ui.layout_sidebar(), ui.layout_grid(), et ui.tab_panel() pour créer une interface utilisateur bien structurée et intuitive. Vous pouvez également utiliser des composants de conteneur tels que ui.panel_sidebar() et ui.panel_main() pour regrouper les éléments d'interface utilisateur liés entre eux.

Voici un exemple de structure d'interface utilisateur plus complexe :

app_ui = ui.page_fluid(
    ui.layout_sidebar(
        ui.panel_sidebar(
            ui.input_text("name", "Entrez votre nom"),
            ui.input_numeric("age", "Entrez votre âge", min_value=0, max_value=120)
        ),
        ui.panel_main(
            ui.tab_panel(
                ui.tab("Aperçu", ui.output_text_verbatim("overview_text")),
                ui.tab("Graphiques",
                    ui.layout_grid(
                        ui.output_plot("plot1"),
                        ui.output_plot("plot2")
                    )
                ),
                ui.tab("Téléchargement", ui.output_download("download_button"))
            )
        )
    )
)

Dans cet exemple, nous utilisons une mise en page avec une barre latérale contenant des champs de saisie et une mise en page en onglets dans le panneau principal. La mise en page en onglets contient trois onglets : "Aperçu", "Graphiques" et "Téléchargement", chacun avec son propre ensemble de sorties.

En organisant l'interface utilisateur de cette manière, vous pouvez créer des applications complexes et intuitives qui sont faciles à naviguer et à maintenir.

Fonctions serveur Shiny Python

La logique côté serveur d'une application Shiny Python est définie dans le fichier server.py. C'est là que vous gérez les entrées des utilisateurs, effectuez le traitement et l'analyse des données, et mettez à jour l'état de l'application.

Gérer les entrées des utilisateurs et mettre à jour l'état de l'application

Dans la logique côté serveur, vous pouvez définir des fonctions qui répondent aux entrées des utilisateurs et mettent à jour l'état de l'application en conséquence. Ces fonctions sont généralement décorées avec le décorateur Inputs(), qui les connecte aux composants d'entrée correspondants dans l'interface utilisateur.

Voici un exemple de fonction serveur qui gère une saisie de texte et met à jour l'état de l'application :

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

Dans cet exemple, la fonction greet_user() est décorée avec Inputs("name"), ce qui signifie qu'elle sera appelée chaque fois que l'utilisateur modifie la valeur de la saisie "name". La fonction prend le nom de l'utilisateur, le concatène avec une salutation, et renvoie le résultat.

La fonction display_greeting() est décorée avec Outputs("greeting"), ce qui signifie que sa valeur de retour sera utilisée pour mettre à jour la sortie "greeting" dans l'interface utilisateur.

Effectuer le traitement et l'analyse des données côté serveur


title: "Shiny Python" language: fr

Shiny Python vous permet d'intégrer votre application avec diverses bibliothèques et modules Python pour le traitement, l'analyse et la visualisation de données. Cela peut être fait dans la logique côté serveur.

Voici un exemple de fonction serveur qui effectue une analyse de données simple et génère un graphique :

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

Dans cet exemple, la fonction analyze_dataset est utilisée pour effectuer une analyse de données et renvoyer un résumé sous forme de tableau HTML. Les fonctions display_dataset_summary et plot_dataset utilisent la fonction analyze_dataset pour afficher le résumé du jeu de données et générer un tracé, respectivement.

Structures de données

Listes

Les listes sont l'une des structures de données les plus fondamentales en Python. Ce sont des collections ordonnées d'éléments, qui peuvent être de différents types de données. Voici un exemple :

fruits = ['pomme', 'banane', 'cerise']
print(fruits)  # Sortie : ['pomme', 'banane', 'cerise']

Vous pouvez accéder aux éléments individuels d'une liste en utilisant leur index, qui commence à 0 :

print(fruits[0])  # Sortie : 'pomme'
print(fruits[1])  # Sortie : 'banane'

Vous pouvez également modifier les éléments d'une liste :

fruits[1] = 'orange'
print(fruits)  # Sortie : ['pomme', 'orange', 'cerise']

Les listes ont de nombreuses méthodes intégrées qui vous permettent d'effectuer diverses opérations, telles que l'ajout, la suppression et le tri des éléments.

Tuples

Les tuples sont similaires aux listes, mais ils sont immuables, ce qui signifie que vous ne pouvez pas modifier leurs éléments après leur création. Les tuples sont définis à l'aide de parenthèses au lieu de crochets :

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

Les tuples peuvent être utiles lorsque vous souhaitez stocker un ensemble fixe de valeurs, telles que les coordonnées d'un point ou les dimensions d'un rectangle.

Dictionnaires

Les dictionnaires sont des collections non ordonnées de paires clé-valeur. Ils vous permettent de stocker et de récupérer rapidement des données en utilisant une clé unique pour chaque valeur. Voici un exemple :

personne = {
    'nom': 'John Doe',
    'âge': 30,
    'ville': 'New York'
}
print(personne['nom'])  # Sortie : 'John Doe'
print(personne['âge'])  # Sortie : 30

Vous pouvez ajouter, modifier et supprimer des paires clé-valeur dans un dictionnaire :

personne['email'] = 'john.doe@example.com'
personne['âge'] = 31
del personne['ville']
print(personne)  # Sortie : {'nom': 'John Doe', 'âge': 31, 'email': 'john.doe@example.com'}

Les dictionnaires sont très polyvalents et peuvent être utilisés pour représenter un large éventail de structures de données, des simples magasins clé-valeur aux structures imbriquées plus complexes.

Ensembles

Les ensembles sont des collections non ordonnées d'éléments uniques. Ils sont utiles pour effectuer des opérations telles que l'union, l'intersection et la différence sur des collections de données. Voici un exemple :

couleurs = {'rouge', 'vert', 'bleu'}
print(couleurs)  # Sortie : {'rouge', 'vert', 'bleu'}
 
# Ajout d'un élément à un ensemble
couleurs.add('jaune')
print(couleurs)  # Sortie : {'rouge', 'vert', 'bleu', 'jaune'}
 
# Suppression d'un élément d'un ensemble
couleurs.remove('vert')
print(couleurs)  # Sortie : {'rouge', 'bleu', 'jaune'}

Les ensembles sont particulièrement utiles pour supprimer les valeurs en double d'une collection ou pour effectuer des opérations basées sur les ensembles.

Flux de contrôle

Instructions conditionnelles

Les instructions conditionnelles en Python vous permettent d'exécuter un code différent en fonction de certaines conditions. L'instruction conditionnelle la plus courante est l'instruction if-elif-else :

x = 10
if x > 0:
    print("x est positif")
elif x < 0:
    print("x est négatif")
else:
    print("x est zéro")

Vous pouvez également utiliser l'opérateur ternaire, qui fournit une façon plus concise d'écrire des instructions if-else simples :

âge = 18
est_adulte = "Oui" if âge >= 18 else "Non"
print(est_adulte)  # Sortie : "Oui"

Boucles

Les boucles en Python vous permettent d'exécuter de manière répétée un bloc de code. Les deux types de boucles les plus courants sont les boucles for et les boucles while.

Une boucle for est utilisée pour itérer sur une séquence (comme une liste, un tuple ou une chaîne de caractères) :

fruits = ['pomme', 'banane', 'cerise']
for fruit in fruits:
    print(fruit)

Une boucle while est utilisée pour exécuter un bloc de code tant qu'une certaine condition est vraie :

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

Vous pouvez également utiliser les instructions break et continue pour contrôler le flux d'une boucle :

for i in range(10):
    if i == 5:
        break  # Quitte la boucle lorsque i vaut 5
    if i % 2 == 0:
        continue  # Passe à l'itération suivante lorsque i est pair
    print(i)  # Sortie : 1, 3, 7, 9

Fonctions

Les fonctions en Python sont des blocs de code réutilisable qui effectuent une tâche spécifique. Elles peuvent prendre des arguments et renvoyer des valeurs. Voici un exemple simple :

def saluer(nom):
    print(f"Bonjour, {nom} !")
 
saluer("Alice")  # Sortie : "Bonjour, Alice !"

Vous pouvez également définir des fonctions avec des arguments par défaut et des arguments de longueur variable :

def calculer_surface(longueur, largeur, hauteur=1):
    return longueur * largeur * hauteur
 
print(calculer_surface(2, 3))  # Sortie : 6
print(calculer_surface(2, 3, 4))  # Sortie : 24

Les fonctions peuvent également être récursives, c'est-à-dire qu'elles peuvent s'appeler elles-mêmes pour résoudre un problème :

def factorielle(n):
    if n == 0:
        return 1
    else:
        return n * factorielle(n-1)
 
print(factorielle(5))  # Sortie : 120

Modules et packages

La bibliothèque standard étendue et les packages tiers de Python offrent une large gamme de fonctionnalités que vous pouvez utiliser dans vos programmes. Pour utiliser un module ou un package, vous devez l'importer.

Voici un exemple d'importation du module math et d'utilisation de ses fonctions :

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

Vous pouvez également importer des fonctions ou des attributs spécifiques d'un module :

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

De plus, vous pouvez créer vos propres modules et packages pour organiser votre code et le rendre plus réutilisable.

Conclusion

Dans ce tutoriel, vous avez appris les différentes structures de données, les instructions de contrôle, les fonctions et les modules en Python. Ce sont les blocs de construction fondamentaux de tout programme Python. Avec ces connaissances, vous pouvez commencer à écrire des applications plus complexes et puissantes. N'oubliez pas, la clé pour devenir un programmeur Python compétent est de pratiquer, expérimenter et continuer à apprendre. Bonne chance!

MoeNagy Dev