Raccourcis courants et astuces pratiques pour Jupyter Notebook

Jupyter Notebook est l'environnement de développement interactif le plus populaire en science des données et en apprentissage automatique. Maîtriser ses raccourcis et astuces peut considérablement améliorer l'efficacité de développement quotidienne.

Vous pouvez cliquer sur le menu Help pour afficher les raccourcis :

Tous les raccourcis de cet article sont basés surWindows/Linuxcomme référence. Les utilisateurs de Mac doivent remplacerCtrlwithCmd, et remplacerAltwithOption。

Deux modes de fonctionnement

Jupyter Notebook a deux modes,tous les raccourcis dépendent du mode actuel, ce qui est le point clé que la plupart des débutants négligent :

Mode Couleur de bordure de cellule Comment y accéder Fonction
Mode commande Bleu appuyezEscou cliquez sur la zone vide à gauche de la cellule Gérer les cellules (ajouter, supprimer, déplacer, etc.)
Mode édition Vert appuyezEnterou double-cliquez à l'intérieur de la cellule Écrire et modifier du code ou du texte dans une cellule

Moyen mnémotechnique rapide :Vert = peut saisir et modifier ; Bleu = peut gérer les cellules. Avant d'entrer en mode édition, utilisez d'abordEscpour quitter, puis utilisezEnterpour entrer. Adopter cette habitude permet d'éviter de nombreuses opérations accidentelles.

Raccourcis pour exécuter des Cellules (universels)

Les trois raccourcis suivants peuvent être utilisés dans les deux modes. Ce sont les opérations les plus fréquentes, alors assurez-vous de les mémoriser :

Raccourci Fonction Scénario d'application
Shift + Enter Exécuter la cellule actuelle et passer automatiquement à la cellule suivante Le plus courant, exécuter le code séquentiellement vers le bas
Ctrl + Enter Exécuter la cellule actuelle et rester sur la cellule actuelle À utiliser lors de tests répétés du même code
Alt + Enter Exécuter la cellule actuelle et insérer une nouvelle cellule en dessous À utiliser lors de l'ajout de blocs de code vers le bas pendant l'exécution

Raccourcis du mode commande (bordure bleue)

appuyezEscAprès être entré en mode commande, vous pouvez utiliser les raccourcis suivants :

1. Insertion et suppression de Cellules

Raccourci Fonction
A À la Cellule actuelleAu-dessusInsérer une nouvelle Cellule (Au-dessus)
B À la Cellule actuelleEn dessousInsérer une nouvelle Cellule (En dessous)
D, D(Appuyer deux fois sur D) Supprimer la Cellule actuelle
Z Annuler la suppression (restaurer la Cellule qui vient d'être supprimée)
X Couper la Cellule actuelle
C Copier la Cellule actuelle
V Coller une Cellule en dessous de la Cellule actuelle
Shift + V Coller une Cellule au-dessus de la Cellule actuelle

2. Changement de type de Cellule

Les Cellules dans Jupyter ont trois types, qui peuvent être changés à tout moment :

Raccourci Passer à Objectif
Y Code Écrire et exécuter du code Python
M Markdown (langage de balisage) Écrire de la documentation mise en forme, des titres, des descriptions
R Brut (texte brut) Afficher le texte tel quel, sans l'exécuter ni le rendre
1 ~ 6 Niveaux de titre Markdown H1 ~ H6 Définir rapidement la cellule au niveau de titre correspondant (bascule automatiquement en mode Markdown)

3. Sélectionner et fusionner des cellules

Raccourci Fonction
↑ / K Sélectionner la cellule au-dessus
↓ / J Sélectionner la cellule en dessous
Shift + ↑ / Shift + K Sélectionner plusieurs cellules vers le haut (en continu)
Shift + ↓ / Shift + J Sélectionner plusieurs cellules vers le bas (en continu)
Shift + M Fusionner les cellules sélectionnées en une seule

4. Contrôle de la sortie et de l'affichage

Raccourci Fonction
O Réduire/développer la sortie de la cellule actuelle
Shift + O Activer/désactiver le mode de défilement pour la zone de sortie de la cellule actuelle (à utiliser lorsque le contenu de sortie est très long)
L Afficher/masquer les numéros de ligne pour la cellule actuelle
F Rechercher et remplacer du texte dans la cellule

5. Opérations sur le noyau et l'interface

Raccourci Fonction
I, I(Appuyez deux fois sur I) Interrompre la cellule en cours d'exécution (équivalent à Ctrl+C)
0, 0(Appuyez deux fois sur 0) Redémarrer le noyau (cela effacera toutes les variables exécutées,à utiliser avec prudence）
H Ouvrir le panneau d'aide des raccourcis (affiche tous les raccourcis disponibles)
P Ouvrir la palette de commandes pour rechercher toutes les fonctions Jupyter
Space Faire défiler la page vers le bas
Shift + Space Faire défiler la page vers le haut
S / Ctrl + S Enregistrer le Notebook

Raccourcis du mode édition (bordure verte)

appuyezEnterAprès être entré en mode édition, vous pouvez utiliser les raccourcis suivants pour agir à l'intérieur d'une cellule :

1. Édition de code

Raccourci Fonction
Tab Auto-complétion du code (saisissez une partie du nom d'une fonction/variable puis appuyez sur Tab pour compléter)
Shift + Tab Afficher la description des paramètres de la fonction au niveau du curseur (affiche une infobulle de documentation ; appuyez une fois pour un bref résumé, deux fois pour la documentation complète)
Ctrl + / Commenter/décommenter la ligne actuelle ou plusieurs lignes de code sélectionnées
Ctrl + D Supprimer toute la ligne actuelle
Ctrl + Shift + - Diviser la cellule actuelle en deux cellules au niveau du curseur
Ctrl + Z Annuler (restaurer la modification précédente)
Ctrl + Y Rétablir (annuler l'annulation)
Ctrl + A Sélectionner tout le contenu de la cellule actuelle
Ctrl + Home Aller au tout début du contenu de la cellule
Ctrl + End Aller à la toute fin du contenu de la cellule
Ctrl + ← / Ctrl + → Déplacer le curseur mot par mot (se déplacer rapidement vers le mot précédent/suivant)

2. Revenir du mode édition au mode commande

Raccourci Fonction
Esc Quitter le mode édition, revenir au mode commande (la bordure de la cellule devient bleue)
Ctrl + M Identique à Esc, quitter le mode édition

Commandes magiques

Les commandes magiques sont des directives Jupyter intégrées spéciales qui commencent par%(ligne unique) ou%%(cellule entière), utilisées pour accomplir des tâches courantes telles que la mesure du temps, le débogage, les opérations sur les fichiers, etc.Elles peuvent être utilisées sans installer de bibliothèques.。

1. Chronométrage du code

Exemple

# %timeit : répète plusieurs fois la mesure du temps d'une seule ligne et calcule la moyenne pour un résultat plus précis (adapté pour tester les performances d'expressions courtes)
%timeit [x**2 for x in range(1000)]
# Exemple de sortie : 98.3 µs ± 1.2 µs par boucle (moyenne ± écart-type de 7 exécutions, 10000 boucles chacune)

# %%time : chronomètre une fois le code de toute la cellule (adapté pour tester des processus complets qui prennent beaucoup de temps)
%%time
import time
data = [x**2 for x in range(100000)]
time.sleep(1)
# Exemple de sortie :
# Temps CPU : utilisateur 45.2 ms, système 8.1 ms, total 53.3 ms
# Temps réel : 1.05 s

2. Affichage en ligne des graphiques

Exemple

# %matplotlib inline : intègre directement les graphiques dans le Notebook pour l'affichage (le plus couramment utilisé, graphiques statiques)
# Généralement placé dans la première cellule du Notebook ; ne doit être exécuté qu'une seule fois pour l'ensemble du Notebook
%matplotlib inline

import matplotlib.pyplot as plt
import numpy as np

x = np.linspace(0, 2 * np.pi, 100)
plt.plot(x, np.sin(x))
plt.title('onde sinusoïdale')
plt.show()

# %matplotlib notebook : active des graphiques interactifs qui peuvent être zoomés et déplacés (mais ne peut pas être utilisé en même temps que inline)
# %matplotlib notebook

3. Affichage et gestion des variables

Exemple

# %who : liste tous les noms de variables définis dans l'espace de noms actuel
%who
# Exemple de sortie : data plt x

# %whos : plus détaillé que %who, affiche aussi le type et la valeur des variables
%whos
# Exemple de sortie :
# Variable Type Données/Info
# ----------------------------
# x ndarray 100: [0. 0.06 ... 6.28]
# data list n=100000

# %reset : efface toutes les variables (affiche une invite de confirmation ; convient lorsqu'on redémarre les calculs)
%reset

# %reset -f : efface de force toutes les variables sans invite de confirmation (-f signifie forcer)
%reset -f

4. Opérations sur les fichiers et les chemins

Exemple

# %pwd : affiche le répertoire de travail courant (Print Working Directory)
%pwd
# Exemple de sortie : '/home/user/notebooks'

# %ls : liste tous les fichiers du répertoire courant (les utilisateurs Windows peuvent avoir besoin d'utiliser %ls ou directement utiliser !dir)
%ls
# Exemple de sortie : data.csv model.py notebook.ipynb

# %%writefile : écrit le contenu de toute la cellule dans un fichier spécifié (couramment utilisé pour créer rapidement des fichiers de script)
%%writefile hello.py
def greet(name):
    print(f"Bonjour, {name}!")

greet("World")
# Après exécution, un fichier hello.py est généré dans le répertoire courant, contenant le code de la cellule

# %run : exécute un fichier de script Python externe et importe ses variables dans l'espace de noms courant
%run hello.py
# Sortie : Hello, world!

# %load : charge le contenu d'un fichier de script externe dans la cellule courante (ne l'exécute pas automatiquement ; charge uniquement le code)
%loadpy

5. 执行系统命令

Exemple

在命令前添加!可以直接执行系统终端命令，无需切换到终端窗口
!pip install          # 安装
!pip list                    # 查看列表
!python --version            # 查看 Python 版本

# 你也可以将命令的输出保存为 Python 变量
files = !ls -1               # 执行 ls 命令并将结果赋值给变量 files
print(files)                 # files 是一个列表，其中每个文件名都是一个元素

6. 查看历史记录与调试

Exemple

# %history：查看当前会话中执行过的所有命令的历史记录
%history
# L'ajout de -n affiche les numéros de ligne ; l'ajout de -l 5 affiche uniquement les 5 entrées les plus récentes
%history -n -l 5

# %debug : après qu'un code signale une erreur, exécuter %debug dans la cellule suivante entre en mode de débogage interactif
# En mode de débogage, vous pouvez saisir des noms de variables pour afficher les valeurs, et saisir q pour quitter le débogage
# Par exemple, après avoir exécuté un morceau de code qui a provoqué une erreur :
%debug

7. Rendu de contenu spécial

Exemple

# %%html : rend le contenu de la cellule en sortie HTML (peut intégrer des styles personnalisés et des éléments interactifs)
%%html
<h3 style="color: steelblue;">Ceci est un titre HTML</h3>
<p style="font-size: 16px;">Le contenu HTML peut être rendu directement dans le Notebook.</p>

# %%latex : rend le contenu de la cellule en formule LaTeX (souvent utilisé pour écrire des formules mathématiques)
%%latex
$$E = mc^2$$
$$\int_0^\infty e^{-x^2} dx = \frac{\sqrt{\pi}}{2}$$

Afficher la progression en cours en temps réel

Lors du traitement de grandes quantités de données ou de l'exécution de longues boucles, il est très important de visualiser la progression en temps réel. Voici plusieurs solutions d'affichage de progression couramment utilisées.

1. Barre de progression tqdm (recommandée)

tqdm est la bibliothèque de barres de progression la plus couramment utilisée, prenant en charge les boucles, Pandas et divers scénarios Jupyter. Commande d'installation :

pip install tqdm

Exemple

from tqdm.notebook import tqdm   # Utilisez la version notebook dans Jupyter pour un affichage plus attrayant
import time

# Utilisation de base : encapsulez un objet itérable dans tqdm() pour afficher automatiquement une barre de progression
for i in tqdm(range(100)):
    time.sleep(0.05)    # Simulez une opération chronophage
# Sortie : affiche la barre de progression, le pourcentage d'achèvement, le temps écoulé, le temps restant estimé

# À utiliser avec enumerate
data = list(range(50))
for i, item in enumerate(tqdm(data, desc="Traitement des données")):
    # Le paramètre desc définit le texte du libellé sur le côté gauche de la barre de progression
    time.sleep(0.05)

# Contrôler manuellement la progression (adapté aux scénarios où le total est incertain)
with tqdm(total=100, desc="Progression du téléchargement") as pbar:
    for chunk in range(10):
        time.sleep(0.1)
        pbar.update(10)     # Mettre à jour la progression de 10 unités à chaque fois
        pbar.set_postfix({"lot": chunk})  # Afficher des informations supplémentaires sur le côté droit de la barre de progression

Exemple

# Intégration de tqdm avec Pandas : afficher la progression pour les opérations apply de DataFrame
import pandas as pd
from tqdm.notebook import tqdm

tqdm.pandas()   # Activer l'intégration Pandas ; ne doit être exécutée qu'une seule fois

df = pd.DataFrame({'value': range(1000)})

# Utiliser progress_apply au lieu de apply ordinaire pour afficher automatiquement la progression
result = df['value'].progress_apply(lambda x: x ** 2)

2. display + clear_output : rafraîchissement dynamique de la sortie

Lorsque vous ne voulez pas installer tqdm, vous pouvez utiliser la fonction intégrée d'IPythonclear_outputpour obtenir des effets de rafraîchissement dynamique :

Exemple

from IPython.display import clear_output
import time

total = 50
for i in range(total):
    time.sleep(0.1)
   
    # clear_output(wait=True) : efface la sortie précédente ; wait=True signifie attendre que le nouveau contenu soit disponible avant d'effacer,
    # pour éviter le scintillement. Remarque : cela efface toute la sortie de la cellule actuelle
    clear_output(wait=True)
   
    # Dessiner manuellement une simple barre de progression textuelle
    done = int((i + 1) / total * 30)       # Calculer le nombre de cellules terminées (30 cellules au total)
    bar = '█' * done + '░' * (30 - done)   # █ signifie terminé, ░ signifie non terminé
    pct = (i + 1) / total * 100
    print(f"Progression : [{bar}] {pct:.1f}% ({i+1}/{total})")

print("&#x2705; Tout est terminé !")

3. Progression du dessin de graphique en temps réel

Dans des scénarios tels que l'entraînement de modèles, vous pouvez mettre à jour dynamiquement les graphiques à intervalles réguliers pour observer les tendances des métriques en temps réel :

Exemple

%matplotlib inline
import matplotlib.pyplot as plt
from IPython.display import clear_output, display
import numpy as np
import time

losses = []     # Stocker la valeur de perte de chaque étape pour simuler le processus d'entraînement

for step in range(50):
    # Simuler l'entraînement : générer une valeur de perte qui diminue progressivement
    loss = 1 / (step + 1) + np.random.uniform(0, 0.05)
    losses.append(loss)
   
    # Mettre à jour le graphique toutes les 5 étapes pour éviter de rafraîchir trop fréquemment
    if (step + 1) % 5 == 0:
        clear_output(wait=True)
       
        fig, ax = plt.subplots(figsize=(8, 4))
        ax.plot(losses, color='steelblue', linewidth=2)
        ax.set_title(f'Progression de l’entraînement (Étape {step + 1}/50)')
        ax.set_xlabel('Étape')
        ax.set_ylabel('Perte')
        ax.grid(True, alpha=0.3)
        plt.tight_layout()
        plt.show()          # Appeler show après clear_output, et le graphique se rafraîchira au même endroit
   
    time.sleep(0.1)

print("Entraînement terminé ! Perte finale :", f"{losses[-1]:.4f}")

Conseils pour consulter la documentation et le code

1. Consulter rapidement la documentation d'une fonction

Exemple

# Méthode 1 : ajouter ? après le nom de la fonction pour faire apparaître un panneau de documentation en bas du Notebook
import numpy as np
np.array?
# Cela fait apparaître la description des paramètres et la description fonctionnelle de np.array

# Méthode 2 : ajouter ?? après le nom de la fonction pour faire apparaître la documentation complète, y compris le code source (si la source est disponible)
np.array??

# Méthode 3 : appuyez sur Shift + Tab à l'intérieur des parenthèses de la fonction
# Par exemple, après avoir tapé np.linspace( (à l'intérieur des parenthèses), appuyez sur Shift + Tab pour faire apparaître des indications sur les paramètres
# Appuyez deux fois sur Shift + Tab pour afficher une documentation plus complète

# Méthode 4 : utiliser la fonction help() (la sortie est plus complète, mais affichée dans la zone de sortie plutôt que dans une fenêtre contextuelle)
help(np.array)

2. Utiliser display pour afficher plusieurs résultats de sortie

Par défaut, Jupyter affiche uniquement la valeur de la dernière expression de chaque Cell. Grâce àdisplay()vous pouvez afficher plusieurs résultats dans une seule Cell :

Exemple

import pandas as pd
from IPython.display import display

df1 = pd.DataFrame({'A': [1, 2, 3], 'B': [4, 5, 6]})
df2 = pd.DataFrame({'X': [7, 8, 9], 'Y': [10, 11, 12]})

# Sans display, seul le dernier DataFrame est affiché
# df1 # ne sera pas affiché
# df2 # Seul celui-ci s'affichera

# L'utilisation de display() permet d'afficher plusieurs tableaux à la fois, avec une belle mise en forme
display(df1)
display(df2)

Exemple

# Astuce : modifiez la configuration du Notebook pour que la valeur de chaque expression soit automatiquement affichée (pas besoin d'appeler display manuellement)
from IPython.core.interactiveshell import InteractiveShell
InteractiveShell.ast_node_interactivity = "all"     # La valeur par défaut est "last_expr" ; après avoir changé en "all"
                                                    # Chaque expression dans la cellule affichera automatiquement son résultat
1 + 1      # Affiche 2
2 + 2      # Affiche 4 (par défaut, cette ligne n'affichera rien)
"hello"    # Affiche 'hello'

3. Supprimer les sorties indésirables

Exemple

import matplotlib.pyplot as plt
import numpy as np

# Problème : plt.plot() affichera une description d'objet supplémentaire lors de l'affichage du graphique, comme :
# [<matplotlib.lines.Line2D object at 0x7f3b1234>]

# Solution : ajouter un point-virgule (;) à la fin de l'instruction pour supprimer la sortie de la dernière expression sans affecter l'affichage du graphique
plt.plot(np.sin(np.linspace(0, 2*np.pi, 100)));
# Après avoir ajouté le point-virgule, le graphique s'affiche normalement, mais la description d'objet supplémentaire n'apparaîtra pas

Autres conseils pratiques

1. Afficher les valeurs intermédiaires des variables (sans interrompre l'exécution du code)

Exemple

# Astuce : utilisez la caractéristique des instructions d'affectation Python qui renvoient aussi une valeur,
# Tout en affectant le résultat intermédiaire à une variable, mettez toute la ligne entre parenthèses pour qu'elle s'affiche
import numpy as np

# Manière normale (impossible de voir la valeur de result)
result = np.array([1, 2, 3]) * 2

# Manière avec parenthèses (affiche la valeur de result pendant l'affectation)
(result := np.array([1, 2, 3]) * 2)    # Approche avec l'opérateur walrus de Python 3.8+
# Sortie : array([2, 4, 6])

# Ou plus simple : écrivez simplement le nom de la variable sur une nouvelle ligne après l'affectation
result = np.array([1, 2, 3]) * 2
result      # Jupyter affichera automatiquement la valeur de la dernière expression

2. Référencer le résultat de sortie précédent

Exemple

# Jupyter dispose de variables spéciales intégrées pour référencer rapidement les sorties historiques :
# _ : Résultat de sortie de la cellule précédente
# __ : Résultat de sortie de l'avant-dernière cellule
# _3 : Résultat de sortie de la 3e cellule (Out

# Par exemple :
1 + 1
# Out[1]: 2

_         # Référencez la sortie précédente, la valeur est 2
# Out[2]: 2

_ * 10    # Utilisez la sortie précédente pour continuer le calcul
# Out[3]: 20

_3 + 5    # Référencez le résultat 20 de Out
# Out[4]: 25

3. Afficher du contenu en texte enrichi dans le Notebook

Exemple

from IPython.display import display, HTML, Image, Markdown, Audio, Video

# Afficher du texte formaté Markdown
display(Markdown("## This is a heading\n\n**bold text**, *italic text*, `code`"))

# Afficher HTML
display(HTML("<span style='color:red; font-size:20px'>Big red text</span>"))

# Afficher une image réseau (passer l'URL de l'image)
display(Image(url="https://www.example.com/images/example-logo.png", width=200))

# Afficher une image locale (passer le chemin du fichier local)
# display(Image(filename="./chart.png"))

4. Ajouter des annotations de chronométrage aux cellules (afficher automatiquement le temps écoulé dans la sortie)

Exemple

# L'installation de jupyter-contrib-nbextensions offre plus de fonctionnalités d'extension
# pip install jupyter-contrib-nbextensions

# Solution simple : utiliser un décorateur ou un gestionnaire de contexte pour encapsuler la logique de chronométrage, utilisable dans n'importe quel bloc de code
import time
from contextlib import contextmanager

@contextmanager
def timer(label="Temps écoulé"):
    start = time.time()
    try:
        yield
    finally:
        elapsed = time.time() - start
        print(f"&#x23f1; {label}: {elapsed:.3f} seconds")

# Utilisation : enveloppez n'importe quel bloc de code avec with timer():, et le temps écoulé sera automatiquement affiché après l'exécution
with timer("Traitement des données"):
    data = [x ** 2 for x in range(1000000)]
# Sortie : &#x23f1; Traitement des données : 0.087 seconds

5. Afficher rapidement tous les raccourcis du Notebook actuel

En mode commande (bordure bleue), appuyez surH, ou via le menuAide → Raccourcis clavier, pour ouvrir le panneau d'aide complet sur les raccourcis et consulter toutes les opérations disponibles à tout moment.

Tableau de référence rapide des raccourcis clavier courants

Opération Raccourci Mode
Exécuter la cellule et passer à la suivante Shift + Enter Général
Exécuter la cellule et rester sur place Ctrl + Enter Général
Exécuter la cellule et en créer une nouvelle en dessous Alt + Enter Général
Passer en mode édition Enter Mode commande
Quitter le mode édition Esc Mode édition
Insérer une cellule au-dessus A Mode commande
Insérer une cellule en dessous B Mode commande
Supprimer la cellule D, D Mode commande
Annuler la suppression de la cellule Z Mode commande
Basculer vers une cellule de code Y Mode commande
Basculer vers une cellule Markdown M Mode commande
Fusionner plusieurs cellules sélectionnées Shift + M Mode commande
Interrompre le noyau (arrêter l'exécution) I, I Mode commande
Redémarrer le noyau 0, 0 Mode commande
Afficher l'aide des raccourcis H Mode commande
Auto-complétion de code Tab Mode édition
Afficher les paramètres/la documentation de la fonction Shift + Tab Mode édition
Commenter/décommenter Ctrl + / Mode édition
Diviser la cellule au niveau du curseur Ctrl + Shift + - Mode édition
Enregistrer le Notebook S / Ctrl + S Mode commande / Mode édition
Autres extensions