Jupyter

À quoi ça sert

Quand tu écris un script Python classique, il s'exécute du début à la fin et tu vois tout le résultat à la fin. Pas pratique pour explorer : à chaque petite question (« combien de lignes a mon CSV ? », « à quoi ressemble la distribution de l'âge ? »), tu dois relancer le script entier.

Un notebook Jupyter, c'est un fichier découpé en cellules. Chaque cellule contient soit du code, soit du texte (Markdown). Tu lances une cellule à la fois — les variables restent en mémoire (le « kernel »), donc tu peux itérer rapidement. Les résultats (tableaux, graphiques) s'affichent juste sous la cellule qui les a produits.

C'est devenu le standard de fait pour :

• L'exploration de données — charger un dataset, regarder ce qu'il y a dedans, faire des graphiques en quelques lignes.
• Le prototypage de modèles ML — entraîner, ajuster, comparer sans recharger les données à chaque essai.
• La pédagogie et la communication — un notebook se lit comme un article, avec le code reproductible à côté du raisonnement.

Un exemple d'usage

Tu reçois un CSV avec les ventes mensuelles d'un magasin. Tu veux juste regarder avant de te lancer dans une analyse. Dans un notebook :

import pandas as pd

df = pd.read_csv("ventes.csv")
df.head()

Tu lances cette cellule (Shift+Enter), tu vois les 5 premières lignes. Tu enchaînes :

df.describe()

df["montant"].plot(kind="hist", bins=30)

Le DataFrame df est resté en mémoire entre les cellules. Tu n'as pas rechargé le CSV. Tu peux modifier la cellule 3 (changer le nombre de bins, sélectionner une autre colonne) et la relancer instantanément. C'est cette boucle d'itération courte qui rend Jupyter indispensable en data.

How-to : installer et utiliser Jupyter

1. Installer JupyterLab dans ton projet

   On reste dans la logique UV : on installe JupyterLab comme dépendance de développement.

   bash Copier

   uv add --dev jupyterlab pandas matplotlib

   jupyterlab est l'interface, pandas et matplotlib sont les compagnons habituels pour l'exploration de données.

2. Lancer JupyterLab

   bash Copier

   uv run jupyter lab

   Ton navigateur s'ouvre automatiquement sur http://localhost:8888 avec un token déjà rempli. Tu vois l'arborescence de ton projet à gauche.

3. Créer ton premier notebook

   Dans le panneau de gauche, clique sur « + » puis sur Notebook → Python 3. Un fichier Untitled.ipynb s'ouvre. Renomme-le (clic droit → Rename) en exploration.ipynb.

   Tape ton premier code dans la cellule :

   python Copier

   print("Hello Jupyter")
   2 + 2

   Lance avec Shift+Enter. Tu verras s'afficher Hello Jupyter et le résultat 4 sous la cellule. Note que seule la dernière expression d'une cellule est affichée automatiquement (en plus des print).

4. Mélanger code et texte

   Une cellule peut être en mode Code ou Markdown. Clique sur la cellule, puis utilise le menu déroulant en haut (ou le raccourci M en mode commande) pour la passer en Markdown :

   markdown Copier

   # Mon analyse des ventes
   
   On regarde d'abord la **distribution** des montants pour repérer
   d'éventuelles valeurs aberrantes.

   Lancer la cellule (toujours Shift+Enter) la rend en HTML. C'est ce mélange code + texte qui fait qu'un notebook se lit comme un article.

5. Maîtriser les deux modes (édition / commande)

   Une cellule peut être en mode édition (bordure bleue, curseur dans le code) ou en mode commande (bordure grise, raccourcis clavier actifs). Bascule avec Esc et Enter.

   Raccourcis essentiels en mode commande :

   • A / B — insérer une cellule au-dessus / en-dessous
   • D D — supprimer la cellule
   • M / Y — passer en Markdown / Code
   • Z — annuler la suppression
   • Shift+Enter — exécuter et passer à la suivante
   • Ctrl+Enter — exécuter sans bouger

6. Utiliser Jupyter directement dans VS Code

   Pas envie de jongler entre VS Code et un onglet de navigateur ? VS Code ouvre les .ipynb nativement.

   1. Installe l'extension Jupyter de Microsoft (et l'extension Python).
   2. Ouvre n'importe quel fichier .ipynb dans VS Code.
   3. En haut à droite, clique sur Select Kernel et choisis l'interpréteur du .venv de ton projet (celui créé par UV).
   4. Tu peux lancer les cellules avec les mêmes raccourcis qu'en JupyterLab.
   Astuce VS Code

   Dans un script Python normal (.py), tu peux écrire # %% au-dessus d'une portion de code : VS Code la traite comme une cellule Jupyter exécutable. Tu obtiens le confort des notebooks sans les inconvénients des .ipynb (cf. ci-dessous).

7. Bien gérer les notebooks dans Git

   Un .ipynb contient le code et les sorties (graphiques inclus, parfois en base64). Résultat : des diffs Git énormes et illisibles dès que tu relances une cellule.

   Deux bonnes pratiques :

   • Vider les sorties avant de commit : Edit → Clear All Outputs dans JupyterLab.
   • Automatiser avec nbstripout : uv add --dev nbstripout && uv run nbstripout --install — il vide les sorties à chaque commit, automatiquement.

Aide-mémoire

uv run jupyter lab            # JupyterLab (recommandé)
uv run jupyter notebook       # interface classique
uv run jupyter lab --port 9000
uv run jupyter nbconvert --to html notebook.ipynb  # export HTML
uv run jupyter nbconvert --to script notebook.ipynb # export .py

# Mesurer le temps
%time df.describe()         # une fois
%%timeit                       # sur toute la cellule (moyenne)
expensive_function()

# Recharger un module modifié sans redémarrer le kernel
%load_ext autoreload
%autoreload 2

# Exécuter une commande shell depuis une cellule
!ls -lh data/
!uv add seaborn

# Afficher les graphiques inline (rarement nécessaire avec JupyterLab récent)
%matplotlib inline

Jupyter et le reste de l'écosystème

Le notebook est un point d'entrée — il prend tout son sens quand on le branche aux autres briques d'un workflow data/ML.

• UV — c'est UV qui fournit l'interpréteur Python utilisé par le kernel Jupyter. Quand tu lances uv run jupyter lab, le kernel pointe automatiquement sur le .venv du projet, donc toutes les libs ajoutées avec uv add sont disponibles dans tes notebooks.
• MLflow — un notebook est l'endroit naturel pour appeler mlflow.start_run() et tester plusieurs modèles. Avec mlflow.sklearn.autolog(), chaque cellule d'entraînement crée un run trackable. Mais attention : pour la production, on ré-écrit en script .py propre (cf. ci-dessous).
• Docker — l'image officielle quay.io/jupyter/scipy-notebook donne un JupyterLab préinstallé avec pandas/scikit-learn/matplotlib. Pratique pour partager un environnement avec un coéquipier sans qu'il ait à l'installer.
• pytest — le notebook est génial pour explorer, mais pas pour tester. Le pattern habituel : extraire les fonctions stables d'un notebook vers un module .py, écrire des tests pytest dessus, et garder le notebook comme « scratchpad ».
• Sphinx — l'extension nbsphinx permet d'inclure des notebooks directement dans une documentation Sphinx. Utile pour des tutoriels où le code et les sorties graphiques sont essentiels.

Pour aller plus loin

• Site officiel : jupyter.org
• Documentation JupyterLab : jupyterlab.readthedocs.io
• Extension Jupyter pour VS Code : marketplace.visualstudio.com
• nbstripout (vider les sorties dans Git) : github.com/kynan/nbstripout