Jupyter : Notebooks et JupyterLab pour la Data Science

Jupyter Notebook est l’outil préféré des data scientists et des chercheurs en Python. Il combine le code exécutable, la documentation en Markdown, les visualisations et les résultats textuels dans un seul document interactif. JupyterLab, l’interface moderne de Jupyter, étend cette expérience en ajoutant un gestionnaire de fichiers, un terminal intégré, et une extensibilité complète. Ce guide vous montre comment installer, configurer et maîtriser Jupyter pour développer et documenter vos analyses de données.

1. Installation et Configuration

Installation avec pip

# Installation de base
# pip install jupyter

# Installation avec support complet
# pip install jupyterlab

# Vérifier l'installation
# jupyter --version
# jupyter kernelspec list

L’installation via pip est recommandée dans un environnement virtuel dédié, afin d’éviter les conflits de dépendances.

# Créer un environnement virtuel
# python -m venv env_jupyter
# source env_jupyter/bin/activate  # Sur Linux/macOS
# env_jupyter\Scripts\activate      # Sur Windows

# Installer Jupyter dans cet environnement
# pip install jupyterlab numpy pandas matplotlib

Environnements virtuels et Kernels

Chaque environnement Python doit disposer de son propre kernel Jupyter. Un kernel est le processus qui exécute le code dans votre notebook.

# Créer un environnement pour data science
# python -m venv ds_env
# source ds_env/bin/activate
# pip install ipykernel

# Enregistrer ce kernel auprès de Jupyter
# python -m ipykernel install --user --name ds_env --display-name "Python (DS)"

# Créer un autre environnement pour du développement web
# python -m venv web_env
# source web_env/bin/activate
# pip install ipykernel flask django

# Enregistrer ce kernel
# python -m ipykernel install --user --name web_env --display-name "Python (Web)"

# Lister tous les kernels disponibles
# jupyter kernelspec list

Une fois les kernels enregistrés, vous pouvez basculer entre eux dans Jupyter via le menu « Kernel » ou en bas à droite du notebook.

2. Notebook versus JupyterLab

Notebook classique

Jupyter Notebook est une interface minimaliste et légère. Elle se lance avec :

# jupyter notebook
# Cette commande ouvre une interface web à http://localhost:8888

Avantages du Notebook classique :

• Léger, peu de ressources
• Simple, peu de distractions
• Démarrage rapide

JupyterLab

JupyterLab est la prochaine génération de Jupyter, avec une interface modulaire et extensible.

# jupyter lab
# Cette commande ouvre JupyterLab à http://localhost:8888

Avantages de JupyterLab :

• Plusieurs fichiers ouverts dans des onglets
• Gestionnaire de fichiers intégré à gauche
• Terminal et console intégrés
• Visualiseur d’images natif
• Extensibilité via des plugins TypeScript/JavaScript
• Barre latérale collapsible

3. Structure des Cellules

Cellule de Code

Une cellule de code contient du Python exécutable. Elle s’exécute en appuyant sur Ctrl+Entrée (ou Cmd+Entrée sur Mac).

# Cellule de code

import numpy as np

data = np.array([1, 2, 3, 4, 5])
moyenne = data.mean()

print(f"Moyenne : {moyenne}")
# Affichage : Moyenne : 3.0

L’ordre d’exécution est déterminé par le numéro entre crochets : [1], [2], etc. Vous pouvez réexécuter une cellule autant que vous le souhaitez, et l’ordre d’exécution change.

Cellule Markdown

Les cellules Markdown permettent de documenter vos analyses avec du texte formaté, des titres, des listes et des formules mathématiques.

# Titre principal

## Sous-titre

Ceci est un paragraphe contenant du texte en **gras** et en *italique*.

- Élément 1
- Élément 2
- Élément 3

### Formules LaTeX

Voici une formule inline : $y = mx + b$

Et une formule centrée :

$$\sum_{i=1}^{n} x_i = \frac{n(n+1)}{2}$$

Astuce : appuyez sur Ctrl+Entrée pour exécuter (afficher) une cellule Markdown, ou Esc puis M pour convertir une cellule de code en Markdown.

4. Raccourcis Clavier Essentiels

Raccourci	Mode	Action
Ctrl+Entrée	Édit/Cmd	Exécuter la cellule
Shift+Entrée	Édit	Exécuter et aller à la cellule suivante
Alt+Entrée	Édit	Exécuter et insérer une nouvelle cellule
Esc	Édit	Passer en mode commande
Entrée	Commande	Passer en mode édition
A	Commande	Insérer une cellule au-dessus
B	Commande	Insérer une cellule au-dessous
D D	Commande	Supprimer la cellule (deux fois D)
M	Commande	Convertir en Markdown
Y	Commande	Convertir en Code
Ctrl+Shift+P	Commande	Palette de commandes
H	Commande	Afficher l’aide des raccourcis

5. Commandes Magiques

Les commandes magiques sont des raccourcis spéciaux préfixés par % (ligne) ou %% (cellule). Elles facilent le débogage et l’optimisation.

%timeit : Mesurer le temps d’exécution

# Mesurer le temps d'une ligne

%timeit sum(range(100))
# Résultat : 1.25 µs ± 41.2 ns per loop (mean ± std. dev. of 7 runs)

%%time : Mesurer toute une cellule

%%time

# Calcul complet de la cellule
resultat = sum(range(1_000_000))
print(resultat)
# CPU times: user 23.4 ms, sys: 1.23 ms, total: 24.6 ms
# Wall time: 25.1 ms

%matplotlib inline

Pour afficher les graphiques Matplotlib directement dans le notebook (obligatoire avant toute utilisation de Matplotlib).

%matplotlib inline

import matplotlib.pyplot as plt

x = [1, 2, 3, 4]
y = [1, 4, 9, 16]

plt.plot(x, y)
plt.xlabel("X")
plt.ylabel("Y")
plt.title("Courbe simple")
plt.show()
# Le graphique s'affiche directement sous la cellule

%run : Exécuter un fichier Python externe

# Supposons que vous ayez un fichier helper.py
# contenant des fonctions réutilisables

%run helper.py

# Les fonctions et variables du fichier sont maintenant disponibles
print(ma_fonction(5))

%pip : Installer des paquets directement dans le notebook

# Installer une bibliothèque sans quitter le notebook
%pip install requests

import requests
# Utiliser la bibliothèque immédiatement

%pwd et %cd : Navigation dans le système de fichiers

%pwd
# Affiche le répertoire courant
# /Users/utilisateur/projects/analysis

%cd ../data
# Change le répertoire courant

%ls
# Liste les fichiers du répertoire courant

6. Affichage Riche et Output

Jupyter peut afficher bien plus que du texte : des images, des DataFrames formatés, du HTML, du LaTeX, etc.

from IPython.display import display, HTML, Image, DataFrame
import pandas as pd

# Afficher du HTML
display(HTML("<h3 style='color:red;'>Attention!</h3>"))
# Résultat : Attention! (en rouge et gros)

# Afficher une image depuis une URL
display(Image(url="https://example.com/image.png"))

# DataFrame Pandas avec formatage automatique
df = pd.DataFrame({
    'Nom': ['Alice', 'Bob', 'Charlie'],
    'Age': [25, 30, 35],
    'Ville': ['Paris', 'Lyon', 'Marseille']
})

display(df)
# Affiche un tableau formaté et interactif

7. Extensions et Plugins Utiles

JupyterLab dispose d’un écosystème riche d’extensions pour améliorer l’expérience.

Gérer les extensions

# Lister les extensions installées
# jupyter labextension list

# Installer une extension
# jupyter labextension install @jupyter-widgets/jupyterlab-manager

# Vérifier les extensions depuis la ligne de commande
# pip install jupyterlab_execute_time
# pip install jupyterlab-code-formatter
# pip install jupyterlab-lsp

Extensions populaires

Extension	Utilité
jupyterlab-execute-time	Affiche le temps d’exécution de chaque cellule
jupyterlab-code-formatter	Formatte le code Python (Black, Autopep8, etc.)
jupyterlab-lsp	Support des serveurs Language Server Protocol (autocomplétion avancée)
ipywidgets	Widgets interactifs (sliders, boutons, etc.)
jupyterlab-git	Intégration Git directement dans JupyterLab

8. Export et Conversion avec nbconvert

Un notebook .ipynb n’est qu’un fichier JSON. Vous pouvez exporter votre travail vers d’autres formats.

# Exporter en PDF (nécessite pandoc et LaTeX)
# jupyter nbconvert --to pdf notebook.ipynb

# Exporter en HTML statique
# jupyter nbconvert --to html notebook.ipynb
# Résultat : notebook.html

# Exporter en Python pur (cellules code uniquement)
# jupyter nbconvert --to python notebook.ipynb
# Résultat : notebook.py

# Exporter en Markdown
# jupyter nbconvert --to markdown notebook.ipynb

# Exporter en slides (révélation.js)
# jupyter nbconvert --to slides notebook.ipynb --post serve

9. Versionner des Notebooks avec Git

Les fichiers .ipynb sont complexes à versionner avec Git. Plusieurs stratégies existent :

Problème natif

// notebook.ipynb est un JSON avec des sorties, métadonnées, etc.
{
  "cells": [...],
  "metadata": {...},
  "nbformat": 4,
  "nbformat_minor": 5
}
// Les diffs sont illisibles, les fusions sont impossibles

Solution 1 : Nettoyer les sorties avant de commiter

# nbstripout : enlève les sorties et métadonnées superflues
# pip install nbstripout

# git config filter.strip-notebook.clean "nbstripout"
# Ajouter à .gitattributes :
# *.ipynb filter=strip-notebook

Solution 2 : Garder le code Python à côté

# Exporter régulièrement en Python
# jupyter nbconvert --to python notebook.ipynb

# Versionner notebook.py au lieu de notebook.ipynb
# Les diffs sont clairs et les fusions faciles

Solution 3 : Utiliser Jupyter Book ou Quarto

Pour un projet sérieux, migrez vers Jupyter Book (.md + code) ou Quarto (format universel), qui sont plus adaptés au contrôle de version.

10. Bonnes Pratiques

• Une section = Un notebook : gardez un notebook par thème d’analyse. Les très longs notebooks deviennent difficiles à naviguer.
• Cellules courtes et focalisées : chaque cellule doit faire une seule chose. Cela facilite le débogage et la réutilisabilité.
• Documentez avec Markdown : n’hésitez pas à écrire des cellules Markdown expliquant vos étapes. Les notebooks servent aussi à raconter une histoire.
• Nettoyez avant de partager : supprimez les cellules de tests, les variables temporaires, et les sorties anciennes. Exportez ou relancez complètement avant de livrer.
• Utilisez des variables nommées explicitement : df_sales_2024 plutôt que df1.
• Sauvegardez régulièrement : Jupyter enregistre automatiquement, mais une manuelle (Ctrl+S) ne fait pas de mal.
• Réinitialisez le kernel avant de partager : Menu « Kernel » → « Restart & Run All » pour vérifier que tout s’exécute en ordre.

11. Alternatives et Compléments

Outil	Cas d’usage
VS Code + Jupyter	Si vous préférez VS Code à une interface web
Google Colab	Notebooks gratuits dans le cloud, GPUs/TPUs gratis
Kaggle Notebooks	Compétitions de data science et notebooks collaboratifs
Pluto.jl	Reactive notebooks pour Julia (concept similaire)
Observable	Notebooks JavaScript pour la visualisation web

Conclusion

Jupyter Notebook et JupyterLab sont devenus incontournables dans l’écosystème Python pour la data science, le machine learning et la recherche. Leur combinaison de code exécutable, de documentation et de visualisation interactives en fait l’environnement idéal pour explorer des données, prototyper des modèles et communiquer vos résultats. En maîtrisant les commandes magiques, les raccourcis clavier, et les extensions, vous gagnerez considérablement en productivité. N’oubliez pas que Jupyter n’est pas un outil de production : pour des pipelines d’analyse robustes, préférez des scripts Python organisés, testés et versionnés proprement.