Python
Maîtriser Python Shiny : Guide pour débutants

Maîtriser Python Shiny : Guide pour débutants

MoeNagy Dev

Qu'est-ce que Python Shiny ?

Python Shiny, également connu sous le nom Shiny for Python, est un framework d'application web qui permet aux développeurs de construire des applications interactives et axées sur les données en utilisant le langage de programmation Python. Shiny a été initialement développé pour le langage de programmation R, mais la version Python propose un ensemble similaire de fonctionnalités et de capacités, permettant aux développeurs Python de créer des applications web réactives et dynamiques avec un effort minimal.

Définition de Python Shiny

Python Shiny est un framework qui permet la création d'applications web interactives en utilisant Python. Il fournit un ensemble d'outils et de fonctions qui simplifient le processus de construction, de déploiement et de maintenance des applications web, en particulier celles qui impliquent la visualisation des données, l'analyse et les interfaces utilisateurs interactives.

Aperçu du framework Shiny

Le framework Shiny est conçu pour faciliter la création d'applications web qui peuvent être utilisées pour présenter des données, effectuer des analyses et interagir avec les utilisateurs. Il suit un modèle de programmation réactif, où les changements dans l'interface utilisateur (UI) ou les données déclenchent automatiquement des mises à jour dans la logique et les sorties de l'application.

Les applications Shiny sont généralement composées de deux composants principaux :

  1. Interface utilisateur (UI) : L'interface utilisateur définit la mise en page, l'apparence et les éléments interactifs de l'application, tels que les boutons, les menus déroulants, les tableaux et les graphiques.
  2. Logique du Serveur : La logique du serveur contient le code Python qui gère les entrées des utilisateurs, traite les données et génère le contenu dynamique à afficher dans l'interface utilisateur.

Les applications Shiny peuvent être déployées sur diverses plateformes, notamment des environnements de développement locaux, des services d'hébergement cloud et des serveurs d'entreprise.

Fonctionnalités clés et avantages de l'utilisation de Python Shiny

  1. Développement d'applications Rapide : Shiny simplifie le processus de construction d'applications web interactives, permettant aux développeurs de se concentrer sur la fonctionnalité principale plutôt que les détails sous-jacents du développement web.
  2. Programmation Réactive : Le modèle de programmation réactive de Shiny garantit que les changements dans l'interface utilisateur (UI) ou les données déclenchent automatiquement des mises à jour dans l'application, offrant ainsi une expérience utilisateur fluide et réactive.
  3. Flexibilité et Extensibilité : Les applications Shiny peuvent être personnalisées et étendues en utilisant HTML, CSS, JavaScript et d'autres bibliothèques Python, permettant aux développeurs de créer des solutions sur mesure.
  4. Intégration avec l'Écosystème Python : Shiny s'intègre parfaitement avec l'immense écosystème Python, permettant aux développeurs de tirer parti d'une large gamme d'outils de traitement, d'analyse et de visualisation des données.
  5. Options de Déploiement : Les applications Shiny peuvent être déployées sur différentes plateformes, des environnements de développement locaux aux services d'hébergement cloud, ce qui les rend accessibles à un large éventail d'utilisateurs.
  6. Communauté et Support : La communauté Shiny fournit une multitude de ressources, y compris la documentation, les tutoriels et les applications contribuées par la communauté, ce qui facilite l'apprentissage et le développement sur le framework.

Commencer avec Python Shiny

Installation de Python Shiny

Pour commencer avec Python Shiny, vous devez avoir Python installé sur votre système. Vous pouvez ensuite installer le package Shiny à l'aide de pip, l'outil d'installation de packages Python :

pip install shiny

Cela installera le package Shiny de base, ainsi que toute dépendance nécessaire.

Configuration de l'environnement de développement

En plus du package Shiny, vous voudrez peut-être configurer un environnement de développement pour faciliter le processus de création de vos applications Shiny. Voici quelques outils et pratiques recommandés :

  1. Environnement de développement intégré (IDE) : Utilisez un IDE compatible avec Python, tel que PyCharm, Visual Studio Code ou Jupyter Notebook, pour écrire, tester et déboguer vos applications Shiny.
  2. Environnements virtuels : Créez un environnement virtuel pour isoler les dépendances de votre projet Shiny des autres projets Python sur votre système. Cela peut être fait à l'aide d'outils tels que venv ou conda.
  3. Contrôle de Version : Utilisez un système de contrôle de version, tel que Git, pour gérer le code de votre application Shiny et collaborer avec d'autres développeurs, si nécessaire.
  4. Outils de Déploiement : Explorez les options et les outils de déploiement, tels que Docker ou les plates-formes d'hébergement basées sur le cloud, pour simplifier le processus de publication de vos applications Shiny.

Création d'une application Shiny de base

Commençons par créer une application Shiny simple qui affiche un titre et un bouton. Créez un nouveau fichier Python, par exemple, app.py, et ajoutez le code suivant :

import shiny
from shiny import App, Inputs, Outputs, Session
 
app = App(
    ui=shiny.ui.page_fluid(
        shiny.ui.h1("Bienvenue dans mon application Shiny !"),
        shiny.ui.button_primary("Cliquez ici", "my_button"),
    ),
    server=function(input, output, session):
        @shiny.input
        def my_button_clicks(event):
            return 0
)
 
if __name__ == "__main__":
    app.run()

Dans cet exemple, nous définissons l'interface utilisateur (UI) en utilisant les composants UI de Shiny, notamment un titre et un bouton principal. La logique côté serveur définit simplement une fonction d'entrée réactive qui suit le nombre de fois où le bouton est cliqué.

Pour exécuter l'application, enregistrez le fichier et exécutez la commande suivante dans votre terminal :

python app.py

Cela lancera l'application Shiny et l'ouvrira dans votre navigateur web par défaut.

Construction de l'Interface Utilisateur (UI)

L'interface utilisateur (UI) Shiny est responsable de l'agencement, de l'apparence et des éléments interactifs de votre application. Shiny propose une large gamme de composants d'interface utilisateur que vous pouvez utiliser pour construire l'interface de votre application.

Composants de l'interface utilisateur Shiny

Shiny offre une variété de composants d'interface utilisateur que vous pouvez utiliser pour construire l'interface de votre application, notamment:

  • Layouts: page_fluid(), page_fixed(), sidebar_layout(), tabs(), et plus
  • Inputs: text_input(), numeric_input(), slider_input(), dropdown(), et plus
  • Outputs: text_output(), plot_output(), table_output(), et plus
  • Containers: column(), row(), box(), card(), et plus
  • Formatting: h1(), h2(), p(), br(), div(), et plus

Voici un exemple de la façon dont vous pouvez utiliser certains de ces composants pour créer une interface plus complexe:

from shiny import App, Inputs, Outputs, Session
 
app = App(
    ui=shiny.ui.page_fluid(
        shiny.ui.h1("Ma application Shiny"),
        shiny.ui.sidebar_layout(
            shiny.ui.sidebar(
                shiny.ui.input_text("name", "Nom"),
                shiny.ui.input_numeric("age", "Âge", min=0, max=120),
                shiny.ui.input_dropdown("gender", "Genre", ["Homme", "Femme", "Autre"]),
            ),
            shiny.ui.main_panel(
                shiny.ui.text_output("greeting"),
                shiny.ui.plot_output("plot")
            )
        )
    ),
    server=function(input, output, session):
        @shiny.output
        def greeting():
            return f"Bonjour, {input.name()}! Vous avez {input.age()} ans et votre genre est {input.gender()}."
 
        @shiny.output
        def plot():
            # Générer un graphique en utilisant Matplotlib, Plotly, ou une autre bibliothèque de visualisation
            import matplotlib.pyplot as plt
            plt.plot([1, 2, 3, 4], [1, 4, 9, 16])
            return plt.gcf()
)
 
if __name__ == "__main__":
    app.run()

Dans cet exemple, nous utilisons sidebar_layout() pour créer une interface réactive avec une barre latérale et un panneau principal. La barre latérale contient des composants d'entrée pour le nom, l'âge et le genre de l'utilisateur, tandis que le panneau principal affiche un message de salutation et un graphique.

Personnalisation de la mise en page et de l'apparence

Shiny vous permet de personnaliser la mise en page et l'apparence de votre application à l'aide d'HTML, de CSS et de JavaScript. Vous pouvez soit insérer ces éléments directement dans le code de votre interface Shiny, soit faire référence à des fichiers externes.

Par exemple, pour ajouter un fichier CSS personnalisé à votre application Shiny, vous pouvez utiliser la fonction tags.link():

from shiny import App, Inputs, Outputs, Session
from shiny.types import TagList
 
app = App(
    ui=shiny.ui.page_fluid(
        shiny.tags.link(rel="stylesheet", href="custom.css"),
        # Autres composants d'interface
    ),
    server=function(input, output, session):
        # Logique du serveur
)
 
if __name__ == "__main__":
    app.run()

Dans ce cas, le fichier custom.css doit être placé dans le même répertoire que votre fichier app.py.

Vous pouvez également utiliser les classes CSS et les thèmes intégrés de Shiny pour personnaliser l'interface de votre application. Shiny fournit plusieurs thèmes prédéfinis, tels que "cerulean", "cosmo", et "flatly", que vous pouvez appliquer aux composants page_fluid() ou page_fixed() de votre application.

app = App(
    ui=shiny.ui.page_fluid(
        theme=shiny.bootstrap.themes.cerulean,
        # Other UI components
    ),
    server=function(input, output, session):
        # Logique du serveur
)

Gestion des interactions utilisateur

Le modèle de programmation réactif de Shiny vous permet de créer des applications qui répondent aux interactions de l'utilisateur en temps réel. Cela est possible grâce à l'utilisation d'entrées et de sorties réactives.

Programmation réactive dans Shiny

Dans Shiny, la logique côté serveur est définie sous la forme d'un ensemble de fonctions réactives qui réagissent aux changements d'état de l'application, tels que les entrées de l'utilisateur ou d'autres valeurs réactives. Ces fonctions réactives sont marquées avec les décorateurs @shiny.input ou @shiny.output, selon qu'elles sont responsables de la gestion des entrées de l'utilisateur ou de la génération de sorties pour l'interface utilisateur.

Voici un exemple d'une simple fonction d'entrée réactive:

from shiny import App, Inputs, Outputs, Session
 
app = App(
    ui=shiny.ui.page_fluid(
        shiny.ui.input_text("name", "Entrez votre nom"),
        shiny.ui.text_output("greeting"),
    ),
    server=function(input, output, session):
        @shiny.output
        def greeting():
            return f"Bonjour, {input.name()}!"
)
 
if __name__ == "__main__":
    app.run()

Dans cet exemple, la fonction greeting() est une sortie réactive qui dépend de la valeur de l'entrée name. Chaque fois que l'utilisateur modifie le texte dans le champ d'entrée, la fonction greeting() est automatiquement réévaluée et la nouvelle sortie est affichée dans l'interface.

Réagir aux entrées de l'utilisateur

Shiny propose une large gamme de composants d'entrée que vous pouvez utiliser pour capturer les interactions de l'utilisateur, tels que les entrées de texte, les entrées numériques, les listes déroulantes, les curseurs et les boutons. Vous pouvez ensuite définir des fonctions réactives dans la logique côté serveur pour gérer ces entrées et mettre à jour l'état de l'application en conséquence.

Voici un exemple de la façon dont vous pouvez réagir à un clic sur un bouton:

from shiny import App, Inputs, Outputs, Session
 
app = App(
    ui=shiny.ui.page_fluid(
        shiny.ui.button_primary("Cliquez ici", "my_button"),
        shiny.ui.text_output("click_count"),
    ),
    server=function(input, output, session):
        click_count = 0
 
        @shiny.input
        def my_button_clicks(event):
            nonlocal click_count
            click_count += 1
            return click_count
 
        @shiny.output
        def click_count():
            return f"Vous avez cliqué sur le bouton {input.my_button_clicks()} fois."
)
 
if __name__ == "__main__":
    app.run()

Dans cet exemple, la fonction my_button_clicks() est une entrée réactive qui compte le nombre de fois que le bouton a été cliqué. La fonction click_count() est une sortie réactive qui affiche le nombre de clics actuel dans l'interface utilisateur.

Mise à jour de l'interface utilisateur en fonction des actions de l'utilisateur

Le modèle de programmation réactif de Shiny permet de mettre à jour facilement l'interface utilisateur en réponse aux actions de l'utilisateur. Vous pouvez définir des fonctions de sortie réactives qui génèrent du contenu dynamique, tels que des graphiques, des tableaux ou du texte, et ces sorties se mettront automatiquement à jour lorsque les données ou l'état sous-jacents changent.

Voici un exemple de mise à jour d'un graphique en fonction de l'entrée de l'utilisateur :

from shiny import App, Inputs, Outputs, Session
import numpy as np
import matplotlib.pyplot as plt
 
app = App(
    ui=shiny.ui.page_fluid(
        shiny.ui.input_numeric("num_points", "Nombre de points", min=10, max=1000, value=100),
        shiny.ui.plot_output("plot"),
    ),
    server=function(
 
## 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 et peuvent contenir des éléments de différents types de données. Voici un exemple :
 
```python
my_list = [1, 'bonjour', 3.14, True]

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

print(my_list[0])  # Résultat : 1
print(my_list[2])  # Résultat : 3.14

Les listes prennent en charge une variété de méthodes pour manipuler leur contenu, telles que append(), insert(), remove() et pop().

my_list.append(42)
my_list.insert(1, 'monde')
my_list.remove(True)
popped_item = my_list.pop(2)

Tuples

Les tuples sont similaires aux listes, mais ils sont immuables, c'est-à-dire que leur contenu ne peut pas être modifié après leur création. Les tuples sont définis en utilisant des parenthèses au lieu de crochets.

my_tuple = (1, 'bonjour', 3.14)

Vous pouvez accéder aux éléments d'un tuple de la même manière que pour une liste :

print(my_tuple[0])  # Résultat : 1
print(my_tuple[2])  # Résultat : 3.14

Les tuples sont souvent utilisés pour représenter des structures de données fixes, telles que les coordonnées d'un point dans l'espace en 2D.

Dictionnaires

Les dictionnaires sont des collections non ordonnées de paires clé-valeur. Ils sont définis à l'aide d'accolades, chaque paire clé-valeur étant séparée par un deux-points.

my_dict = {'name': 'John', 'age': 30, 'city': 'New York'}

Vous pouvez accéder aux valeurs d'un dictionnaire en utilisant leurs clés correspondantes :

print(my_dict['name'])  # Résultat : 'John'
print(my_dict['age'])   # Résultat : 30

Les dictionnaires sont utiles pour stocker et récupérer rapidement des données, et sont souvent utilisés dans des applications nécessitant une recherche par clé-valeur, comme la mise en cache et la gestion de la configuration.

Ensembles

Les ensembles sont des collections non ordonnées d'éléments uniques. Ils sont définis à l'aide d'accolades, similaires aux dictionnaires, mais sans les paires clé-valeur.

my_set = {1, 2, 3, 4, 5}

Les ensembles sont utiles pour effectuer des opérations telles que l'union, l'intersection et la différence sur des collections d'éléments uniques.

set1 = {1, 2, 3}
set2 = {2, 3, 4}
print(set1 | set2)  # Résultat : {1, 2, 3, 4}
print(set1 & set2)  # Résultat : {2, 3}
print(set1 - set2)  # Résultat : {1}

Flux de contrôle

Instructions conditionnelles

Les instructions conditionnelles en Python utilisent les mots-clés if, elif et else pour exécuter des blocs de code différents en fonction de certaines conditions.

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

Boucles

Python prend en charge deux types principaux de boucles : les boucles for et les boucles while. Les boucles for sont utilisées pour itérer sur des séquences, telles que des listes, des tuples ou des chaînes de caractères, tandis que les boucles while sont utilisées pour exécuter un bloc de code tant qu'une certaine condition est vraie.

# Boucle for
for i in range(5):
    print(i)  # Résultat : 0 1 2 3 4
 
# Boucle while
count = 0
while count < 3:
    print(count)
    count += 1  # Résultat : 0 1 2

Compréhensions de liste

Les compréhensions de liste permettent de créer de nouvelles listes basées sur des listes existantes de manière concise. Elles sont particulièrement utiles pour effectuer des transformations ou des opérations de filtrage sur des collections de données.

# Créer une liste de carrés
numbers = [1, 2, 3, 4, 5]
squares = [x**2 for x in numbers]
print(squares)  # Résultat : [1, 4, 9, 16, 25]
 
# Filtrer les nombres pairs
even_numbers = [x for x in numbers if x % 2 == 0]
print(even_numbers)  # Résultat : [2, 4]

Fonctions

Les fonctions en Python sont définies à l'aide du mot-clé def, suivi du nom de la fonction et d'un ensemble de parenthèses pouvant contenir des paramètres.

def greet(name):
    print(f"Bonjour, {name} !")
 
greet("Alice")  # Résultat : Bonjour, Alice !

Les fonctions peuvent également renvoyer des valeurs à l'aide du mot-clé return.

def add_numbers(a, b):
    return a + b
 
result = add_numbers(3, 4)
print(result)  # Résultat : 7

Arguments par défaut et arguments de mot-clé

Les fonctions peuvent avoir des valeurs par défaut pour leurs paramètres et accepter également des arguments de mot-clé.

def greet(name, message="Bonjour"):
    print(f"{message}, {name} !")
 
greet("Alice")  # Résultat : Bonjour, Alice !
greet("Bob", message="Salut")  # Résultat : Salut, Bob !

Portée des variables

Python a différents niveaux de portée des variables, notamment local, global et intégré. Comprendre la portée des variables est important pour éviter les conflits de noms et s'assurer que votre code se comporte comme prévu.

variable_globale = 10
 
def my_function():
    variable_locale = 20
    print(variable_globale)  # Peut accéder à la variable globale
    print(variable_locale)   # Peut accéder à la variable locale
 
my_function()
print(variable_globale)  # Peut accéder à la variable globale
# print(variable_locale)  # Erreur : variable_locale n'est pas définie en dehors de la fonction

Modules et packages

La modularité de Python vous permet d'organiser votre code en composants réutilisables. Les modules sont des fichiers Python individuels, tandis que les packages sont des collections de modules.

# my_module.py
def say_hello(name):
    print(f"Bonjour, {name} !")
 
# main.py
import my_module
my_module.say_hello("Alice")  # Résultat : Bonjour, Alice !

Vous pouvez également importer des fonctions ou des attributs spécifiques d'un module à l'aide du mot-clé from.

from my_module import say_hello
say_hello("Bob")  # Résultat : Bonjour, Bob !

Les packages sont créés en ajoutant un fichier __init__.py à un répertoire contenant plusieurs modules.

mon_package/
    __init__.py
    module1.py

Vous pouvez ensuite importer des fonctions ou des classes du package en utilisant le nom du package.

import my_package.module1
my_package.module1.my_function()

Conclusion

Dans ce tutoriel, nous avons couvert un large éventail de concepts Python, y compris les structures de données, le flux de contrôle, les fonctions et les modules. Ces blocs de construction fondamentaux serviront de base solide pour vous permettre de poursuivre votre exploration et votre maîtrise du langage de programmation Python. N'oubliez pas de vous entraîner régulièrement, d'expérimenter avec différents exemples et de rechercher des ressources supplémentaires pour approfondir vos connaissances en Python. Bon codage!

MoeNagy Dev