Leçon 00-2 — Le terminal et VS Code, sérieusement

1. Objectif

À la fin de cette leçon tu sauras : te déplacer n'importe où sur ton disque au terminal (pwd, ls, cd), créer dossiers et fichiers sans toucher la souris, expliquer la différence entre chemin relatif et chemin absolu, et travailler dans VS Code comme un développeur — dossier ouvert, terminal intégré, sauvegarde maîtrisée.

2. Pourquoi c'est important

Le terminal n'est pas un folklore de vieux informaticien : c'est l'interface universelle de la programmation. Lancer un script, installer une bibliothèque, utiliser Git, déployer un projet, lire des logs — tout passe par lui. Aucun tutoriel sérieux, aucune documentation, aucune réponse StackOverflow ne te donnera une suite de clics : on te donnera des commandes. Un développeur qui évite le terminal reste dépendant de boutons que quelqu'un d'autre a bien voulu créer. À l'inverse, dix commandes bien maîtrisées couvrent 95 % des besoins — c'est exactement ce que cette leçon installe.

3. Explication simple

Le terminal est une conversation avec ta machine. Tu tapes une commande, elle répond, et elle attend la suivante. La règle d'or : le terminal se trouve toujours quelque part dans ton disque — dans un dossier, appelé le dossier courant. Toutes les commandes s'interprètent depuis cet endroit.

Trois commandes forment le GPS :

pwd     # print working directory : OÙ suis-je ?
ls      # list : QU'y a-t-il ici ?
cd      # change directory : ALLER ailleurs

Sous Windows, il y a trois terminaux différents — et ils ne parlent pas la même langue :

Terminal	Origine	Syntaxe
`cmd`	l'ancêtre (DOS)	`dir`, antislashes — à oublier
PowerShell	le Windows moderne	`Get-ChildItem`, verbes-noms, alias
Git Bash	livré avec Git, syntaxe Unix	`ls`, `cd`, forward slashes `/`

Dans cette méthode, on utilise Git Bash, pour une raison simple : sa syntaxe (Unix) est celle de 99 % des tutoriels, des serveurs, de la documentation Python et des réponses en ligne. Ce que tu apprends dans Git Bash marche sur Mac, sur Linux, sur un serveur distant. Ce que tu apprendrais dans cmd ne marche que dans cmd. Concrètement : chemins avec des / (~/Claude/learnpython), et ~ désigne ton dossier personnel (C:\Users\jtron).

VS Code, de son côté, n'est pas un « Bloc-notes amélioré » : c'est un atelier. La différence clé avec ce que tu connais : on n'ouvre pas un fichier, on ouvre un dossier (le projet entier). VS Code voit alors toute l'arborescence, et son terminal intégré s'ouvre déjà au bon endroit.

4. Explication approfondie

a) Chemins relatifs vs absolus — LA notion de la leçon.

Un chemin absolu part de la racine du disque et est valable depuis n'importe où :

/c/Users/jtron/Claude/learnpython/lessons     # notation Git Bash
C:\Users\jtron\Claude\learnpython\lessons     # notation Windows (équivalente)

Un chemin relatif part du dossier courant — il ne veut rien dire sans savoir où tu es :

lessons/level-00-environnement    # depuis ~/Claude/learnpython : OK
                                  # depuis ~/Documents : n'existe pas !

Deux raccourcis à connaître par cœur : . = le dossier courant, .. = le dossier parent. cd .. remonte d'un cran, cd ../.. de deux. Note que Git Bash traduit : C:\Users\jtron s'écrit /c/Users/jtron, et ~ en est l'abréviation. Les trois formes suivantes désignent le même endroit :

cd ~/Claude/learnpython
cd /c/Users/jtron/Claude/learnpython
cd "C:\Users\jtron\Claude\learnpython"   # toléré par Git Bash, entre guillemets

b) Les espaces dans les chemins sont des séparateurs. Le terminal découpe ta commande sur les espaces. cd Mon Dossier est lu comme « cd avec DEUX arguments : Mon et Dossier ». D'où la règle : un chemin qui contient un espace se met entre guillemets (cd "Mon Dossier") — ou mieux, on évite les espaces dans les noms de dossiers de projets (c'est pour ça que le repo s'appelle learnpython, pas learn python).

c) La tab-completion n'est pas un confort, c'est une méthode de travail. Tape le début d'un nom, appuie sur Tab : le terminal complète. Deux bénéfices : la vitesse, et surtout zéro faute de frappe — si Tab ne complète pas, c'est que le fichier n'est pas là où tu crois, et tu viens de gagner cinq minutes de débogage. Complète TOUJOURS les chemins par Tab. Les autres réflexes de survie : flèche haut (rappeler les commandes précédentes), Ctrl+C (interrompre une commande qui tourne — par exemple un script Python en boucle infinie), clear (nettoyer l'écran, rien n'est perdu).

d) VS Code : les habitudes qui changent tout.

Ouvrir le dossier : File → Open Folder → learnpython (ou, mieux, au terminal : cd ~/Claude/learnpython && code . — « ouvre VS Code ici »). L'explorateur latéral montre alors tout le repo, et les chemins relatifs deviennent visibles d'un coup d'œil.
Terminal intégré : Ctrl+ù (clavier français ; menu Terminal → New Terminal sinon). C'est un vrai terminal, dans l'éditeur, ouvert à la racine du dossier ouvert. Vérifie que le profil est Git Bash (menu déroulant + du panneau terminal → Select Default Profile → Git Bash).
Extension Python officielle (éditeur : Microsoft) : panneau Extensions (Ctrl+Shift+X) → chercher « Python » → Install. Elle apporte coloration avancée, détection d'erreurs pendant la frappe, et l'auto-complétion.
Ctrl+S, encore et toujours : le point blanc dans l'onglet = non sauvegardé = Python exécutera l'ancienne version. (Le « Auto Save » existe ; je te déconseille de l'activer pendant l'apprentissage : savoir ce qui est sur le disque doit rester un acte conscient.)

Difficulté honnête : la navigation au terminal demande de la répétition, pas de l'intelligence. Les deux premiers jours, tu seras plus lent qu'avec l'explorateur Windows — c'est normal et temporaire. Interdis-toi l'explorateur pour tout ce qui touche au repo pendant une semaine : c'est le prix de l'automatisme.

5. Exemples commentés

Exemple 1 — le GPS : où suis-je, qu'y a-t-il, aller ailleurs

pwd

/c/Users/jtron

ls

Claude/  Desktop/  Documents/  Downloads/  ...

cd Claude/learnpython
pwd

/c/Users/jtron/Claude/learnpython

cd Claude/learnpython est un chemin relatif : il ne marche que parce que pwd montrait /c/Users/jtron juste avant.

Exemple 2 — monter, descendre, revenir

cd lessons/level-00-environnement   # descendre de deux crans
cd ..                               # remonter d'un cran → lessons/
cd ../..                            # remonter de deux → ~/Claude
cd ~/Claude/learnpython             # chemin absolu : marche depuis PARTOUT
cd -                                # bonus : revenir au dossier précédent

Exemple 3 — créer des dossiers et des fichiers sans la souris

cd ~/Claude/learnpython/lessons/level-00-environnement/exercices/mes-reponses
mkdir drafts                    # créer un dossier
touch drafts/notes.py           # créer un fichier vide (Git Bash)
ls drafts

notes.py

cat drafts/notes.py             # afficher le contenu : vide, donc rien

En PowerShell, les équivalents seraient New-Item -ItemType File drafts/notes.py et Get-Content — tu les croiseras dans des tutoriels Windows ; inutile de les retenir, on travaille en Git Bash.

Exemple 4 — la tab-completion en action

cd ~/Claude/learnpython/le<Tab>
# devient : cd ~/Claude/learnpython/lessons/
cd le<Tab>ve<Tab>
# lessons/ puis level-00-environnement/ (si l'ambiguïté est levée)

Si Tab affiche plusieurs candidats (level-00-environnement/ level-01-bases/), tape un caractère de plus et retente. Si Tab ne propose rien : le chemin n'existe pas depuis ici — vérifie pwd.

Exemple 5 — VS Code ouvert au bon endroit, cycle complet

cd ~/Claude/learnpython
code .

Puis dans VS Code : Ctrl+ù pour le terminal intégré, qui s'ouvre directement dans ~/Claude/learnpython. Créer un fichier via l'explorateur latéral (clic droit sur mes-reponses → New File → cycle.py), taper print("full cycle"), Ctrl+S, puis dans le terminal intégré :

python lessons/level-00-environnement/exercices/mes-reponses/cycle.py

full cycle

Éditeur, terminal, exécution : tout au même endroit. C'est ta configuration de travail pour toute la méthode.

6. Erreurs fréquentes

1) cd vers un chemin avec espaces, sans guillemets

cd /c/Users/jtron/Mon Projet

bash: cd: too many arguments

Le terminal a vu deux arguments (.../Mon et Projet). Correction : cd "/c/Users/jtron/Mon Projet". Prévention : pas d'espaces dans les noms de tes dossiers de code.

2) Chemin relatif utilisé depuis le mauvais endroit

cd lessons

bash: cd: lessons: No such file or directory

lessons existe — mais pas dans le dossier courant. Réflexe en trois temps : pwd (où suis-je ?), ls (que vois-je ?), puis reconstruire le chemin depuis là. Un chemin relatif est une direction depuis ici, pas une adresse.

3) Travailler dans le mauvais dossier sans s'en rendre compte

Symptômes : tes fichiers « disparaissent », git status montre des choses inattendues, python ne trouve rien. Cause : un cd oublié trois commandes plus tôt. Le prompt de Git Bash affiche le dossier courant en permanence (~/Claude/learnpython) — apprends à le lire avant chaque commande, c'est gratuit.

4) Éditer sans sauvegarder, puis relancer le script

Déjà vue en 00-1, elle revient ici car c'est dans VS Code qu'elle se joue : tu modifies cycle.py, tu relances au terminal intégré, la sortie ne change pas. Le point blanc dans l'onglet te nargue. Ctrl+S, relance. Tant que ce réflexe n'est pas câblé, vérifie l'onglet À CHAQUE exécution surprenante.

5) Ouvrir un fichier isolé dans VS Code au lieu du dossier

VS Code sans dossier ouvert = pas d'explorateur latéral, terminal intégré ouvert n'importe où, extension Python à moitié fonctionnelle. Symptôme : la barre latérale dit « No Folder Opened ». Correction : File → Open Folder → learnpython. Toujours ouvrir le projet, jamais le fichier seul.

6) Confondre ls et cd, ou donner un fichier à cd

cd hello.py

bash: cd: hello.py: Not a directory

cd va DANS un dossier ; un fichier n'est pas un dossier. Le message le dit littéralement — lis-le. (De même, ls liste, il ne déplace pas : faire trois ls de suite ne te fait pas avancer.)

7. Lire les messages d'erreur

Les erreurs du terminal sont plus laconiques que les tracebacks Python, mais elles suivent toutes le même format — apprends à le découper :

bash: cd: lessons: No such file or directory
  │    │     │             │
  │    │     │             └── le problème
  │    │     └── l'argument fautif
  │    └── la commande concernée
  └── qui parle (le shell bash)

Les trois messages que tu verras cette semaine :

command not found → la commande n'existe pas : faute de frappe (pyhton), ou programme absent du PATH (leçon 00-1).
No such file or directory → la commande existe, mais l'argument (chemin) ne mène nulle part depuis ici. Diagnostic : pwd puis ls.
Not a directory / Is a directory → tu as donné un fichier là où il fallait un dossier, ou l'inverse.

Règle transversale : le terminal te dit toujours lequel des deux est en cause, la commande ou l'argument. Lire le message évite de « retaper la même commande en espérant » — ce que font tous les débutants et qui ne marche jamais.

8. Exercices — faciles

Règles : uniquement au terminal (Git Bash), explorateur Windows interdit. Avant chaque Entrée, prédis ce que la commande va répondre.

a) Ouvre un terminal neuf. Sans aucun cd, réponds par écrit : où es-tu ? Vérifie avec pwd. Puis navigue jusqu'à lessons/level-00-environnement/exercices/mes-reponses en utilisant la tab-completion à chaque segment, et prouve ta position avec pwd et ls.

b) Depuis mes-reponses/, en une commande à chaque fois : remonte à la racine du repo, puis redescends dans lessons/level-01-bases, puis reviens dans mes-reponses du niveau 00 avec un chemin relatif (il commence par ..).

c) Crée au terminal un dossier terminal-drills dans mes-reponses/, puis dedans trois fichiers vides : a.py, b.py, notes.txt. Vérifie avec ls, affiche le contenu (vide) de a.py avec cat, puis nettoie ton écran.

9. Exercices — moyens

a) Le chemin piégé : crée un dossier nommé test drive (avec l'espace, exceptionnellement) dans terminal-drills/. Constate que mkdir test drive ne fait PAS ce que tu veux (que fait-il exactement ? ls te le dira). Répare : supprime les dossiers créés par erreur (rmdir), crée le bon dossier avec des guillemets, entre dedans, ressors, puis supprime-le. Note la leçon dans ton journal.

b) Écris sur papier le chemin absolu (notation Git Bash) et le chemin relatif depuis la racine du repo de ton fichier hello.py de la leçon 00-1. Vérifie les deux : cat <chemin> doit afficher ton code dans les deux cas — une fois depuis ~/, une fois depuis ~/Claude/learnpython.

c) Configuration VS Code complète : ouvre le repo avec code . depuis la racine, installe l'extension Python officielle (Microsoft), ouvre le terminal intégré, vérifie que c'est bien Git Bash (sinon change le profil par défaut), et lance hello.py depuis ce terminal intégré. Capture la preuve : la sortie du script + pwd dans le même terminal.

10. Exercices — difficiles

a) Le parcours sans filet. Ferme VS Code. Au terminal uniquement : (1) crée ~/Claude/learnpython/lessons/level-00-environnement/exercices/mes-reponses/labyrinth/deep/deeper/ en une seule commande ; (2) crée dans deeper/ un fichier exit.py qui affiche way out, sans ouvrir d'éditeur ; (3) exécute-le depuis QUATRE endroits différents : depuis deeper/, depuis labyrinth/, depuis la racine du repo, et depuis ~ avec un chemin absolu ; (4) note les quatre commandes exactes dans ton journal.

Indice 1 : mkdir a une option pour créer les dossiers parents manquants d'un coup — cherche mkdir -p (le --help d'une commande, ou une recherche web, font partie du métier).
Indice 2 : pour écrire dans un fichier sans éditeur : echo 'print("way out")' > chemin/vers/exit.py. Attention aux guillemets : simples à l'extérieur, doubles à l'intérieur.
Indice 3 : les quatre commandes ne diffèrent que par le chemin donné à python. Depuis labyrinth/ : python deep/deeper/exit.py. Construis les trois autres sur ce modèle ; la dernière commence par /c/Users/jtron/ ou ~/.

11. Mini-projet lié — « le plan du repo »

Durée cible : 20–30 min. Au terminal uniquement, explore TOUT le repo learnpython (ls dans chaque dossier, cat sur les README) et dessine dans un fichier repo_map.txt (créé et rempli au terminal ou dans VS Code, au choix) l'arborescence complète sur 2 niveaux de profondeur, avec une ligne de description par élément. Exemple de début :

learnpython/
  README.md            <- point d'entrée de la méthode
  GIT_WORKFLOW.md      <- règlement Git du projet (utilisé en 00-3)
  lessons/
    TEMPLATE_LECON.md  <- structure obligatoire des leçons
    ...

Contraintes : chaque description doit prouver que tu as ouvert le fichier (pas de « un fichier README » — dis ce qu'il contient). Bonus : la commande ls -R ou find . -maxdepth 2 te donne un squelette à annoter. Ce plan te servira de carte mentale pour toute la suite.

12. Correction / méthode de correction

Les corrections détaillées sont dans solutions/serie-00-solutions.md.

Méthode : (1) termine toutes les manipulations avant d'ouvrir les solutions ; (2) compare tes commandes et surtout leur ordre — au terminal, l'ordre est le raisonnement ; (3) chaque message d'erreur rencontré va dans ton journal avec sa cause en une phrase ; (4) le test final honnête : demain, refais l'exercice 10-a sans notes. Si tu y arrives, le terminal est acquis.

13. À retenir

Le terminal est toujours quelque part : pwd avant de douter, ls avant d'agir.
Chemin absolu = valable partout (commence par / ou ~) ; chemin relatif = direction depuis ici (. = ici, .. = parent).
Git Bash = syntaxe Unix = celle des tutoriels, de la doc et des serveurs. C'est notre terminal unique.
Espaces dans un chemin → guillemets obligatoires ; mieux : pas d'espaces dans les noms de projets.
Tab complète et vérifie en même temps ; flèche haut rappelle ; Ctrl+C interrompt.
Dans VS Code : ouvrir le dossier (code .), terminal intégré (Ctrl+ù), extension Python, Ctrl+S avant chaque exécution.
Un message d'erreur du shell désigne toujours le coupable : la commande ou l'argument. Le lire, pas le relancer.

14. Questions de révision

Quelles sont les trois commandes « GPS » et que répond chacune ?
cd lessons échoue avec No such file or directory alors que le dossier existe : explique le paradoxe et donne la démarche de diagnostic.
Donne un chemin absolu et un chemin relatif vers le même fichier, et dis dans quelles conditions chacun fonctionne.
Pourquoi utilise-t-on Git Bash plutôt que cmd ou PowerShell dans cette méthode ?
Que teste réellement la tab-completion, au-delà du gain de temps ?
Pourquoi ouvrir un dossier (et non un fichier) dans VS Code change-t-il le comportement du terminal intégré ?
Que fait mkdir test drive (sans guillemets), exactement ?
Ton script modifié affiche l'ancienne sortie : quelles sont les DEUX causes possibles vues dans les leçons 00-1 et 00-2, et dans quel ordre les vérifies-tu ?

15. Checklist de compréhension

Je navigue jusqu'à n'importe quel dossier du repo sans explorateur Windows, en moins de 30 secondes.
Je peux expliquer .. et . à quelqu'un avec un exemple.
J'utilise Tab systématiquement (et je sais ce que son silence signifie).
Je peux créer un dossier et un fichier au terminal sans regarder la leçon.
VS Code est configuré : dossier ouvert, Git Bash en terminal intégré, extension Python installée.
Je lis un message d'erreur du shell et je nomme le coupable (commande ou argument) avant de retaper quoi que ce soit.
J'ai fait le mini-projet et mon repo_map.txt décrit réellement le repo.

Si une case reste vide : refais les exercices de la section correspondante demain, AVANT d'ouvrir la leçon suivante.

16. Commit conseillé

Comme en 00-1 : si tu n'as pas encore fait la leçon 00-3, garde tes fichiers au chaud. Sinon :

git add lessons/level-00-environnement/exercices/mes-reponses/
git commit -m "exercises: complete lesson 00-2 terminal drills"

Puis, si c'est ta fin de session : entrée de journal + git push.