# L'environnement de travail : le terminal et un premier fichier de code<no value>

## Dans cette leçon

Cette leçon se compose de deux chapitres courts, dans le même ordre que les diapositives. Les outils eux-mêmes (Python, VS Code, Git et Docker) ont déjà été installés dans le thème [Installations](/fr/docs/installations/01-installations/).

1. **Chapitre 1** — le terminal, le shell et les commandes de base (PowerShell / Bash)
2. **Chapitre 2** — le dossier de travail et un premier fichier Python

## Chapitre 1 : Le terminal, le shell et les commandes de base (PowerShell / Bash)

### Qu'allons-nous apprendre ?

- La différence entre un **terminal** et un **shell**.
- Comment une **commande** est construite.
- Les commandes de base que chaque développeur utilise tous les jours : naviguer, lister, créer, copier, déplacer, supprimer.
- PowerShell (Windows) face à Bash/Zsh (Mac/Linux).

### Pourquoi en avons-nous besoin ?

- **Git**, **l'installation de paquets** avec `pip` et le lancement d'un **serveur** (les thèmes backend et bases de données) se font tous depuis le terminal.
- Les vrais serveurs dans le cloud n'ont **pas** d'interface graphique — seulement un terminal.
- Une fois qu'on s'y est habitué, le terminal est **plus rapide** que la souris : une seule commande peut créer 5 dossiers d'un coup.

### Explication à partir des bases

#### Terminal, shell, commande

Trois termes qui prêtent à confusion au début :

| Terme | Ce que c'est | Exemple |
|---|---|---|
| **Terminal** | La **fenêtre** : le programme qui affiche du texte et reçoit la saisie du clavier. | Windows Terminal, le terminal de VS Code, Terminal.app sur Mac |
| **Shell** | L'**interpréteur** : le programme qui tourne dans la fenêtre, lit ce que vous avez tapé et l'exécute. | PowerShell, Bash, Zsh, cmd |
| **Commande** | L'**instruction** elle-même. | `cd week-1` |

{{< box "analogy" "Analogie" >}}
Le **terminal** est le téléphone, le **shell** est la personne au bout du fil qui comprend la langue et fait ce que vous demandez, et la **commande** est la phrase que vous prononcez. On peut tenir le même téléphone (terminal) et parler à différentes personnes qui comprennent différentes langues (PowerShell ou Bash).
{{< /box >}}

- **PowerShell** — le shell moderne de Windows.
- **Bash** — le shell courant sous Linux. **Zsh** — celui par défaut sur Mac, presque identique à Bash pour les commandes de base.
- **cmd** — l'ancien shell de Windows. Nous ne l'utiliserons pas.

#### L'invite de commande (prompt)

L'**invite** (prompt) est le texte que le shell affiche pendant qu'il attend une commande :

```text
PS C:\Users\dana\dev\kodkod6>        ← PowerShell: "PS" + current directory
dana@laptop:~/dev/kodkod6$           ← Bash: user@computer:directory$
```

`~` (tilde) dans Bash = le **dossier personnel** de l'utilisateur.

#### Comment une commande est construite

```text
command   argument(s)    flag(s)/option(s)
  cp      notes.txt  backup.txt
  ls      -la
  mkdir   week-2
```

- **Commande** — quoi faire.
- **Argument** — sur quoi le faire (un fichier, un dossier).
- **Option** (flag) — comment le faire. Dans Bash : `-a` ou `--all`. Dans PowerShell : `-Recurse`, `-Force`.
- Un espace sépare les parties. C'est pourquoi les noms contenant des espaces ont besoin de guillemets : `cd "My Folder"`. Et c'est une raison de plus de ne pas mettre d'espaces dans les noms.

### Syntaxe

#### Le tableau des commandes principales

| Action | PowerShell | Bash / Zsh |
|---|---|---|
| Où suis-je ? | `pwd` | `pwd` |
| Qu'y a-t-il ici ? | `ls` (ou `dir`) | `ls` |
| Y compris les fichiers cachés | `ls -Force` | `ls -a` |
| Entrer dans un dossier | `cd week-1` | `cd week-1` |
| Remonter d'un dossier | `cd ..` | `cd ..` |
| Aller au dossier personnel | `cd ~` | `cd ~` (ou simplement `cd`) |
| Créer un dossier | `mkdir week-2` | `mkdir week-2` |
| Créer un fichier vide | `New-Item notes.txt` | `touch notes.txt` |
| Afficher le contenu d'un fichier | `cat notes.txt` | `cat notes.txt` |
| Copier | `cp a.txt b.txt` | `cp a.txt b.txt` |
| Déplacer / renommer | `mv a.txt b.txt` | `mv a.txt b.txt` |
| Supprimer un fichier | `rm notes.txt` | `rm notes.txt` |
| Supprimer un dossier et son contenu | `rm -r folder` | `rm -r folder` |
| Effacer l'écran | `cls` (ou `clear`) | `clear` |
| Aide sur une commande | `Get-Help cp` | `man cp` (sortir : `q`) |

Dans PowerShell, `ls`, `cat`, `cp`, `mv`, `rm` sont des **alias** de commandes plus longues (`Get-ChildItem`, `Get-Content`, `Copy-Item`...). Ainsi, les mêmes commandes de base fonctionnent dans les deux environnements.

#### Des raccourcis clavier qui font gagner des heures

| Touche | Ce qu'elle fait |
|---|---|
| `Tab` | **Autocomplétion** des noms de fichiers et de dossiers. Tapez `cd we` + Tab et vous obtenez `cd week-1`. |
| `↑` / `↓` | Parcourir les commandes précédentes. |
| `Ctrl + C` | Arrêter la commande en cours. |
| `Ctrl + L` | Effacer l'écran. |

### Premier exemple de code

Naviguer et vérifier. Au passage, nous verrons l'invite changer :

```powershell
pwd
cd ~
pwd
cd dev\kodkod6
ls
```

**Exemple de sortie :**

```text
Path
----
C:\Users\dana\dev\kodkod6\week-1

Path
----
C:\Users\dana

    Directory: C:\Users\dana\dev\kodkod6

Mode                 LastWriteTime         Length Name
----                 -------------         ------ ----
d----          06/10/2026     09:12                sandbox
d----          06/10/2026     08:40                week-1
```

### Analyse du code ligne par ligne

| Commande | Ce qui s'est passé |
|---|---|
| `pwd` | **p**rint **w**orking **d**irectory : affiche où nous sommes. |
| `cd ~` | Saut vers le dossier personnel. |
| `pwd` | Confirme que nous nous sommes bien déplacés. |
| `cd dev\kodkod6` | Un chemin relatif, du dossier personnel vers `dev`, puis vers `kodkod6`. |
| `ls` | Affiche le contenu. Dans PowerShell, `d` dans la colonne Mode indique un répertoire (dossier). |

### Un autre exemple

Nous construisons la structure de dossiers du **thème Python** uniquement avec des commandes : créer des fichiers, copier, renommer et supprimer :

```powershell
cd ~\dev\kodkod6
mkdir week-2
cd week-2
mkdir day-1, day-2, day-3
New-Item day-1\notes.txt
ls
cp day-1\notes.txt day-2\notes.txt
mv day-2\notes.txt day-2\summary.txt
ls day-2
rm day-1\notes.txt
cd ..
```

**Dans Bash/Zsh (Mac / Linux), la même chose :**

```bash
cd ~/dev/kodkod6
mkdir week-2
cd week-2
mkdir day-1 day-2 day-3
touch day-1/notes.txt
ls
cp day-1/notes.txt day-2/notes.txt
mv day-2/notes.txt day-2/summary.txt
ls day-2
rm day-1/notes.txt
cd ..
```

**Analyse :**

- `mkdir day-1, day-2, day-3` — dans PowerShell, on peut créer plusieurs dossiers d'un coup avec des virgules. Dans Bash — avec des espaces.
- `New-Item` / `touch` — créent un fichier vide.
- `cp source destination` — **copier** : la source reste, et une copie est créée.
- `mv source destination` — **déplacer**. Si la destination est dans le même dossier avec un autre nom, c'est en fait un **renommage**.
- `rm` — **supprimer**.
- `cd ..` — retour à `kodkod6`.

### Erreur courante

**L'erreur : croire que `rm` est comme « supprimer » dans l'explorateur de fichiers.**

{{< box "warn" "rm n'envoie pas à la corbeille !" >}}
Un fichier supprimé avec `rm` est **supprimé définitivement**. Il n'y a ni annulation ni corbeille. En particulier : ne lancez **jamais** `rm -r` sur un chemin dont vous n'êtes pas sûr, et ne copiez jamais depuis Internet des commandes contenant `rm -rf /` ou `sudo rm`.
{{< /box >}}

**Une habitude sûre :** avant `rm`, lancez `ls` sur exactement le même chemin et vérifiez ce que vous allez supprimer.

**Deuxième erreur — des espaces dans les noms :**

```powershell
cd My Projects
```

```text
Set-Location: A positional parameter cannot be found that accepts argument 'Projects'.
```

Le shell a vu **deux** arguments : `My` et `Projects`. La correction : `cd "My Projects"`. Et mieux dès le départ : `my-projects`.

**Troisième erreur — exécuter du code Python dans le shell :**

```powershell
PS> print("hi")
```

`print` est une commande **Python**, pas PowerShell. Elle s'exécute dans Python : `python -c "print('hi')"`, ou dans un fichier `.py`. Et inversement : `cd` ne fonctionne pas dans un fichier Python.

### Résumé

- **Terminal** = la fenêtre. **Shell** = l'interpréteur (PowerShell / Bash / Zsh). **Commande** = l'instruction.
- Une commande = nom + arguments + options, séparés par des espaces.
- Naviguer : `pwd`, `ls`, `cd`, `cd ..`, `cd ~`.
- Fichiers : `mkdir`, `New-Item` / `touch`, `cp`, `mv`, `rm`. Et `rm` n'envoie **pas** à la corbeille.
- `Tab` pour l'autocomplétion, `↑` pour la commande précédente, `Ctrl + C` pour arrêter.

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

### Documentation officielle

- [VS Code — Terminal Basics](https://code.visualstudio.com/docs/terminal/basics)
- [PowerShell 101 — Getting started](https://learn.microsoft.com/en-us/powershell/scripting/learn/ps101/01-getting-started)
- [Set-Location (cd)](https://learn.microsoft.com/en-us/powershell/module/microsoft.powershell.management/set-location)
- [GNU Bash Reference Manual](https://www.gnu.org/software/bash/manual/bash.html)

<!-- docs:end -->

## Chapitre 2 : Le dossier de travail et un premier fichier Python

### Qu'allons-nous apprendre ?

- Pourquoi on écrit le code **dans un fichier**, et ce qu'est vraiment un fichier de code.
- Comment construire un **dossier de travail** (workspace folder) ordonné pour tout le cours.
- Ce qui se passe quand on exécute un fichier : l'**interpréteur** le lit de haut en bas.
- Ce qu'est le **répertoire courant**, et pourquoi il provoque l'erreur de débutant la plus fréquente.

### Pourquoi en avons-nous besoin ?

- Une ligne tapée dans le terminal disparaît dès que l'on ferme la fenêtre. Un vrai programme fait des dizaines et des centaines de lignes — il faut les **enregistrer**.
- Dans le cours, nous écrirons des dizaines de fichiers : exercices, projets, serveurs. Sans ordre, au bout d'une semaine vous ne retrouverez plus rien. Les développeurs professionnels gardent chaque projet dans son propre dossier — et c'est aussi ainsi que Git et VS Code s'attendent à travailler : **projet = dossier**.
- Beaucoup d'erreurs de débutants (« le fichier est introuvable ») arrivent parce que le terminal se trouve dans un autre dossier que le fichier.

### Explication à partir des bases

#### Fichier et dossier

- **Fichier** — une unité d'information enregistrée sur le disque : un document, une image ou un fichier de code.
- **Dossier / répertoire** — un « tiroir » qui contient des fichiers et d'autres dossiers.
- **Chemin** — l'adresse complète d'un fichier, depuis la racine jusqu'à lui. Par exemple : `C:\dev\kodkod6\week-1\hello.py`.

#### Ce qu'est vraiment un fichier de code

| | |
|---|---|
| **Texte** | Un fichier de code est un fichier texte ordinaire — on peut l'ouvrir dans n'importe quel éditeur de texte. |
| **`.py`** | L'extension dit au système d'exploitation et à VS Code : « ceci est du code Python ». VS Code le voit et active la coloration syntaxique et un bouton d'exécution. |
| **Interpréteur** | Le programme Python lit le fichier et l'exécute. Sans lui, le fichier n'est que du texte. |
| **De haut en bas** | L'exécution commence à la première ligne et continue ligne après ligne jusqu'à la fin. |

#### Le répertoire courant

Le terminal « se tient » toujours dans un dossier — il apparaît à gauche du curseur (l'**invite**) :

```text
PS C:\dev\kodkod6\week-1>
```

Quand vous tapez `python hello.py`, Python cherche `hello.py` **uniquement dans le répertoire courant**. Si le fichier est dans un autre dossier — il ne le trouvera pas.

{{< box "analogy" "Analogie" >}}
Le terminal est comme une personne qui se tient dans une pièce précise d'une maison. Si vous lui demandez « d'apporter le livre de l'étagère », elle ne cherchera que sur l'étagère de la pièce où elle se trouve. Si le livre est dans une autre pièce, il faut d'abord lui dire de changer de pièce (la commande `cd`), ou lui donner l'adresse complète.
{{< /box >}}

### Structure de dossiers recommandée pour le cours

```text
C:\dev\kodkod6\          (Mac: ~/dev/kodkod6/)
├── week-1\
│   └── hello.py
├── week-2\
├── week-3\
└── week-4\
```

- **Un seul dossier pour tout le cours** (`kodkod6`), avec un dossier pour chaque semaine à l'intérieur.
- Règles de nommage : **lettres anglaises minuscules, sans espaces et sans hébreu**. À la place d'un espace, utilisez un tiret `-` pour les dossiers et un tiret bas `_` pour les fichiers Python (`my_file.py`). Les espaces et les caractères non anglais dans un chemin posent problème à de nombreux outils.
- Dans VS Code, ouvrez **tout** le dossier `kodkod6` (**File → Open Folder**), pas un seul fichier.

### Comment exécuter un fichier

Supposons que le dossier `week-1` contienne un fichier `hello.py` avec une seule ligne qui affiche `Hello, World!`. Le formateur montrera son exécution à l'écran :

```powershell
cd week-1
python hello.py
```

**Sortie :**

```text
Hello, World!
```

| Commande | Ce qu'elle fait |
|---|---|
| `cd week-1` | **c**hange **d**irectory — déplace le terminal vers le dossier où se trouve le fichier. |
| `python hello.py` | Lance l'interpréteur et lui passe le fichier. Il le lit de haut en bas et exécute chaque ligne. |

**Une deuxième façon d'exécuter : le bouton Run.** Dans VS Code, quand un fichier `.py` est ouvert, il y a un triangle ▷ en haut à droite (**Run Python File**). Un clic ouvre un terminal et exécute le fichier avec son chemin complet — pas besoin de `cd`.

### Erreur courante

**L'erreur : exécuter depuis le mauvais dossier.**

```text
PS C:\dev\kodkod6> python hello.py
can't open file '...hello.py':
[Errno 2] No such file or directory
```

- Le terminal se trouve dans `kodkod6`, et le fichier est dans `kodkod6\week-1`.
- Python cherche le fichier **uniquement dans le répertoire courant**.
- **La correction :** d'abord `cd week-1`, et seulement ensuite exécuter. Ou exécuter avec le chemin : `python week-1\hello.py`.

**Deuxième erreur : ne pas enregistrer avant d'exécuter.** Si l'onglet du fichier affiche un rond ⚪ au lieu de ✕, le fichier n'a pas été enregistré, et Python exécutera l'ancienne version. Il est conseillé d'activer **File → Auto Save**.

### Résumé

- Un **fichier de code** est un fichier texte. L'extension **`.py`** indique que c'est du code Python.
- **Projet = dossier.** Des noms anglais, sans espaces : `kodkod6/week-1/hello.py`.
- L'**interpréteur** lit le fichier et l'exécute **de haut en bas**.
- Le **répertoire courant** est l'endroit où se tient le terminal — et c'est là que Python cherche le fichier.
- Exécutez avec `cd` vers le dossier puis `python file.py`, ou avec le bouton ▷ de VS Code.

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

### Documentation officielle

- [Python Tutorial — Using the Python Interpreter](https://docs.python.org/3/tutorial/interpreter.html)
- [Command line and environment](https://docs.python.org/3/using/cmdline.html)
- [VS Code — Run Hello World](https://code.visualstudio.com/docs/python/python-tutorial#_run-python-code)

<!-- 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: Terminal, shell ou commande ?

Pour chaque phrase, indiquez si elle décrit un **terminal**, un **shell** ou une **commande** :

1. La fenêtre où l'on tape et où l'on voit la sortie.
2. `mkdir week-2`
3. PowerShell sous Windows, ou Bash sur Mac et Linux.
4. Le programme qui comprend ce que nous avons tapé et l'exécute.
5. `cd ..`

{{< solution >}}
1. **Terminal** — la fenêtre.
2. **Commande** — une instruction : créer un dossier.
3. **Shell** — ce sont les noms de différents shells.
4. **Shell** — le « cerveau » qui interprète et exécute les commandes.
5. **Commande** — une instruction : remonter d'un dossier.

La règle : le **terminal** est la fenêtre, le **shell** est le programme qui tourne à l'intérieur, et la **commande** est ce que vous tapez.
{{< /solution >}}

### Exercice 2: Quel est le chemin complet ?

La structure de dossiers du cours :

```text
C:\dev\kodkod6\
├── week-1\
│   └── hello.py
└── week-2\
```

1. Quel est le chemin complet du fichier `hello.py` ?
2. Le terminal se trouve dans `C:\dev\kodkod6\week-2`. Quelle commande le ramène à `kodkod6` ?
3. Pourquoi est-il conseillé de garder tous les fichiers du cours dans un seul dossier, et pas sur le bureau ?

{{< solution >}}
1. `C:\dev\kodkod6\week-1\hello.py`
2. `cd ..` — deux points = remonter d'un dossier.
3. Quand tout est sous `kodkod6`, il est facile de retrouver n'importe quel fichier même un mois plus tard, les chemins sont courts et sans espaces, et on peut ouvrir tout le cours dans VS Code d'un coup.
{{< /solution >}}

### Exercice 3: Comment une commande est construite

Dans chacune des commandes suivantes — quel est le nom de la commande, quel est l'argument et quelle est l'option (s'il y en a) ?

```text
git --version
cp notes.txt backup.txt
ls -la
mkdir week-2
```

{{< solution >}}
| Commande | Nom de la commande | Arguments | Option |
|---|---|---|---|
| `git --version` | `git` | — | `--version` |
| `cp notes.txt backup.txt` | `cp` | `notes.txt`, `backup.txt` | — |
| `ls -la` | `ls` | — | `-la` |
| `mkdir week-2` | `mkdir` | `week-2` | — |

La règle : **commande** = quoi faire, **argument** = sur quoi le faire, **option** = comment (un changement de comportement, commence par un tiret).
{{< /solution >}}

### Exercice 4: Naviguer dans les dossiers

Le terminal se trouve dans `C:\dev\kodkod6`. Écrivez la suite de commandes qui fait ce qui suit, dans l'ordre :

1. Crée un dossier nommé `week-1`.
2. Y entre.
3. Affiche où se trouve maintenant le terminal.
4. Remonte d'un dossier.

{{< solution >}}
```powershell
mkdir week-1
cd week-1
pwd
cd ..
```

- `mkdir` — crée un dossier.
- `cd week-1` — entre dans le dossier.
- `pwd` — affiche le chemin courant : `C:\dev\kodkod6\week-1`.
- `cd ..` — deux points = remonter d'un dossier.
{{< /solution >}}

### Exercice 5: « No such file or directory »

Le fichier `hello.py` se trouve dans `C:\dev\kodkod6\week-1`. Un étudiant lance :

```text
PS C:\dev\kodkod6> python hello.py
can't open file '...hello.py': [Errno 2] No such file or directory
```

1. Pourquoi Python ne trouve-t-il pas le fichier, s'il existe ?
2. Donnez deux façons de corriger le problème.

{{< solution >}}
1. Python cherche le fichier **uniquement dans le répertoire courant** — le dossier où se trouve le terminal (`kodkod6`). Le fichier est dans le sous-dossier `week-1`, il n'est donc pas trouvé.
2. Deux façons :
   - Entrer d'abord dans le dossier : `cd week-1`, puis `python hello.py`.
   - L'exécuter avec le chemin : `python week-1\hello.py`.

(Une troisième option : le bouton ▷ Run de VS Code, qui exécute le fichier avec son chemin complet.)
{{< /solution >}}

<!-- exercises:end -->