# Installations : tout ce que vous installez dans le cours<no value>

## Dans cette leçon

Cette leçon se compose de quelques chapitres courts, dans le même ordre que les diapositives :

1. **Chapitre 1** — les outils du cours : ce que fait chaque outil
2. **Chapitre 2** — les étapes d'installation, une par une
3. **Chapitre 3** — vérifier que tout est installé, et ce que nous installerons plus tard dans le cours

## Chapitre 1 : Les outils du cours

### Qu'allons-nous apprendre ?

Dans cette leçon, nous allons découvrir le cours et notre façon d'y travailler, puis mettre en place l'**environnement de développement** — l'ensemble des outils que nous utiliserons pour écrire et exécuter du code tout au long du cours. À la fin de la leçon, tous les outils seront installés sur votre ordinateur, et vous saurez à quoi sert chacun d'eux :

- **VS Code** — l'endroit où l'on écrit le code.
- **Python** — le programme qui exécute le code que nous avons écrit.
- **Git** — l'outil qui conserve l'historique du code.
- **Docker** — exécute des programmes prêts à l'emploi, comme une base de données, dans une « boîte » isolée.
- **Le terminal** — une fenêtre où l'on donne à l'ordinateur des commandes écrites.

### Pourquoi en avons-nous besoin ?

Avant de construire une maison, on apporte les outils sur le chantier et on vérifie qu'ils fonctionnent. En programmation, c'est pareil : s'il manque un outil ou s'il est mal installé, chaque leçon suivante bloquera sur des problèmes d'installation au lieu de porter sur la matière elle-même.

Dans le monde réel, le premier jour d'un développeur dans une nouvelle entreprise ressemble exactement à cela : on reçoit un ordinateur, on installe un éditeur de code, un langage de programmation, Git et Docker, et on vérifie qu'on peut lancer le projet. C'est une compétence dont vous aurez besoin dans chaque emploi.

#### Comment le cours est construit

- Le cours est découpé en **thèmes**, dans l'ordre où ils sont enseignés et exactement dans l'ordre des présentations : installations, l'ordinateur et le système d'exploitation, les réseaux, Python, Git, la POO, le backend et les bases de données.
- Chaque thème est découpé en **leçons**. Chaque leçon est autonome et a toujours la même structure : ce que nous allons apprendre → pourquoi nous en avons besoin → explication à partir des bases → syntaxe → exemple → analyse ligne par ligne → un autre exemple → erreur courante → exercices → résumé. Les thèmes théoriques (l'ordinateur et le système d'exploitation, les réseaux) n'ont pas de code — leurs exercices sont des questions de compréhension.
- À la fin de chaque leçon, il y a **5 exercices** — les mêmes que dans le fichier d'exercices de la présentation. Les solutions sont masquées et ne s'ouvrent qu'au clic, pour que vous essayiez d'abord seul.
- En haut et en bas de chaque leçon se trouve un bouton **Marquer comme terminé**, et chaque page affiche votre progression globale dans le cours.

{{< box "tip" "Comment tirer le meilleur parti du site" >}}
Ne vous contentez pas de lire. Chaque fois qu'un exemple de code apparaît — tapez-le vous-même (sans copier-coller) et exécutez-le. Taper oblige le cerveau à remarquer chaque caractère, et c'est le moyen le plus rapide d'apprendre la syntaxe.
{{< /box >}}

### Explication à partir des bases

#### Qu'est-ce que le code, et qui le comprend ?

Le **code** est un texte écrit selon les règles précises d'un langage de programmation. L'ordinateur lui-même ne « comprend » pas le texte — il ne comprend que des instructions binaires très simples (nous en parlerons dans la leçon sur les composants de l'ordinateur). Il nous faut donc un intermédiaire : un programme qui lit notre code et le traduit en actions que l'ordinateur exécute.

#### Python — l'interpréteur

**Python** est à la fois le nom du langage et le nom du programme qui l'exécute. Ce programme s'appelle un **interpréteur** — il lit notre fichier ligne par ligne et exécute chaque ligne.

{{< box "analogy" "Analogie" >}}
Imaginez que vous écrivez une recette en français, et que le cuisinier ne parle que japonais. L'interpréteur est le traducteur debout à côté du cuisinier, qui lit la recette ligne par ligne et lui dit quoi faire. Sans traducteur — la recette n'est qu'une feuille de papier.
{{< /box >}}

#### VS Code — l'éditeur de code

**VS Code** (Visual Studio Code) est un **éditeur de code** — un programme pour écrire du texte, spécialement adapté au code. On pourrait aussi écrire du code dans le Bloc-notes, mais VS Code vous apporte :

- **La coloration syntaxique** — différents mots du code reçoivent des couleurs différentes, ce qui rend les erreurs faciles à repérer.
- **L'autocomplétion** — propose des noms de fonctions et de variables pendant que vous tapez.
- **Un terminal intégré** — vous pouvez exécuter le code sans quitter l'éditeur.
- **Un débogueur** — un outil pour arrêter le code au milieu et vérifier ce qui s'y passe (nous l'apprendrons dans le thème Python).

Il est important de comprendre : **VS Code n'exécute pas le code tout seul.** Quand vous cliquez sur « Run », il demande simplement à Python d'exécuter le fichier. C'est pourquoi il faut installer les deux.

#### Git — la machine à remonter le temps de votre code

**Git** est un outil de **contrôle de version**. Il enregistre des « instantanés » du code au fil du temps, ce qui permet de revenir à une version antérieure, de voir ce qui a changé et quand, et de travailler en équipe sur le même code. Nous l'apprendrons en détail dans le thème Git. Aujourd'hui, nous l'installons seulement.

#### Docker — des programmes prêts à l'emploi dans une boîte

Plus tard dans le cours, nous travaillerons avec une **base de données** — un programme qui gère et stocke des informations (MySQL). L'installer directement sur l'ordinateur est un long processus, différent sur chaque système d'exploitation. **Docker** résout ce problème : il exécute des programmes prêts à l'emploi dans un **conteneur** — une « boîte » isolée qui contient déjà tout ce dont le programme a besoin. Avec une seule commande, et exactement la même pour tout le monde. Aujourd'hui, nous l'installons seulement, et nous l'utiliserons quand nous arriverons aux bases de données.

#### Le terminal — parler à l'ordinateur par écrit

La plupart du temps, nous utilisons l'ordinateur avec la souris : clic sur des icônes, glisser-déposer de fichiers. Le **terminal** (aussi appelé ligne de commande) est une autre façon de faire : vous tapez une **commande** sous forme de texte, vous appuyez sur Entrée, et l'ordinateur l'exécute et répond par du texte.

Pourquoi travailler ainsi ? Parce que de nombreux outils de développement (Python, Git, les serveurs) fonctionnent principalement par commandes. Sous Windows, le terminal exécute généralement **PowerShell**, et sous Mac/Linux, **Bash** ou **Zsh**. Nous verrons les différences dans le thème sur l'ordinateur et le système d'exploitation.

{{< box "term" "Petit glossaire" >}}
- **Environnement de développement** (Development Environment) — l'ensemble des outils de développement.
- **Interpréteur** (Interpreter) — un programme qui lit le code et l'exécute ligne par ligne.
- **Éditeur de code** (Code Editor) — un éditeur de texte adapté à l'écriture de code.
- **Contrôle de version** (Version Control) — un système qui gère les versions du code au fil du temps.
- **Conteneur** (Container) — une « boîte » isolée où s'exécute un programme prêt à l'emploi, avec tout ce dont il a besoin.
- **Terminal** — une fenêtre où l'on donne des commandes écrites.
- **Commande** — une ligne de texte qui demande à l'ordinateur de faire quelque chose.
{{< /box >}}

<!-- docs:start — generated by scripts/intro6/site_docs.py; edit the links there -->

### Documentation officielle

- [Using Python on Windows](https://docs.python.org/3/using/windows.html)
- [VS Code — Getting Started with Python](https://code.visualstudio.com/docs/python/python-tutorial)
- [Pro Git — About Version Control](https://git-scm.com/book/en/v2/Getting-Started-About-Version-Control)
- [Docker — What is a container?](https://docs.docker.com/get-started/docker-concepts/the-basics/what-is-a-container/)

<!-- docs:end -->

## Chapitre 2 : Les étapes d'installation

### Qu'allons-nous apprendre ?

Nous installons les quatre outils dans l'ordre : **Python**, **VS Code**, **Git** et **Docker**. Téléchargez chaque outil uniquement depuis son site officiel (les liens sont ci-dessous), et sur la plupart des écrans gardez les options par défaut. Après chaque installation, vérifiez que l'outil fonctionne — et seulement ensuite passez au suivant.

**1. Python**

1. Allez sur [python.org/downloads](https://www.python.org/downloads/) et téléchargez la dernière version (3.12 ou plus récente).
2. **Sous Windows — très important :** sur le premier écran de l'installateur, cochez **Add python.exe to PATH**. Sans cela, le terminal ne trouvera pas Python (nous expliquerons ce qu'est PATH dans le thème sur l'ordinateur et le système d'exploitation).
3. Cliquez sur Install Now et attendez la fin.

**2. VS Code**

1. Téléchargez-le depuis [code.visualstudio.com](https://code.visualstudio.com/) et installez-le avec les options par défaut.
2. Sous Windows, cochez aussi **Add to PATH** et **Open with Code** pendant l'installation.
3. Ouvrez VS Code → l'onglet **Extensions** (l'icône des carrés sur le côté) → cherchez **Python** (de Microsoft) → Install.
4. (Vous pouvez le faire maintenant aussi, et c'est obligatoire dans le thème des bases de données) l'extension **Database Client** (de Weijan Chen) — une interface pour visualiser la base de données et exécuter du SQL.

**3. Git**

1. Téléchargez-le depuis [git-scm.com/downloads](https://git-scm.com/downloads) et installez-le avec les options par défaut.
2. Sur Mac, vous pouvez aussi exécuter `xcode-select --install` dans le terminal.

**4. Docker**

1. Téléchargez **Docker Desktop** depuis [docker.com/products/docker-desktop](https://www.docker.com/products/docker-desktop/) et installez-le avec les options par défaut.
2. **Sous Windows :** Docker Desktop a besoin de **WSL 2** (une couche Windows pour exécuter Linux). Si l'installateur demande de l'installer ou de le mettre à jour — acceptez ; il faut parfois redémarrer l'ordinateur.
3. Ouvrez **Docker Desktop** et attendez la fin du démarrage (le coin affiche **Engine running**). Les commandes `docker` ne fonctionnent que tant qu'il est ouvert.

**5. Le terminal**

- **Windows :** le terminal est déjà installé. Cherchez **Terminal** ou **PowerShell** dans le menu Démarrer.
- **Mac :** l'application **Terminal** (recherche avec `Cmd + Space`).
- **Dans VS Code :** le menu **Terminal → New Terminal** (ou `` Ctrl + ` ``). C'est le terminal que nous utiliserons pendant la majeure partie du cours.

{{< box "warn" "Après l'installation — ouvrez un nouveau terminal" >}}
Un terminal déjà ouvert avant l'installation ne « connaît » pas le nouvel outil. Si vous obtenez une erreur indiquant que la commande est introuvable — fermez le terminal (et VS Code) et rouvrez-le.
{{< /box >}}

<!-- docs:start — generated by scripts/intro6/site_docs.py; edit the links there -->

### Documentation officielle

- [Python Downloads](https://www.python.org/downloads/)
- [Visual Studio Code on Windows](https://code.visualstudio.com/docs/setup/windows)
- [Pro Git — Installing Git](https://git-scm.com/book/en/v2/Getting-Started-Installing-Git)
- [Install Docker Desktop on Windows](https://docs.docker.com/desktop/setup/install/windows-install/)
- [Install WSL](https://learn.microsoft.com/en-us/windows/wsl/install)

<!-- docs:end -->

## Chapitre 3 : Vérification, et ce qui s'installe plus tard

### Syntaxe

La « syntaxe » du jour, ce sont les commandes de vérification. Après chaque installation, vérifiez que l'outil est installé avec l'option `--version`, qui affiche simplement la version de l'outil :

```powershell
python --version
git --version
code --version
docker --version
```

La structure de chaque commande :

```text
<program name>  <flag>
     python     --version
```

- **Nom du programme** — quel programme lancer.
- **Option** (flag) — un mot qui commence par `--` (ou `-`) et modifie ce que fait le programme. `--version` dit : « ne fais rien d'autre qu'afficher ta version ».

### Premier exemple de code

Ouvrez un terminal et lancez la première commande de vérification :

```powershell
python --version
```

**Résultat attendu :**

```text
Python 3.12.4
```

Votre numéro peut être différent — l'important est qu'il commence par `Python 3`.

### Analyse du code ligne par ligne

```powershell
python --version
```

| Partie | Ce qu'elle fait |
|---|---|
| `python` | Le nom du programme. Le terminal cherche un programme portant ce nom sur l'ordinateur (dans les dossiers listés dans PATH) et le lance. |
| espace | Sépare le nom du programme de ce qu'on lui passe. |
| `--version` | Une option qui dit à Python : « affiche ta version et quitte ». Python n'exécute aucun code dans ce cas. |

Et ce qui apparaît dans la sortie :

| Sortie | Signification |
|---|---|
| `Python` | Le nom du programme qui a répondu — la preuve que le terminal l'a trouvé. |
| `3.12.4` | Le numéro de version : 3 = version majeure, 12 = version mineure, 4 = version de correction de bugs. |

### Un autre exemple

Vérifiez maintenant tout l'environnement d'un coup — quatre commandes, l'une après l'autre :

```powershell
python --version
git --version
code --version
docker --version
```

**Résultat attendu :**

```text
Python 3.12.4
git version 2.45.1.windows.1
1.93.1
38c31bc77e0dd6ae88a4e9cc93428cc27a56ba40
x64
Docker version 27.3.1, build ce12230
```

- `git version ...` — Git est installé.
- `Docker version ...` — Docker est installé. (Vos numéros peuvent être différents.)
- `code --version` affiche trois lignes : la version de VS Code, l'identifiant de build (une longue chaîne) et le type de processeur (`x64` ou `arm64`). Les trois lignes sont normales.

### Erreur courante

**L'erreur :** installer Python sous Windows sans cocher **Add python.exe to PATH**, puis lancer :

```powershell
python --version
```

et obtenir :

```text
python : The term 'python' is not recognized as the name of a cmdlet, function,
script file, or operable program.
```

ou parfois le Microsoft Store s'ouvre à la place.

**Pourquoi cela arrive-t-il ?** Le terminal ne cherche les programmes que dans les dossiers listés dans une liste appelée **PATH**. Si Python n'y a pas été ajouté — pour le terminal, il n'existe pas, même s'il est installé sur le disque.

**La correction :**

1. Relancez l'installateur de Python → **Modify** → **Next** → cochez **Add Python to environment variables** → Install.
2. Fermez le terminal et rouvrez-le.
3. Une alternative sous Windows : la commande `py --version` (le Python Launcher) fonctionne généralement même sans PATH.

{{< box "warn" "Docker : Docker Desktop n'est pas ouvert" >}}
`docker --version` fonctionne même lorsque Docker Desktop est fermé — mais d'autres commandes (comme `docker ps`) échoueront avec `failed to connect to the docker API`. La correction : ouvrez Docker Desktop et attendez qu'il démarre.
{{< /box >}}

{{< box "warn" "Une autre erreur classique : Mac" >}}
Sur Mac, la commande `python` n'existe parfois pas et seule `python3` fonctionne. C'est normal. Sur Mac, utilisez `python3` partout où le site indique `python`.
{{< /box >}}

### Ce que nous installerons plus tard dans le cours

Les quatre outils sont installés dès le premier jour. Pendant le cours, nous ajouterons quelques autres éléments — chacun exactement dans le thème qui en a besoin. Inutile de les installer maintenant ; ils sont listés ici pour que vous ayez **une liste complète** de tout ce qui s'installe dans le cours :

| Quoi | Quand | Comment |
|---|---|---|
| **Un compte GitHub** | Thème Git | Inscription sur [github.com](https://github.com) (gratuit) |
| **Définir un nom et un e-mail pour Git** | Thème Git | `git config --global user.name` et `user.email` — une fois par ordinateur |
| **Un environnement virtuel** (venv) | Thème backend | `python -m venv .venv` dans le dossier du projet |
| **FastAPI** | Thème backend | `pip install "fastapi[standard]"` dans le venv |
| **La base de données MySQL** | Thème bases de données | Un conteneur dans Docker : `docker run ... mysql:8.4` |
| **L'extension Database Client** | Thème bases de données | Dans VS Code : Extensions → **Database Client** (de Weijan Chen) |
| **Le pilote mysql-connector-python** | Thème bases de données | `pip install mysql-connector-python` dans le venv |

Les commandes elles-mêmes — juste pour que vous les reconnaissiez. Nous les exécuterons en arrivant à chaque thème, avec une explication complète :

```powershell
# Git topic: one-time identity
git config --global user.name "Dana Cohen"
git config --global user.email "dana@example.com"

# Backend topic: inside a venv
pip install "fastapi[standard]"

# Databases topic: driver + MySQL image
pip install mysql-connector-python
docker pull mysql:8.4
```

- **`pip`** — le gestionnaire de paquets de Python. Il télécharge des bibliothèques depuis Internet et les installe, comme une boutique d'applications pour le code.
- **`docker pull`** — télécharge à l'avance l'**image** MySQL (le modèle à partir duquel Docker crée un conteneur). Dans le thème des bases de données, `docker run` la téléchargera tout seul si elle manque — mais si vous avez le temps et une bonne connexion, vous pouvez la télécharger maintenant.

{{< box "tip" "Liste de contrôle de fin de leçon" >}}
- `python --version` affiche `Python 3.x`
- `git --version` affiche `git version ...`
- `code --version` affiche la version de VS Code
- `docker --version` affiche `Docker version ...`, et Docker Desktop s'ouvre et affiche **Engine running**
- L'extension **Python** de Microsoft est installée dans VS Code
{{< /box >}}

### Résumé

- **L'environnement de développement** = cinq outils : VS Code (écrire), Python (exécuter), Git (conserver l'historique), Docker (exécuter des programmes prêts à l'emploi, comme une base de données), le terminal (donner des commandes).
- **Python est un interpréteur** — il lit notre code et l'exécute ligne par ligne. VS Code lui demande seulement de l'exécuter.
- **Sous Windows, cochez Add python.exe to PATH** en installant Python, et Docker Desktop a besoin de WSL 2.
- Vérifiez l'installation de chaque outil avec `--version`.
- Une erreur « not recognized » signifie généralement que l'outil n'est pas listé dans **PATH**, ou que le terminal a été ouvert avant l'installation.
- **Plus tard dans le cours**, nous ajouterons : un compte GitHub et `git config` (Git), venv et FastAPI (backend), MySQL dans Docker, Database Client et le pilote (bases de données).

<!-- docs:start — generated by scripts/intro6/site_docs.py; edit the links there -->

### Documentation officielle

- [Python — Installing Python Modules](https://docs.python.org/3/installing/index.html)
- [Pro Git — First-Time Git Setup](https://git-scm.com/book/en/v2/Getting-Started-First-Time-Git-Setup)
- [Docker Hub — MySQL official image](https://hub.docker.com/_/mysql)
- [FastAPI — Virtual Environments](https://fastapi.tiangolo.com/virtual-environments/)

<!-- docs:end -->

<!-- exercises:start — generated by scripts/intro6/sync_site_exercises.py; edit scripts/intro6/exercises/ -->
## Exercices

Questions de compréhension sur le contenu de la leçon — sans code.

### Exercice 1: Cinq outils — cinq rôles

Associez chaque outil à son rôle :

| Outil | Rôle |
|---|---|
| Python | ? |
| VS Code | ? |
| Git | ? |
| Terminal | ? |
| Docker | ? |

Les rôles : (a) conserve l'historique de chaque modification du code, (b) lit le code et l'exécute, (c) un endroit où l'on donne à l'ordinateur des commandes écrites, (d) l'endroit où l'on écrit le code, (e) exécute des programmes prêts à l'emploi — comme une base de données — dans un conteneur.

{{< solution >}}
| Outil | Rôle |
|---|---|
| Python | (b) — l'interpréteur : lit le code et l'exécute |
| VS Code | (d) — l'éditeur de code : écrire, exécuter et déboguer |
| Git | (a) — la machine à remonter le temps : l'historique de chaque modification du code |
| Terminal | (c) — parler à l'ordinateur avec des commandes écrites |
| Docker | (e) — exécute des programmes prêts à l'emploi, comme MySQL, dans un conteneur isolé |
{{< /solution >}}

### Exercice 2: « The term 'python' is not recognized »

Un étudiant a installé Python, a ouvert le terminal qui était déjà ouvert auparavant, a tapé `python --version` et a obtenu le message :

```text
python : The term 'python' is not recognized as the name of a cmdlet...
```

1. Que dit ce message ?
2. Donnez deux causes possibles du problème, et ce qu'il faut faire dans chaque cas.

{{< solution >}}
1. Le terminal n'a trouvé aucun programme nommé `python` dans les dossiers listés dans **PATH**.
2. Deux causes possibles :
   - **Le terminal a été ouvert avant l'installation** — il ne « connaît » pas la modification de PATH. Fermez-le et ouvrez un nouveau terminal.
   - **La case Add python.exe to PATH n'a pas été cochée pendant l'installation** — relancez l'installateur (Modify) et cochez-la, ou utilisez `py --version`.

(Sur Mac, la commande est généralement `python3`.)
{{< /solution >}}

### Exercice 3: « failed to connect to the docker API »

Un étudiant a installé Docker Desktop. La commande `docker --version` fonctionne et affiche une version, mais la commande `docker ps` échoue :

```text
failed to connect to the docker API
```

1. Comment une commande Docker peut-elle fonctionner et l'autre non ?
2. Que faut-il faire pour corriger cela ?
3. Quel composant supplémentaire doit être installé sous Windows pour que Docker Desktop fonctionne ?

{{< solution >}}
1. `docker --version` affiche seulement la version de l'outil en ligne de commande — il n'a pas besoin du moteur Docker. `docker ps` doit communiquer avec le **moteur**, et le moteur ne tourne que tant que **Docker Desktop est ouvert**.
2. Ouvrez Docker Desktop et attendez la fin du démarrage (**Engine running** apparaît), puis relancez la commande.
3. **WSL 2** — la couche Windows pour exécuter Linux. Si l'installateur demande de l'installer ou de le mettre à jour — acceptez ; il faut parfois redémarrer l'ordinateur.
{{< /solution >}}

### Exercice 4: Qu'installe-t-on, et quand ?

Pour chaque élément de la liste, écrivez **quand** il s'installe dans le cours : (a) le premier jour, (b) dans le thème Git, (c) dans le thème backend, (d) dans le thème bases de données.

| Élément | Quand ? |
|---|---|
| Python | ? |
| Compte GitHub | ? |
| FastAPI | ? |
| Docker Desktop | ? |
| mysql-connector-python | ? |
| VS Code | ? |

{{< solution >}}
| Élément | Quand ? |
|---|---|
| Python | (a) le premier jour |
| Compte GitHub | (b) dans le thème Git — c'est aussi là qu'on définit son nom et son e-mail avec `git config` |
| FastAPI | (c) dans le thème backend — installé avec `pip` dans un environnement virtuel |
| Docker Desktop | (a) le premier jour — mais utilisé seulement dans les bases de données |
| mysql-connector-python | (d) dans le thème bases de données — le pilote qui connecte Python à MySQL |
| VS Code | (a) le premier jour |

La règle : les **quatre outils** (Python, VS Code, Git, Docker) s'installent le premier jour. Les **bibliothèques et les comptes** s'ajoutent quand on arrive au thème qui en a besoin.
{{< /solution >}}

### Exercice 5: Lire la sortie des vérifications

Un étudiant a lancé les quatre commandes de vérification et a obtenu :

```text
Python 3.12.4
git version 2.45.1.windows.1
1.93.1
38c31bc77e0dd6ae88a4e9cc93428cc27a56ba40
x64
docker : The term 'docker' is not recognized as the name of a cmdlet...
```

1. Quels outils sont installés et fonctionnent ?
2. `code --version` a affiché trois lignes. Que représente chaque ligne ?
3. Quel est le problème à la dernière ligne, et que faut-il faire ?

{{< solution >}}
1. **Python**, **Git** et **VS Code** sont installés — chacun a affiché sa version.
2. Les trois lignes de VS Code :
   - `1.93.1` — la version de VS Code.
   - La longue chaîne — l'identifiant de build (commit).
   - `x64` — le type de processeur pour lequel la version a été compilée.
3. Le terminal ne trouve pas `docker` — Docker n'a pas été installé, ou le terminal a été ouvert **avant** l'installation. Installez Docker Desktop (si nécessaire), fermez le terminal, ouvrez-en un nouveau et vérifiez à nouveau avec `docker --version`.
{{< /solution >}}

<!-- exercises:end -->