932 lines
36 KiB
Markdown
932 lines
36 KiB
Markdown
# 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)
|