Créez votre premier Notebook Jupyter 🧠

Vous débutez avec Python et souhaitez un environnement pratique pour apprendre à coder ? Avec Jupyter Notebook, vous combinez code, texte et visualisations dans un même espace interactif. En suivant ce guide pas à pas, vous saurez installer Anaconda, ouvrir votre premier notebook, exécuter du code Python, et même créer vos premiers graphiques.

Qu’est-ce qu’un notebook Jupyter ?

Un notebook Jupyter est un document interactif qui combine code Python, texte explicatif et résultats dans une même interface web. Imaginez un cahier numérique où vous pouvez :

• Écrire et exécuter du code Python par petits blocs
• Documenter votre démarche avec du texte formaté
• Visualiser immédiatement les résultats et graphiques
• Partager facilement votre travail

Cette approche révolutionne l’apprentissage et l’expérimentation en programmation, car vous avancez étape par étape, testez immédiatement vos idées, et gardez une trace de votre raisonnement.

Pourquoi débuter avec Jupyter ? Contrairement aux scripts Python classiques, les notebooks permettent d’expérimenter sans contrainte et de comprendre chaque étape de votre code.

Prérequis pour commencer

Avant de créer votre premier notebook, vérifiez que vous disposez de :

• Ordinateur : Windows, Mac ou Linux (tous compatibles)
• Connexion internet : Pour télécharger Anaconda (~500 Mo)
• Espace disque : 3 Go d’espace libre minimum
• Motivation : Aucune expérience en programmation requise !

Temps estimé : 30 minutes pour l’installation et premiers pas.

Installation d’Anaconda : la solution tout-en-un

Anaconda est la distribution Python recommandée pour débuter avec Jupyter. Elle inclut Python, Jupyter Notebook, JupyterLab et toutes les bibliothèques scientifiques essentielles en une seule installation.

Astuce

Si vous utilisez déjà conda via Miniconda, vous pouvez installer Jupyter séparément :

conda install jupyter

Pourquoi choisir Anaconda ?

Anaconda simplifie votre vie de débutant :

• Installation unique : Python + Jupyter + 250 bibliothèques
• Gestion automatique : Pas de conflits entre versions
• Interface graphique : Anaconda Navigator pour les non-initiés
• Communauté : Solution utilisée par millions de data scientists

Télécharger et installer Anaconda

Étape 1 : Téléchargement

Rendez-vous sur anaconda.com/download et téléchargez la version correspondant à votre système :

• Windows : Anaconda3-2025.06-0-Windows-x86_64.exe
• Mac : Anaconda3-2025.06-0-MacOSX-arm64.pkg
• Linux : Anaconda3-2025.06-0-Linux-x86_64.sh

Étape 2 : Installation

Lancez l’installateur et suivez l’assistant :

# Sur Linux, depuis le terminal :
wget https://repo.anaconda.com/archive/Anaconda3-2025.06-0-Linux-x86_64.sh
bash Anaconda3-2025.06-0-Linux-x86_64.sh

# Acceptez la licence et l'installation dans le dossier par défaut
# Répondez 'yes' à l'initialisation de conda
## Pour le shell bash/zsh, Acceptez d'ajouter conda au PATH, et rechargez votre shell :
source ~/.bashrc # ou source ~/.zshrc

Étape 3 : Vérification

Ouvrez un nouveau terminal (important !) et vérifiez l’installation :

# Vérifier la version de conda
conda --version
# Résultat attendu : conda 25.x.x

# Vérifier Python
python --version
# Résultat attendu : Python 3.1x.x

# Vérifier Jupyter
jupyter --version
# Résultat attendu : jupyter core + notebook + lab

✅ Installation réussie ? Vous devriez voir les versions affichées sans erreur.

Lancer Jupyter : première interface

Maintenant qu’Anaconda est installé, découvrons comment lancer Jupyter. Vous avez deux options principales.

Option 1 : Anaconda Navigator (recommandé débutants)

Anaconda Navigator est une interface graphique intuitive :

1. Lancez Anaconda Navigator depuis le menu Démarrer/Applications
2. Cliquez sur “Launch” sous Jupyter Notebook
3. Attendez : Votre navigateur s’ouvre automatiquement
4. Explorez : Vous accédez à l’interface Jupyter

Option 2 : Terminal/Ligne de commande

Pour les plus aventureux, depuis le terminal :

# Créer un dossier pour vos notebooks (optionnel)
mkdir ~/Mes-Notebooks
cd ~/Mes-Notebooks

# Lancer Jupyter Notebook
jupyter notebook

# Résultat attendu :
# [I 10:30:15.123 NotebookApp] Serving notebooks from local directory
# [I 10:30:15.123 NotebookApp] Jupyter Notebook is running at:
# [I 10:30:15.123 NotebookApp] http://localhost:8888/?token=abc123...

🌐 Interface web : Jupyter s’ouvre dans votre navigateur à l’adresse http://localhost:8888

Astuce

À savoir : Vous pouvez aussi lancer JupyterLab, une interface plus puissante :

jupyter lab

Comprendre l’interface d’accueil

L’interface Jupyter ressemble à un explorateur de fichiers :

• 🗂️ Files : Vos dossiers et fichiers
• 🏃 Running : Notebooks actuellement ouverts
• 📊 Clusters : Fonctionnalités avancées (ignorez pour l’instant)
• New : Bouton pour créer un nouveau notebook

Navigation : Cliquez sur les dossiers pour explorer, utilisez le bouton “New” pour créer.

Créer votre premier notebook

C’est le moment tant attendu : créer votre premier notebook Jupyter !

Étape 1 : Nouveau notebook

Dans l’interface Jupyter :

1. Cliquez sur le bouton “New” (en haut à droite)
2. Sélectionnez “Python 3” dans le menu déroulant
3. Attendez : Un nouvel onglet s’ouvre avec votre notebook vierge

🎉 Félicitations ! Vous venez de créer votre premier notebook.

Étape 2 : Nommer votre notebook

Par défaut, votre notebook s’appelle “Untitled”. Changeons cela :

1. Cliquez sur “Untitled” en haut de la page
2. Tapez : “Mon-Premier-Notebook”
3. Validez avec Entrée

💾 Sauvegarde automatique : Jupyter sauvegarde votre travail toutes les 2 minutes.

Étape 3 : Comprendre l’interface du notebook

Votre notebook contient plusieurs éléments clés :

• 📝 Cellule : Zone rectangulaire où vous tapez du code ou du texte
• ▶️ Bouton Run : Execute la cellule active
• ⌨️ Mode édition : Curseur visible, vous pouvez taper
• 🎯 Mode commande : Cellule sélectionnée (bordure bleue), raccourcis actifs

Concept fondamental : Un notebook = séquence de cellules exécutables.

Vos premières cellules de code

Passons à la pratique ! Nous allons créer plusieurs cellules de code pour découvrir les bases.

Cellule 1 : Hello World en Python

Dans la première cellule (déjà présente), tapez :

# Mon premier code Python dans Jupyter !
print("Hello, je suis dans un notebook Jupyter !")
print("C'est fantastique ! 🚀")

Exécution :

• Cliquez sur le bouton “Run”
• Ou utilisez le raccourci Shift + Entrée

Résultat attendu :

Hello, je suis dans un notebook Jupyter !
C'est fantastique ! 🚀

✨ Magie ! Le code s’exécute et le résultat s’affiche immédiatement en dessous.

Cellule 2 : Calculs mathématiques

Jupyter excelle pour les calculs interactifs. Créez une nouvelle cellule :

# Calculs mathématiques simples
a = 10
b = 5

print(f"Addition : {a} + {b} = {a + b}")
print(f"Multiplication : {a} × {b} = {a * b}")
print(f"Division : {a} ÷ {b} = {a / b}")

# Variable gardée en mémoire pour les cellules suivantes
resultat = a * b
print(f"Résultat stocké : {resultat}")

Point important : Les variables restent en mémoire entre les cellules !

Cellule 3 : Utiliser la variable précédente

Dans une nouvelle cellule :

# La variable 'resultat' de la cellule précédente est toujours accessible
print(f"Je récupère le résultat précédent : {resultat}")

# Je peux l'utiliser pour de nouveaux calculs
nouveau_calcul = resultat * 2
print(f"Nouveau calcul : {resultat} × 2 = {nouveau_calcul}")

🔗 Persistance : C’est la force de Jupyter, chaque cellule enrichit votre “session” de travail.

Cellule 4 : Créer des graphiques simples

Découvrons la visualisation avec Matplotlib (inclus dans Anaconda) :

# Créer un graphique simple
import matplotlib.pyplot as plt

# Données pour notre graphique
x = [1, 2, 3, 4, 5]
y = [2, 4, 6, 8, 10]

# Créer le graphique
plt.figure(figsize=(8, 5))
plt.plot(x, y, marker='o', color='blue', linewidth=2)
plt.title("Mon Premier Graphique dans Jupyter")
plt.xlabel("Valeurs X")
plt.ylabel("Valeurs Y")
plt.grid(True, alpha=0.3)

# Afficher le graphique
plt.show()

🎨 Résultat : Un beau graphique s’affiche directement dans le notebook !

Ajouter du texte avec Markdown

Les notebooks ne contiennent pas que du code. Ajoutons des explications avec des cellules Markdown.

Créer une cellule Markdown

1. Nouvelle cellule : Cliquez sur ”+” dans la barre d’outils
2. Changer le type : Menu déroulant “Code” → “Markdown”
3. Taper du texte formaté

Exemple de cellule Markdown

# Mon Analyse de Données

Ceci est une **cellule Markdown** qui me permet d'expliquer mon travail.

## Objectifs
- Apprendre les bases de Jupyter
- Créer des graphiques simples
- Documenter mes découvertes

> **Note importante :** Le Markdown permet de structurer et embellir mes explications.

### Prochaines étapes
1. Analyser plus de données
2. Créer des graphiques avancés
3. Partager mon notebook

Exécution : Shift + Entrée transforme le texte brut en texte formaté élégant.

Astuce

Si vous ne connaissez pas le Markdown, voici quelques bases rapides :

Élément	Syntaxe	Résultat
Titre H1	# Mon titre	Mon titre
Texte en gras	**important**	important
Liste	- élément	• élément
Code	`print("Hello")`	print("Hello")

Plus d’infos : Guide Markdown

Alternance code/texte

Workflow recommandé pour vos notebooks :

1. Cellule Markdown : Expliquer ce que vous allez faire
2. Cellule Code : Implémenter votre solution
3. Cellule Markdown : Commenter les résultats obtenus
4. Répéter ce cycle pour construire une histoire cohérente

Cette approche rend vos notebooks lisibles et pédagogiques.

Sauvegarder et organiser

Votre premier notebook prend forme ! Apprenons les bonnes pratiques de sauvegarde et organisation.

Sauvegarde automatique et manuelle

Jupyter sauvegarde automatiquement, mais vous pouvez forcer :

• Ctrl + S (Windows/Linux) ou Cmd + S (Mac)
• Menu File → Save and Checkpoint
• Icône disquette dans la barre d’outils

💾 Checkpoints : Jupyter crée des “points de sauvegarde” pour revenir en arrière si nécessaire.

Format de fichier .ipynb

Votre notebook est sauvé au format .ipynb (IPython Notebook) :

• Structure JSON : Contient code, texte, résultats et métadonnées
• Portable : Fonctionne sur tous les systèmes avec Jupyter
• Versionnable : Compatible avec Git (avec précautions)

Organisation recommandée

Créez une structure logique pour vos notebooks :

Documents/
└── Mes-Notebooks/
    ├── 01-Apprentissage/
    │   ├── Mon-Premier-Notebook.ipynb
    │   └── Exercices-Python.ipynb
    ├── 02-Projets/
    │   └── Analyse-Donnees.ipynb
    └── 03-Brouillons/
        └── Tests-Divers.ipynb

📁 Conseil : Utilisez des noms descriptifs et datés pour retrouver facilement vos travaux.

Raccourcis clavier essentiels

Maîtriser les raccourcis Jupyter accélère considérablement votre productivité.

Mode Commande vs Mode Édition

Jupyter fonctionne avec deux modes :

• Mode Édition : Curseur visible, vous tapez dans la cellule

  • Entrer : Passer en mode édition
  • Shift + Entrée : Exécuter et passer à cellule suivante
  • Ctrl + Entrée : Exécuter sans changer de cellule

• Mode Commande : Cellule sélectionnée (bordure bleue), raccourcis actifs

  • Échap : Passer en mode commande
  • A : Insérer cellule au-dessus (Above)
  • B : Insérer cellule en-dessous (Below)
  • DD : Supprimer la cellule (Delete Delete)
  • M : Convertir en Markdown
  • Y : Convertir en Code

Raccourcis de navigation

• ↑↓ : Naviguer entre les cellules
• Shift + ↑↓ : Sélectionner plusieurs cellules
• Ctrl + A : Sélectionner toutes les cellules

Raccourcis d’exécution

• Shift + Entrée : Exécuter cellule et passer à la suivante
• Ctrl + Entrée : Exécuter cellule sans bouger
• Alt + Entrée : Exécuter et insérer nouvelle cellule

⚡ Productivité : Ces raccourcis deviendront naturels avec la pratique !

Gestion des erreurs courantes

Même avec votre premier notebook, vous rencontrerez des erreurs. Apprenons à les comprendre et résoudre.

Erreur de syntaxe Python

Problème courant :

# Erreur : parenthèse oubliée
print("Hello World"

Message d’erreur :

  File "<ipython-input-1-abc123>", line 2
    print("Hello World"
                       ^
SyntaxError: unexpected EOF while parsing

Solution : Ajoutez la parenthèse manquante.

Variable non définie

Problème :

# Utiliser une variable non créée
print(ma_variable)

Erreur :

NameError: name 'ma_variable' is not defined

Solution : Définissez la variable dans une cellule précédente et exécutez-la.

Valeurs indéfinies

Vous exécutez une cellule dépendant d’une variable non encore définie. Symptômes :

NameError: name 'ma_variable' is not defined

Solutions :

1. Ordre d’exécution : Assurez-vous d’avoir exécuté les cellules dans le bon ordre.
2. Redémarrer le kernel : Si vous avez perdu le contexte, redémarrez le kernel (voir ci-dessous).
3. Vérifier les dépendances : Assurez-vous que toutes les variables nécessaires sont définies avant utilisation.

Kernel occupé ou planté

Symptômes :

• Cellule avec [*] qui ne finit jamais
• Interface qui ne répond plus

Solutions :

1. Kernel → Interrupt : Stopper l’exécution
2. Kernel → Restart : Redémarrer (perd les variables)
3. Kernel → Restart & Clear Output : Redémarrage complet

🔧 Dépannage : En cas de doute, redémarrez le kernel !

Bonnes pratiques pour débuter

Adoptez dès maintenant les bonnes habitudes qui feront de vous un utilisateur efficace de Jupyter.

1. Structurez vos notebooks

Organisation claire :

# Titre du Notebook
**Description** : Objectif et contexte

## 1. Import des bibliothèques
## 2. Chargement des données
## 3. Exploration
## 4. Analyse
## 5. Conclusions

2. Commentez votre code

Code explicite :

# Charger les données de vente du mois dernier
import pandas as pd
df = pd.read_csv('ventes_octobre.csv')

# Calculer la moyenne des ventes par jour
moyenne_journaliere = df['ventes'].mean()
print(f"Moyenne : {moyenne_journaliere:.2f}€")

3. Utilisez des noms de variables clairs

❌ Évitez :

a = 10
b = 5
c = a * b

✅ Préférez :

prix_unitaire = 10
quantite = 5
total = prix_unitaire * quantite

4. Testez étape par étape

Approche progressive :

• Une fonction = une cellule
• Vérifiez chaque résultat intermédiaire
• Corrigez immédiatement les erreurs

5. Sauvegardez régulièrement

Habitudes :

• Ctrl+S après chaque section importante
• Noms de fichiers descriptifs
• Copies de sauvegarde pour projets importants

Premiers projets pratiques

Maintenant que vous maîtrisez les bases, créons quelques projets simples pour consolider vos acquis.

Projet 1 : Calculatrice personnelle

Créez un nouveau notebook “Calculatrice-Personnelle.ipynb” :

# Calculatrice personnelle avec historique

# Liste pour stocker l'historique
historique = []

def calculer(a, operation, b):
    """Fonction de calcul avec historique"""
    if operation == '+':
        resultat = a + b
    elif operation == '-':
        resultat = a - b
    elif operation == '*':
        resultat = a * b
    elif operation == '/':
        if b != 0:
            resultat = a / b
        else:
            return "Erreur : Division par zéro !"

    # Ajouter à l'historique
    calcul = f"{a} {operation} {b} = {resultat}"
    historique.append(calcul)

    return resultat

# Tests de la calculatrice
print("=== Ma Calculatrice Personnelle ===")
print(f"10 + 5 = {calculer(10, '+', 5)}")
print(f"20 - 8 = {calculer(20, '-', 8)}")
print(f"7 × 6 = {calculer(7, '*', 6)}")
print(f"15 ÷ 3 = {calculer(15, '/', 3)}")

print("\n=== Historique des calculs ===")
for calcul in historique:
    print(calcul)

Projet 2 : Analyse de mes dépenses

# Analyse simple de budget personnel
import matplotlib.pyplot as plt

# Mes dépenses du mois (exemple)
categories = ['Alimentation', 'Transport', 'Loisirs', 'Logement', 'Autres']
montants = [350, 120, 200, 800, 150]

# Calculs de base
total_depenses = sum(montants)
print(f"Total des dépenses : {total_depenses}€")

# Pourcentages par catégorie
pourcentages = [(montant/total_depenses)*100 for montant in montants]

for i, cat in enumerate(categories):
    print(f"{cat} : {montants[i]}€ ({pourcentages[i]:.1f}%)")

# Graphique en secteurs
plt.figure(figsize=(10, 6))
plt.pie(montants, labels=categories, autopct='%1.1f%%', startangle=90)
plt.title('Répartition de mes dépenses mensuelles')
plt.axis('equal')
plt.show()

Projet 3 : Générateur de mots de passe

# Générateur de mots de passe sécurisés
import random
import string

def generer_mot_de_passe(longueur=12, inclure_symboles=True):
    """Génère un mot de passe aléatoire"""

    # Caractères disponibles
    lettres = string.ascii_letters  # a-z, A-Z
    chiffres = string.digits        # 0-9
    symboles = "!@#$%^&*"

    # Construire le jeu de caractères
    caracteres = lettres + chiffres
    if inclure_symboles:
        caracteres += symboles

    # Générer le mot de passe
    mot_de_passe = ''.join(random.choice(caracteres) for _ in range(longueur))
    return mot_de_passe

# Génération de plusieurs mots de passe
print("=== Générateur de Mots de Passe ===")
for i in range(5):
    mdp = generer_mot_de_passe(12, True)
    print(f"Mot de passe {i+1} : {mdp}")

# Versions sans symboles (plus simples)
print("\n=== Versions sans symboles ===")
for i in range(3):
    mdp = generer_mot_de_passe(10, False)
    print(f"Simple {i+1} : {mdp}")

🎯 Objectif : Ces projets vous donnent des bases solides pour créer vos propres notebooks !

Conclusion

Félicitations ! Vous savez maintenant créer et utiliser votre premier notebook Jupyter. Voici quelques sujets à explorer (en cours de rédaction) pour aller plus loin :

• Pandas : Manipulation de données tabulaires
• NumPy : Calculs numériques avancés
• Matplotlib/Seaborn : Visualisations sophistiquées
• Requests : Récupération de données web

Le plus important : n’ayez pas peur d’expérimenter ! Les notebooks encouragent l’exploration et l’apprentissage par l’essai. Chaque erreur est une opportunité d’apprendre.

Bon apprentissage avec Jupyter ! 📚✨

Plus d’infos

Documentations officielles :

• Jupyter Documentation
• Python.org Tutorial
• Pandas Getting Started

Communautés :

• Stack Overflow
• Reddit r/Jupyter
• GitHub Jupyter

×

📖 Voir la documentation →