# Chapitre 00 — Installer Python et son environnement de travail

> **⏱️ Durée estimée :** 2 à 3 heures (installation comprise)
>
> **📋 Prérequis :** aucun ! Savoir allumer un ordinateur, télécharger un fichier et taper au clavier suffit. Pense à jeter un œil au [sommaire](README.md) pour avoir une vue d'ensemble du cours.
>
> **🎯 Objectifs — À la fin de ce chapitre, tu sauras :**
> - installer la dernière version stable de Python 3 sur Windows, macOS ou Linux, et vérifier qu'elle fonctionne ;
> - installer et configurer VS Code avec l'extension Python ;
> - te déplacer dans tes dossiers avec le terminal (`cd`, `ls`, `dir`) ;
> - utiliser l'interpréteur interactif de Python comme une calculatrice améliorée ;
> - écrire, enregistrer et exécuter ton premier script, avec des commentaires ;
> - lire un message d'erreur de Python sans paniquer et trouver la ligne fautive.

---

## Cours

### 1. Python, c'est quoi exactement ?

Un ordinateur est très rapide mais complètement bête : il ne fait que ce qu'on lui dit, à la lettre. Pour lui donner des ordres, on écrit des **programmes** dans un **langage de programmation**. Python est l'un de ces langages, et c'est sans doute le plus apprécié des débutants, parce qu'il se lit presque comme de l'anglais simplifié.

Voici un programme Python complet :

```python
print("Bonjour, le monde !")
```

Sortie :

```text
Bonjour, le monde !
```

Une seule ligne, et c'est tout. Dans d'autres langages, il faudrait plusieurs lignes de « cérémonie » pour obtenir le même résultat.

Python est utilisé partout : automatisation de tâches répétitives, sites web, analyse de données, intelligence artificielle, jeux, robotique… Tu découvriras ces domaines au [chapitre 14](14-specialisations.md).

**Comment ça marche ?** Le texte que tu écris (le **code source**) est lu par un programme appelé **l'interpréteur Python**. L'interpréteur lit ton code ligne par ligne, de haut en bas, et exécute chaque instruction. Pense à un cuisinier (l'interpréteur) qui lit une recette (ton code) : il suit les étapes dans l'ordre, et s'il tombe sur une phrase incompréhensible, il s'arrête et te le dit.

Installer Python, c'est donc installer cet interpréteur sur ton ordinateur.

### 2. Installer Python

> 💡 Installe toujours **la dernière version stable de Python 3**, disponible sur le site officiel [python.org](https://www.python.org/downloads/). Ce cours demande au minimum Python 3.12. N'installe jamais « Python 2 » : il est abandonné depuis 2020.

Choisis la section qui correspond à ton système.

#### 2.1. Sous Windows

Il existe aujourd'hui deux façons officielles d'installer Python sous Windows. Les deux fonctionnent ; choisis-en **une seule**.

**Méthode A — L'installateur classique (le plus courant dans les tutoriels)**

1. Va sur [python.org/downloads](https://www.python.org/downloads/) et clique sur le gros bouton jaune *Download Python 3.x.x*. Si le site te propose plutôt le « Python install manager », regarde la méthode B.
2. Lance le fichier `.exe` téléchargé.
3. ⚠️ **ÉTAPE CRUCIALE** : tout en bas de la première fenêtre, **coche la case « Add python.exe to PATH »**. Si tu l'oublies, la commande `python` ne sera pas reconnue dans le terminal.
4. Clique sur *Install Now* et attends la fin de l'installation.
5. Si un message *Disable path length limit* apparaît à la fin, clique dessus (c'est sans risque et ça évite des soucis plus tard).

> 🤔 **Le PATH, c'est quoi ?** C'est une liste de dossiers dans lesquels Windows cherche les programmes quand tu tapes une commande. Cocher la case ajoute le dossier de Python à cette liste. Sans ça, Windows te répond qu'il ne connaît pas `python`, un peu comme si tu cherchais un livre dans une bibliothèque qui n'a pas de fiche à son nom.

**Méthode B — Le « Python install manager »**

Les versions récentes de Python proposent sous Windows un **gestionnaire d'installation** (Python install manager). Il est disponible dans le **Microsoft Store** (cherche « Python install manager ») ou sur python.org. Une fois installé, il fournit les commandes `python` et `py` : la première fois que tu tapes `python` dans un terminal, il télécharge et installe automatiquement la dernière version stable. Si on te propose d'ajouter un dossier au PATH pendant la configuration, accepte.

> ⚠️ Ne mélange pas les deux méthodes, et si tu tapes `python` et que **le Microsoft Store s'ouvre** tout seul, c'est que Python n'est pas (bien) installé : Windows te propose de l'installer. Dans ce cas, reprends l'une des deux méthodes ci-dessus.

**La commande `py` sous Windows.** Windows propose aussi un petit programme appelé `py` (le « lanceur Python »). Il fonctionne même quand le PATH est mal configuré. Si `python` ne marche pas, essaie `py` :

```text
C:\Users\camille> py --version
Python 3.x.y
```

#### 2.2. Sous macOS

macOS contient parfois un vieux Python, ou un Python installé par les outils de développement d'Apple. Ne t'en sers pas et installe la version officielle :

1. Va sur [python.org/downloads](https://www.python.org/downloads/) et télécharge l'installateur macOS (fichier `.pkg`).
2. Lance-le et clique sur *Continuer* jusqu'à la fin.
3. À la fin, une fenêtre du Finder s'ouvre : double-clique sur **`Install Certificates.command`**. Cela permettra à Python de télécharger des choses sur Internet de façon sécurisée (utile au [chapitre 12](12-outils-venv-pip-git.md)).

> 💡 Si tu connais déjà **Homebrew**, `brew install python` fonctionne aussi très bien.

Sous macOS, la commande s'appelle **`python3`** (et pas `python`).

#### 2.3. Sous Linux

La plupart des distributions Linux (Ubuntu, Debian, Fedora…) ont **déjà Python 3** installé, car le système lui-même s'en sert. Vérifie la version (voir section suivante). Si elle est trop ancienne ou absente, utilise le gestionnaire de paquets :

```text
# Ubuntu / Debian
sudo apt update
sudo apt install python3 python3-venv python3-pip

# Fedora
sudo dnf install python3
```

> ⚠️ Ne désinstalle **jamais** le Python fourni avec Linux : ton système en a besoin pour fonctionner.

Sous Linux aussi, la commande s'appelle **`python3`**.

#### 2.4. `python`, `python3` ou `py` : qui fait quoi ?

| Système | Commande à utiliser | Remarque |
|---|---|---|
| Windows | `python` (ou `py`) | `python3` peut ouvrir le Microsoft Store : évite-la |
| macOS | `python3` | `python` n'existe souvent pas |
| Linux | `python3` | `python` peut ne pas exister, ou pointer vers autre chose |

Dans la suite du cours, on écrira `python` dans les exemples de terminal. **Si tu es sous macOS ou Linux, remplace mentalement `python` par `python3`.**

### 3. Le terminal : parler à l'ordinateur en texte

Le **terminal** (on dit aussi « console » ou « ligne de commande ») est une fenêtre où tu tapes des commandes au lieu de cliquer. Ça fait un peu « film de hackers », mais tu n'as besoin que de trois ou quatre commandes.

**Ouvrir un terminal :**

- **Windows** : touche Windows, tape « Terminal » (ou « PowerShell »), puis Entrée.
- **macOS** : `Cmd` + `Espace`, tape « Terminal », puis Entrée.
- **Linux** : souvent `Ctrl` + `Alt` + `T`.

Tu vois alors une ligne qui se termine par `>` (Windows) ou `$` / `%` (macOS, Linux) : c'est l'**invite de commande** (le *prompt*). Elle t'indique aussi **le dossier dans lequel tu te trouves**, appelé **dossier courant**.

#### 3.1. Vérifier que Python est installé

Tape la commande suivante, puis Entrée :

```text
python --version
```

(ou `python3 --version` sous macOS/Linux, ou `py --version` sous Windows)

Tu dois voir quelque chose comme `Python 3.x.y`, avec un numéro au moins égal à 3.12. 🎉 Si tu obtiens une erreur, va voir la section [Pièges fréquents](#pièges-fréquents).

#### 3.2. Les commandes indispensables

| Action | Windows (PowerShell) | macOS / Linux |
|---|---|---|
| Afficher le dossier courant | `pwd` (ou `cd` seul dans l'ancien `cmd`) | `pwd` |
| Lister le contenu du dossier | `dir` (ou `ls` dans PowerShell) | `ls` |
| Entrer dans un dossier | `cd nom_du_dossier` | `cd nom_du_dossier` |
| Remonter d'un niveau | `cd ..` | `cd ..` |
| Revenir au dossier personnel | `cd ~` | `cd ~` |
| Créer un dossier | `mkdir nom_du_dossier` | `mkdir nom_du_dossier` |
| Effacer l'écran | `cls` (ou `clear`) | `clear` |

Imagine que tes dossiers sont des pièces d'une maison. `ls`/`dir` revient à regarder autour de toi, `cd cuisine` à entrer dans la cuisine, `cd ..` à revenir dans le couloir.

Exemple de session (macOS/Linux) :

```text
$ pwd
/home/camille
$ mkdir cours-python
$ cd cours-python
$ pwd
/home/camille/cours-python
$ ls
$ cd ..
$ pwd
/home/camille
```

> 💡 **Astuces qui font gagner un temps fou :**
> - La touche **Tab** complète automatiquement les noms de dossiers et de fichiers : tape `cd cou` puis Tab.
> - La **flèche du haut** rappelle les commandes précédentes.
> - Si un nom de dossier contient des espaces, mets-le entre guillemets : `cd "Mes documents"`. Mieux encore : évite les espaces et les accents dans les noms de dossiers de programmation (`cours-python` plutôt que `Cours Python élémentaire`).

**Crée maintenant ton dossier de travail** pour tout le cours, par exemple `cours-python` dans ton dossier personnel, avec `mkdir cours-python`.

### 4. L'interpréteur interactif : Python en direct

Tape simplement `python` (ou `python3`) dans le terminal, sans rien d'autre :

```text
$ python3
Python 3.x.y (...)
Type "help", "copyright", "credits" or "license" for more information.
>>>
```

Les trois chevrons `>>>` signifient : « Python t'écoute ». Tu es dans l'**interpréteur interactif** (on dit aussi **REPL** : *Read, Evaluate, Print, Loop* — lire, évaluer, afficher, recommencer). Chaque ligne que tu tapes est exécutée immédiatement.

Essaie-le comme une calculatrice :

```pycon
>>> 2 + 3
5
>>> 10 - 4 * 2
2
>>> (10 - 4) * 2
12
>>> 7 / 2
3.5
>>> 2 ** 10
1024
```

Remarques :

- `*` est la multiplication, `/` la division, `**` la puissance (`2 ** 10` = 2 à la puissance 10).
- Les priorités sont celles des maths : la multiplication passe avant l'addition, sauf si tu mets des parenthèses.
- Les nombres à virgule s'écrivent avec un **point** : `3.5`, pas `3,5`.

Tu peux aussi manipuler du texte, à condition de le mettre entre guillemets :

```pycon
>>> "Bonjour"
'Bonjour'
>>> "Bon" + "jour"
'Bonjour'
>>> "Ha" * 3
'HaHaHa'
>>> print("Salut !")
Salut !
```

Tous ces détails (types de valeurs, opérateurs) seront approfondis au [chapitre 01](01-variables-types-operateurs.md).

**Pour quitter l'interpréteur**, tape `exit()` puis Entrée (ou `Ctrl` + `D` sous macOS/Linux, `Ctrl` + `Z` puis Entrée sous Windows). Tu reviens alors au terminal normal.

> ⚠️ **Ne confonds pas les deux mondes !**
> - Après `$` ou `>` : tu parles au **terminal** (commandes `cd`, `ls`, `python`…).
> - Après `>>>` : tu parles à **Python** (code Python).
>
> Taper `cd Documents` après `>>>`, ou `print("Bonjour")` dans le terminal, provoque une erreur.

L'interpréteur interactif est parfait pour tester une petite idée, mais tout ce que tu y tapes disparaît quand tu le fermes. Pour écrire de vrais programmes, on utilise des **scripts** enregistrés dans des fichiers, et un éditeur de code.

### 5. Installer VS Code, ton éditeur de code

Tu pourrais écrire du Python dans le Bloc-notes, mais ce serait comme écrire un roman sans correcteur d'orthographe. Un **éditeur de code** colore ton code, détecte des erreurs à la volée, complète automatiquement ce que tu tapes, et permet d'exécuter ton programme en un clic.

Nous utiliserons **Visual Studio Code** (VS Code), gratuit et disponible sur les trois systèmes.

1. Télécharge-le sur [code.visualstudio.com](https://code.visualstudio.com/) et installe-le.
   - **Windows** : pendant l'installation, coche « Ajouter à PATH » et « Ajouter l'action *Ouvrir avec Code* », c'est pratique.
   - **macOS** : glisse l'application dans le dossier *Applications*.
   - **Linux** : utilise le paquet `.deb` / `.rpm` proposé, ou la logithèque de ta distribution.
2. Lance VS Code.
3. Clique sur l'icône **Extensions** dans la barre de gauche (quatre petits carrés), ou fais `Ctrl` + `Shift` + `X` (`Cmd` + `Shift` + `X` sur macOS).
4. Cherche **« Python »** et installe l'extension publiée par **Microsoft** (c'est la première, avec des millions de téléchargements). Elle installe automatiquement ses compagnons (Pylance, le débogueur…).
5. (Facultatif) Si tu préfères l'interface en français, installe aussi l'extension **« French Language Pack for Visual Studio Code »** puis redémarre VS Code.

**Ouvrir ton dossier de travail.** Dans VS Code : *Fichier* → *Ouvrir le dossier…* (*File* → *Open Folder…*), puis choisis ton dossier `cours-python`. VS Code peut te demander si tu fais confiance aux auteurs des fichiers : réponds oui, c'est ton dossier.

**Choisir l'interpréteur.** Ouvre la palette de commandes avec `Ctrl` + `Shift` + `P` (`Cmd` + `Shift` + `P` sur macOS), tape « Python: Select Interpreter » et choisis la version de Python que tu viens d'installer. En général VS Code la trouve tout seul.

**Le terminal intégré.** VS Code contient son propre terminal : menu *Terminal* → *Nouveau terminal* (ou ``Ctrl`` + ``ù`` sur un clavier français, ``Ctrl`` + `` ` `` sur un clavier anglais). Il s'ouvre directement dans ton dossier de travail. C'est celui-là que tu utiliseras le plus souvent.

### 6. Ton premier script

Un **script** est simplement un fichier texte qui contient du code Python et dont le nom se termine par **`.py`**.

1. Dans VS Code, crée un nouveau fichier (*Fichier* → *Nouveau fichier*, ou l'icône 📄+ à côté du nom du dossier) et nomme-le **`bonjour.py`**.
2. Tape ce code :

```python
print("Bonjour !")
print("Je m'appelle Python.")
print("Je sais calculer : 6 x 7 =", 6 * 7)
```

3. **Enregistre** (`Ctrl` + `S` / `Cmd` + `S`). Un rond blanc à côté du nom de l'onglet signifie « fichier non enregistré » : Python exécute ce qui est **sur le disque**, pas ce qui est à l'écran !
4. Exécute-le, au choix :
   - clique sur le bouton ▶ (*Run Python File*) en haut à droite de l'éditeur ;
   - ou, dans le terminal intégré, tape `python bonjour.py` (ou `python3 bonjour.py`).

Sortie :

```text
Bonjour !
Je m'appelle Python.
Je sais calculer : 6 x 7 = 42
```

Félicitations, tu es officiellement programmeur ou programmeuse ! 🎉

**Ce qu'il faut remarquer :**

- `print(...)` affiche ce qu'on lui donne entre parenthèses. C'est une **fonction** : un outil prêt à l'emploi fourni par Python. (Tu apprendras à créer tes propres fonctions au [chapitre 05](05-fonctions.md).)
- Le texte est entre guillemets : `"Bonjour !"`. On appelle ça une **chaîne de caractères**. Sans guillemets, Python croirait que c'est du code.
- On peut donner plusieurs choses à `print`, séparées par des virgules : Python les affiche séparées par une espace.
- `6 * 7` n'est pas entre guillemets : Python le calcule et affiche `42`.
- Les lignes sont exécutées **dans l'ordre**, de haut en bas.

Encore un exemple, pour voir que `print()` sans rien affiche une ligne vide :

```python
print("Ligne 1")
print()
print("Ligne 3, après une ligne vide")
print("Le résultat de 100 / 8 est", 100 / 8)
```

Sortie :

```text
Ligne 1

Ligne 3, après une ligne vide
Le résultat de 100 / 8 est 12.5
```

> 💡 **Guillemets simples ou doubles ?** Les deux marchent : `'Bonjour'` et `"Bonjour"` sont identiques. Mais si ton texte contient une apostrophe (très fréquent en français !), utilise des guillemets doubles : `"J'adore Python"`.

### 7. Les commentaires

Un **commentaire** est une note pour les humains, que Python ignore complètement. Il commence par le caractère `#` et s'étend jusqu'à la fin de la ligne.

```python
# Ce programme affiche un message de bienvenue.
# Auteur : Camille

print("Bienvenue !")  # un commentaire peut aussi suivre du code

# print("Cette ligne ne sera pas exécutée")
print("Fin du programme")
```

Sortie :

```text
Bienvenue !
Fin du programme
```

**À quoi servent les commentaires ?**

- **Expliquer le pourquoi** d'un morceau de code (« on arrondit ici parce que la banque n'accepte pas les centimes de centimes »).
- **Désactiver temporairement** une ligne sans l'effacer, pour tester quelque chose. Dans VS Code, `Ctrl` + `/` (`Cmd` + `/`) commente ou décommente les lignes sélectionnées.
- **Structurer** un long script en sections.

> 💡 Un bon commentaire explique **pourquoi**, pas **quoi**. `print("Bonjour")  # affiche Bonjour` n'apporte rien : le code le dit déjà.

### 8. Lire ta première erreur

Tu vas faire des erreurs. Beaucoup. Tout le monde en fait, même les experts avec 20 ans d'expérience. La différence, c'est qu'ils savent **lire les messages d'erreur**. Bonne nouvelle : les messages de Python sont parmi les plus clairs qui existent.

Crée un fichier `erreur.py` avec ce code (il y a une faute volontaire à la ligne 2) :

```python
print("Bonjour")
print(Bonjour)
```

En l'exécutant, tu obtiens :

```text
Bonjour
Traceback (most recent call last):
  File "C:\Users\camille\cours-python\erreur.py", line 2, in <module>
    print(Bonjour)
          ^^^^^^^
NameError: name 'Bonjour' is not defined
```

Comment lire ce message (on l'appelle un **traceback**) :

1. **Commence par la dernière ligne** : c'est la plus importante. Elle donne le **type d'erreur** (`NameError`) et une explication (`name 'Bonjour' is not defined` : « le nom 'Bonjour' n'est pas défini »).
2. **Remonte d'une ou deux lignes** pour trouver **où** : le fichier (`erreur.py`) et le numéro de ligne (`line 2`). Python recopie même la ligne fautive et met des `^^^^` sous le morceau problématique.
3. **Remarque** que la ligne 1 a bien été exécutée (`Bonjour` s'est affiché) : Python s'arrête **à la première erreur rencontrée**.

Ici, on a oublié les guillemets : Python croit que `Bonjour` est un nom de quelque chose qu'il devrait connaître. La correction : `print("Bonjour")`.

Il existe aussi des erreurs détectées **avant même l'exécution**, quand Python relit ton code : les **erreurs de syntaxe** (`SyntaxError`). C'est l'équivalent d'une faute de grammaire.

```python
print("Bonjour"
```

```text
  File "C:\Users\camille\cours-python\erreur.py", line 1
    print("Bonjour"
         ^
SyntaxError: '(' was never closed
```

Traduction : « la parenthèse ouverte n'a jamais été fermée ». Dans ce cas, **rien** n'est exécuté, même pas les lignes correctes situées avant.

**Petit dictionnaire des erreurs que tu croiseras au début :**

| Message | Signification | Cause probable |
|---|---|---|
| `SyntaxError: invalid syntax` | Syntaxe invalide | Faute de frappe, symbole manquant ou en trop |
| `SyntaxError: '(' was never closed` | Parenthèse jamais fermée | Il manque `)` |
| `SyntaxError: unterminated string literal` | Chaîne non terminée | Il manque un guillemet fermant |
| `IndentationError: unexpected indent` | Décalage inattendu | Espaces en trop en début de ligne |
| `NameError: name '...' is not defined` | Nom inconnu | Faute de frappe, ou guillemets oubliés |
| `ZeroDivisionError: division by zero` | Division par zéro | On a divisé par 0 |

> 💡 **Le réflexe à prendre :** dernière ligne → numéro de ligne → regarder la ligne en question **et celle d'avant** (une parenthèse oubliée à la ligne 3 est parfois signalée à la ligne 4). Et si tu ne comprends pas, copie la dernière ligne du message dans un moteur de recherche : quelqu'un a déjà eu le même problème. Les erreurs et le débogage seront approfondis au [chapitre 08](08-erreurs-et-debogage.md).

---

## Pièges fréquents

### Piège 1 — « python n'est pas reconnu » (Windows)

```text
PS C:\Users\camille> python --version
python : Le terme «python» n'est pas reconnu comme nom d'applet de commande, fonction, fichier de script ou programme exécutable.
```

**Cause :** la case « Add python.exe to PATH » n'a pas été cochée pendant l'installation.

**Correction :** essaie d'abord `py --version`. Si ça marche, tu peux utiliser `py` à la place de `python`. Sinon, relance l'installateur de Python, choisis *Modify* (ou désinstalle puis réinstalle) et coche bien la case. **Ferme et rouvre ensuite le terminal (et VS Code)** : un terminal déjà ouvert ne voit pas les changements du PATH.

### Piège 2 — « command not found: python » (macOS / Linux)

```text
$ python --version
zsh: command not found: python
```

**Cause :** sur macOS et Linux, la commande s'appelle `python3`.

**Correction :**

```text
$ python3 --version
Python 3.x.y
```

### Piège 3 — Taper du Python dans le terminal, ou une commande de terminal dans Python

Dans le terminal (pas dans Python) :

```text
$ print("Bonjour")
bash: syntax error near unexpected token `"Bonjour"'
```

Dans l'interpréteur Python :

```text
>>> python bonjour.py
  File "<stdin>", line 1
    python bonjour.py
           ^^^^^^^
SyntaxError: invalid syntax
```

**Correction :** regarde l'invite. `>>>` = Python ; `$`, `%` ou `>` = terminal. Pour lancer un script, quitte d'abord l'interpréteur avec `exit()`, puis tape `python bonjour.py` dans le terminal.

### Piège 4 — « No such file or directory »

```text
$ python3 bonjour.py
python3: can't open file '/home/camille/bonjour.py': [Errno 2] No such file or directory
```

**Cause :** tu n'es pas dans le dossier qui contient le fichier (ici, on est dans `/home/camille` alors que le fichier est dans `/home/camille/cours-python`), ou le fichier n'a pas le nom que tu crois (par exemple `bonjour.py.txt` sous Windows).

**Correction :** vérifie où tu es (`pwd`) et ce qu'il y a dans le dossier (`ls` ou `dir`), puis déplace-toi avec `cd cours-python`. Utiliser le terminal intégré de VS Code, qui s'ouvre directement dans le bon dossier, évite souvent ce problème.

### Piège 5 — Oublier d'enregistrer

Tu modifies ton code, tu l'exécutes… et rien ne change. Le rond blanc sur l'onglet de VS Code te dit que le fichier n'est **pas enregistré**.

**Correction :** `Ctrl` + `S` (`Cmd` + `S`) avant chaque exécution. Mieux : active *Fichier* → *Enregistrement automatique* (*Auto Save*).

### Piège 6 — Les guillemets « typographiques »

Si tu copies du code depuis un traitement de texte (Word, un PDF…), les guillemets droits `"` sont parfois remplacés par des guillemets courbes `“ ”` :

```python
print(“Bonjour”)
```

```text
  File "bonjour.py", line 1
    print(“Bonjour”)
          ^
SyntaxError: invalid character '“' (U+201C)
```

**Correction :** retape les guillemets directement dans VS Code : `print("Bonjour")`. Les guillemets français `« »` provoquent la même erreur.

### Piège 7 — Les majuscules comptent

```python
Print("Bonjour")
```

```text
Traceback (most recent call last):
  File "bonjour.py", line 1, in <module>
    Print("Bonjour")
    ^^^^^
NameError: name 'Print' is not defined. Did you mean: 'print'?
```

**Correction :** Python est **sensible à la casse** : `print`, `Print` et `PRINT` sont trois noms différents. Remarque que Python te suggère même la bonne réponse : *Did you mean: 'print'?*

### Piège 8 — Des espaces en trop en début de ligne

```python
print("Bonjour")
  print("Au revoir")
```

```text
  File "bonjour.py", line 2
    print("Au revoir")
IndentationError: unexpected indent
```

**Correction :** en Python, les espaces en **début** de ligne (l'**indentation**) ont un sens précis, que tu découvriras au [chapitre 02](02-conditions.md). Pour l'instant, toutes tes lignes doivent commencer tout à gauche.

---

## Exercices

### Exercice 1 ⭐ — Vérification de l'installation

Ouvre un terminal et :

1. affiche la version de Python installée ;
2. crée un dossier `chapitre00` dans ton dossier de travail et entre dedans ;
3. affiche le chemin du dossier courant pour vérifier que tu es au bon endroit ;
4. lance l'interpréteur interactif, calcule `2 ** 100`, puis quitte-le.

Résultat attendu pour le calcul : `1267650600228229401496703205376`.

### Exercice 2 ⭐ — Calculatrice interactive

Dans l'interpréteur interactif, calcule :

1. le nombre de secondes dans une journée ;
2. le nombre de minutes dans une année de 365 jours ;
3. le prix de 3 croissants à 1,20 € et 2 baguettes à 1,10 € ;
4. la moyenne de 12, 15 et 17.

Attention aux priorités de calcul et à la virgule !

### Exercice 3 ⭐ — Présente-toi

Écris un script `presentation.py` qui affiche exactement (en mettant tes propres informations) :

```text
Bonjour !
Je m'appelle Camille.
J'apprends Python.

À bientôt !
```

Note la ligne vide avant la dernière ligne.

### Exercice 4 ⭐⭐ — Chasse aux erreurs

Le script suivant contient **quatre** erreurs. Exécute-le, lis chaque message d'erreur, corrige la ligne fautive et recommence jusqu'à ce que tout fonctionne.

```text
print("Début du programme")
print("Le double de 21 est", 21 * 2
Print("Python est sensible à la casse")
print("Il manque un guillemet)
print(Fin du programme)
```

Sortie attendue une fois corrigé :

```text
Début du programme
Le double de 21 est 42
Python est sensible à la casse
Il manque un guillemet
Fin du programme
```

### Exercice 5 ⭐⭐ — Le commentateur

Écris un script `recette.py` qui affiche une petite recette de crêpes (titre, ingrédients, étapes) sur une dizaine de lignes. Ajoute :

- un commentaire en tête avec ton nom et la date ;
- un commentaire avant chaque section (titre, ingrédients, étapes) ;
- une ligne d'étape « désactivée » par un commentaire, qui ne doit pas s'afficher.

### Exercice 6 ⭐⭐ — Facture rapide

Écris un script `facture.py` qui affiche une facture et laisse Python faire **tous** les calculs (n'écris pas les résultats toi-même). Un client achète 4 cahiers à 2.5 € et 3 stylos à 1.2 €.

Sortie attendue :

```text
=== FACTURE ===
Cahiers : 4 x 2.5 = 10.0 €
Stylos  : 3 x 1.2 = 3.5999999999999996 €
TOTAL   : 13.6 €
```

Ne t'inquiète pas du `3.5999999999999996` : c'est normal, et tu sauras pourquoi (et comment l'arrondir) au chapitre 01.

### Exercice 7 ⭐⭐⭐ — Art ASCII

Écris un script `chat.py` qui dessine ce chat (attention : la barre oblique inversée `\` est un caractère spécial en Python ; pour l'afficher, il faut l'écrire en double `\\` dans une chaîne).

```text
 /\_/\
( o.o )
 > ^ <
```

Puis ajoute un cadre de 20 étoiles au-dessus et au-dessous, **sans taper les 20 étoiles à la main** (indice : tu as vu ce que fait `"Ha" * 3`).

---

## Mini-projet

### Ma carte de visite dans le terminal

**Objectif :** créer un script `carte_visite.py` qui affiche une jolie carte de visite à ton nom, encadrée, et qui calcule une ou deux informations « amusantes ».

**Cahier des charges :**

1. Le fichier commence par un commentaire d'en-tête : nom du programme, auteur, date, description en une phrase.
2. La carte est encadrée par une ligne de 40 caractères `=` en haut et en bas, générée avec l'opérateur `*` sur une chaîne.
3. Elle contient au moins : ton prénom, ta ville, un loisir, et la phrase « Apprenti·e Pythoniste ».
4. Une section « Le saviez-vous ? » affiche au moins deux calculs faits par Python, par exemple ton âge approximatif en jours (âge × 365) et le nombre d'heures de sommeil par an (8 × 365).
5. Les sections sont séparées par des lignes vides et commentées dans le code.
6. Le script s'exécute sans aucune erreur depuis le terminal **et** depuis le bouton ▶ de VS Code.

**Étapes suggérées :**

1. Crée le fichier dans ton dossier de travail et écris le commentaire d'en-tête.
2. Affiche le cadre du haut, puis teste.
3. Ajoute les lignes d'information une par une, en testant à chaque fois.
4. Ajoute la section des calculs.
5. Termine par le cadre du bas et relis les commentaires.

**Pistes d'amélioration :**

- Ajoute un petit dessin ASCII (un chat, une tasse de café…).
- Centre visuellement les textes en ajoutant des espaces.
- Ajoute le nombre de battements de cœur approximatif depuis ta naissance (environ 70 par minute).
- Quand tu auras lu le chapitre 01, reviens améliorer ce script avec des variables et une saisie au clavier !

---

## Corrigés

<details>
<summary>Corrigé de l'exercice 1</summary>

Sous macOS / Linux (sous Windows, remplace `python3` par `python` ou `py`, et `pwd` fonctionne dans PowerShell) :

```text
$ python3 --version
Python 3.x.y
$ mkdir chapitre00
$ cd chapitre00
$ pwd
/home/camille/cours-python/chapitre00
$ python3
>>> 2 ** 100
1267650600228229401496703205376
>>> exit()
$
```

Remarque : Python calcule sans problème des nombres entiers gigantesques, contrairement à une calculatrice de poche qui afficherait `1.2676506e+30`.

</details>

<details>
<summary>Corrigé de l'exercice 2</summary>

```pycon
>>> 24 * 60 * 60
86400
>>> 365 * 24 * 60
525600
>>> 3 * 1.20 + 2 * 1.10
5.8
>>> (12 + 15 + 17) / 3
14.666666666666666
```

- Pour les prix, on écrit `1.20` avec un point, jamais une virgule. (Parfois, un calcul avec des nombres à virgule donne un résultat comme `3.5999999999999996` au lieu de `3.6` : c'est une petite imprécision normale en informatique, expliquée au chapitre 01.)
- Pour la moyenne, les **parenthèses sont indispensables** : `12 + 15 + 17 / 3` calculerait d'abord `17 / 3` et donnerait `32.666666666666664`.

</details>

<details>
<summary>Corrigé de l'exercice 3</summary>

```python
print("Bonjour !")
print("Je m'appelle Camille.")
print("J'apprends Python.")
print()
print("À bientôt !")
```

Sortie :

```text
Bonjour !
Je m'appelle Camille.
J'apprends Python.

À bientôt !
```

On utilise des guillemets doubles car le texte contient des apostrophes. `print()` sans argument affiche une ligne vide.

</details>

<details>
<summary>Corrigé de l'exercice 4</summary>

Les quatre erreurs, dans l'ordre où Python les signale :

1. Ligne 4 : `SyntaxError: unterminated string literal (detected at line 4)` → il manque le guillemet fermant. Surprise : ce n'est pas la ligne 2 qui est signalée en premier ! Python découpe d'abord tout le fichier en « mots », et une chaîne non terminée bloque ce découpage dès le départ.
2. Ligne 2 : `SyntaxError: '(' was never closed` → il manque la parenthèse fermante.
3. Ligne 5 : `SyntaxError: invalid syntax. Perhaps you forgot a comma?` → Python lit `Fin du programme` comme trois noms de code à la suite, ce qui n'a pas de sens. La vraie cause : les guillemets oubliés.
4. Ligne 3 : `NameError: name 'Print' is not defined. Did you mean: 'print'?` → majuscule en trop. Cette erreur n'apparaît qu'en dernier, **pendant l'exécution** : les deux premières lignes s'affichent avant que Python ne plante.

À retenir : tant qu'il reste une erreur de syntaxe (`SyntaxError`), **rien** ne s'exécute. Les autres erreurs (`NameError`…) n'apparaissent qu'au moment où Python atteint la ligne fautive.

Version corrigée :

```python
print("Début du programme")
print("Le double de 21 est", 21 * 2)
print("Python est sensible à la casse")
print("Il manque un guillemet")
print("Fin du programme")
```

Sortie :

```text
Début du programme
Le double de 21 est 42
Python est sensible à la casse
Il manque un guillemet
Fin du programme
```

</details>

<details>
<summary>Corrigé de l'exercice 5</summary>

```python
# Recette de crêpes
# Auteur : Camille — 14 octobre

# --- Titre ---
print("=== Crêpes pour 4 personnes ===")
print()

# --- Ingrédients ---
print("Ingrédients :")
print("- 250 g de farine")
print("- 4 œufs")
print("- 50 cl de lait")
print("- 1 pincée de sel")
print()

# --- Étapes ---
print("Étapes :")
print("1. Mélanger la farine et les œufs.")
print("2. Ajouter le lait petit à petit.")
# print("2bis. Ajouter un verre de rhum.")  # étape désactivée
print("3. Laisser reposer 1 heure.")
print("4. Cuire dans une poêle chaude.")
```

Sortie :

```text
=== Crêpes pour 4 personnes ===

Ingrédients :
- 250 g de farine
- 4 œufs
- 50 cl de lait
- 1 pincée de sel

Étapes :
1. Mélanger la farine et les œufs.
2. Ajouter le lait petit à petit.
3. Laisser reposer 1 heure.
4. Cuire dans une poêle chaude.
```

La ligne « 2bis » est commentée : Python l'ignore.

</details>

<details>
<summary>Corrigé de l'exercice 6</summary>

```python
# Facture : Python fait tous les calculs
print("=== FACTURE ===")
print("Cahiers : 4 x 2.5 =", 4 * 2.5, "€")
print("Stylos  : 3 x 1.2 =", 3 * 1.2, "€")
print("TOTAL   :", 4 * 2.5 + 3 * 1.2, "€")
```

Sortie :

```text
=== FACTURE ===
Cahiers : 4 x 2.5 = 10.0 €
Stylos  : 3 x 1.2 = 3.5999999999999996 €
TOTAL   : 13.6 €
```

Dans `"4 x 2.5 ="`, le calcul est entre guillemets : c'est du texte, affiché tel quel. Juste après, `4 * 2.5` est hors guillemets : Python le calcule. Remarque qu'on recopie les mêmes nombres plusieurs fois : au chapitre 01, les **variables** permettront d'éviter ça.

</details>

<details>
<summary>Corrigé de l'exercice 7</summary>

```python
# Un chat en art ASCII, encadré d'étoiles
print("*" * 20)
print(" /\\_/\\")
print("( o.o )")
print(" > ^ <")
print("*" * 20)
```

Sortie :

```text
********************
 /\_/\
( o.o )
 > ^ <
********************
```

Chaque `\\` dans le code produit **un seul** `\` à l'écran. `"*" * 20` répète la chaîne `"*"` vingt fois.

</details>

<details>
<summary>Corrigé du mini-projet</summary>

```python
# ------------------------------------------------------------
# carte_visite.py
# Auteur : Camille
# Date : 14 octobre
# Description : affiche ma carte de visite dans le terminal.
# ------------------------------------------------------------

# --- Cadre du haut ---
print("=" * 40)

# --- Identité ---
print("  Camille")
print("  Apprentie Pythoniste")
print()

# --- Informations ---
print("  Ville  : Lyon")
print("  Loisir : l'escalade")
print()

# --- Le saviez-vous ? (calculs faits par Python) ---
print("  Le saviez-vous ?")
print("  J'ai vécu environ", 28 * 365, "jours.")
print("  Je dors environ", 8 * 365, "heures par an.")
print("  Mon cœur a battu environ", 70 * 60 * 24 * 365 * 28, "fois.")

# --- Cadre du bas ---
print("=" * 40)
```

Sortie :

```text
========================================
  Camille
  Apprentie Pythoniste

  Ville  : Lyon
  Loisir : l'escalade

  Le saviez-vous ?
  J'ai vécu environ 10220 jours.
  Je dors environ 2920 heures par an.
  Mon cœur a battu environ 1030176000 fois.
========================================
```

Points à vérifier : le commentaire d'en-tête est présent, chaque section est commentée, les cadres sont générés avec `"=" * 40`, et tous les nombres sont calculés par Python. Le nombre de battements de cœur correspond à l'une des pistes d'amélioration.

</details>

---

## Récapitulatif

**Points clés :**

- Python est un langage **interprété** : l'interpréteur lit ton code de haut en bas et l'exécute ligne par ligne.
- Installe **la dernière version stable de Python 3** depuis python.org. Sous Windows, **coche « Add python.exe to PATH »** (ou utilise le Python install manager).
- La commande est `python` (ou `py`) sous Windows, `python3` sous macOS et Linux.
- Dans le terminal : `cd` pour te déplacer, `cd ..` pour remonter, `ls` / `dir` pour lister, `pwd` pour savoir où tu es, `mkdir` pour créer un dossier.
- `>>>` = interpréteur interactif (tests rapides) ; un fichier `.py` = script (programme durable). On lance un script avec `python nom_du_fichier.py`.
- VS Code + l'extension Python de Microsoft : ton atelier de travail. N'oublie pas d'enregistrer avant d'exécuter.
- `print(...)` affiche des valeurs ; le texte se met entre guillemets.
- `#` commence un commentaire, ignoré par Python.
- Un message d'erreur se lit **de bas en haut** : type d'erreur, explication, puis numéro de ligne.

**Checklist de validation :**

- [ ] `python --version` (ou `python3 --version`) affiche une version 3.12 ou plus récente.
- [ ] Je sais ouvrir un terminal, savoir où je suis et me déplacer dans mes dossiers.
- [ ] Je sais lancer l'interpréteur interactif, y faire un calcul et le quitter.
- [ ] VS Code est installé avec l'extension Python, et mon dossier de travail est ouvert dedans.
- [ ] J'ai écrit, enregistré et exécuté un script `.py` de deux façons (bouton ▶ et terminal).
- [ ] Je sais écrire un commentaire et désactiver une ligne.
- [ ] Face à une erreur, je sais trouver son type et le numéro de la ligne fautive.

---

[← Chapitre précédent (sommaire)](README.md) | [Sommaire](README.md) | [Chapitre suivant →](01-variables-types-operateurs.md)