# Aide-mémoire Python

Toute la syntaxe essentielle du cours, regroupée pour la retrouver vite. Les numéros entre parenthèses renvoient au chapitre où la notion est expliquée en détail.

---

## Sommaire

1. [Bases](#1-bases-ch-01)
2. [Conditions](#2-conditions-ch-02)
3. [Boucles](#3-boucles-ch-03)
4. [Listes](#4-listes-ch-04)
5. [Tuples et ensembles](#5-tuples-et-ensembles-ch-04)
6. [Dictionnaires](#6-dictionnaires-ch-04)
7. [Fonctions](#7-fonctions-ch-05)
8. [Chaînes de caractères](#8-chaînes-de-caractères-ch-06)
9. [Compréhensions et outils d'itération](#9-compréhensions-et-outils-ditération-ch-06)
10. [Fichiers, CSV, JSON](#10-fichiers-csv-json-ch-07)
11. [Exceptions](#11-exceptions-ch-08)
12. [Modules utiles](#12-modules-utiles-ch-09)
13. [Classes](#13-classes-ch-10-et-11)
14. [Annotations de type](#14-annotations-de-type-ch-11)
15. [Commandes du terminal](#15-commandes-du-terminal-ch-00-12-13)
16. [Erreurs courantes et leur sens](#16-erreurs-courantes-et-leur-sens)

---

## 1. Bases (ch. 01)

```python
# Commentaire sur une ligne

nom = "Alice"          # str  : texte
age = 30               # int  : entier
taille = 1.68          # float: nombre à virgule
majeur = True          # bool : True / False
rien = None            # absence de valeur

type(age)              # <class 'int'>
```

**Conversions**

```python
int("42")      # 42
float("3.5")   # 3.5
str(42)        # "42"
bool(0)        # False  (0, "", [], {}, None sont « faux »)
int(3.9)       # 3      (tronque, n'arrondit pas)
round(3.9)     # 4
```

**Opérateurs**

| Opérateur | Sens | Exemple | Résultat |
|---|---|---|---|
| `+ - *` | addition, soustraction, multiplication | `7 * 2` | `14` |
| `/` | division (toujours un float) | `7 / 2` | `3.5` |
| `//` | division entière | `7 // 2` | `3` |
| `%` | reste (modulo) | `7 % 2` | `1` |
| `**` | puissance | `2 ** 10` | `1024` |
| `+=`, `-=`… | raccourcis | `x += 1` | `x = x + 1` |

**Entrées / sorties**

```python
prenom = input("Ton prénom ? ")          # renvoie toujours un str
age = int(input("Ton âge ? "))           # convertir pour calculer

print("Bonjour", prenom)                 # Bonjour Alice
print(f"{prenom} a {age} ans")           # f-string
print(f"Prix : {12.5:.2f} €")            # Prix : 12.50 €
print(f"{42:>6}")                        # '    42' (aligné à droite sur 6)
print("a", "b", sep="-", end="!\n")      # a-b!
```

---

## 2. Conditions (ch. 02)

```python
if note >= 16:
    print("Très bien")
elif note >= 10:
    print("Admis")
else:
    print("Recalé")
```

| Comparaison | Logique |
|---|---|
| `==` égal, `!=` différent | `and` : les deux vrais |
| `<`, `<=`, `>`, `>=` | `or` : au moins un vrai |
| `in`, `not in` (appartenance) | `not` : inverse |
| `is None`, `is not None` | |

```python
if 0 <= age < 18:                  # comparaisons enchaînées
    ...
statut = "majeur" if age >= 18 else "mineur"   # condition sur une ligne

match commande:                    # Python 3.10+
    case "q" | "quitter":
        print("Au revoir")
    case "aide":
        print("Commandes : ...")
    case _:
        print("Commande inconnue")
```

---

## 3. Boucles (ch. 03)

```python
for i in range(5):           # 0, 1, 2, 3, 4
    print(i)

range(2, 10)                 # 2 à 9
range(10, 0, -2)             # 10, 8, 6, 4, 2

for lettre in "abc":         # parcourt n'importe quel itérable
    print(lettre)

compteur = 0
while compteur < 3:
    compteur += 1

while True:                  # boucle infinie + sortie contrôlée
    reponse = input("> ")
    if reponse == "q":
        break                # sort de la boucle
    if reponse == "":
        continue             # passe au tour suivant
    print(reponse)
```

> `Ctrl + C` dans le terminal arrête un programme coincé dans une boucle infinie.

---

## 4. Listes (ch. 04)

```python
fruits = ["pomme", "banane", "kiwi"]

fruits[0]            # "pomme"   (premier)
fruits[-1]           # "kiwi"    (dernier)
fruits[1:3]          # ["banane", "kiwi"]
len(fruits)          # 3
"kiwi" in fruits     # True

fruits.append("poire")       # ajoute à la fin
fruits.insert(0, "fraise")   # insère à l'indice 0
fruits.remove("banane")      # retire la première occurrence
dernier = fruits.pop()       # retire et renvoie le dernier
fruits.sort()                # trie sur place
fruits.reverse()             # inverse sur place
fruits.index("kiwi")         # position d'un élément
fruits.count("pomme")        # nombre d'occurrences

copie = fruits.copy()        # vraie copie (ou fruits[:])
sum([1, 2, 3]), min([4, 2]), max([4, 2])   # 6, 2, 4
```

> **Attention** : `b = a` ne copie pas la liste, les deux noms désignent la même liste.

---

## 5. Tuples et ensembles (ch. 04)

```python
point = (3, 4)               # tuple : non modifiable
x, y = point                 # déballage
a, b = b, a                  # échanger deux variables

couleurs = {"rouge", "vert"} # set : pas de doublons, pas d'ordre
couleurs.add("bleu")
couleurs.discard("vert")
set([1, 1, 2])               # {1, 2}

a, b = {1, 2, 3}, {2, 3, 4}
a | b    # {1, 2, 3, 4}  union
a & b    # {2, 3}        intersection
a - b    # {1}           différence
```

---

## 6. Dictionnaires (ch. 04)

```python
eleve = {"nom": "Alice", "age": 17}

eleve["nom"]                 # "Alice"  (KeyError si absent)
eleve.get("ville")           # None     (pas d'erreur)
eleve.get("ville", "?")      # "?"      (valeur par défaut)
eleve["ville"] = "Lyon"      # ajoute ou modifie
del eleve["age"]             # supprime
"nom" in eleve               # True (teste les clés)

for cle, valeur in eleve.items():
    print(cle, valeur)

eleve.keys(), eleve.values()

compte = {}
compte["a"] = compte.get("a", 0) + 1     # compter des occurrences
```

---

## 7. Fonctions (ch. 05)

```python
def aire_rectangle(largeur, hauteur=1):
    """Renvoie l'aire d'un rectangle."""
    return largeur * hauteur

aire_rectangle(3, 4)                 # 12
aire_rectangle(3)                    # 3  (hauteur par défaut)
aire_rectangle(hauteur=2, largeur=5) # 10 (arguments nommés)

def stats(*nombres, **options):      # nombre variable d'arguments
    print(nombres, options)          # tuple, dict

stats(1, 2, 3, arrondi=2)            # (1, 2, 3) {'arrondi': 2}

def min_max(valeurs):
    return min(valeurs), max(valeurs)  # renvoie un tuple

petit, grand = min_max([4, 1, 9])
```

> **Piège** : ne jamais mettre une liste ou un dict comme valeur par défaut (`def f(x=[])`). Utilise `None` puis crée la liste dans la fonction.

---

## 8. Chaînes de caractères (ch. 06)

```python
s = "  Bonjour le Monde  "

s.strip()                    # "Bonjour le Monde"
s.lower(), s.upper()         # minuscules, majuscules
s.title()                    # "  Bonjour Le Monde  "
s.replace("Monde", "monde")
s.split()                    # ["Bonjour", "le", "Monde"]
"a,b,c".split(",")           # ["a", "b", "c"]
"-".join(["a", "b", "c"])    # "a-b-c"
s.strip().startswith("Bon")  # True
"monde" in s.lower()         # True
s.count("o")                 # 3
s.find("le")                 # indice, ou -1 si absent
"42".isdigit()               # True

mot = "Python"
mot[0], mot[-1]              # "P", "n"
mot[1:4]                     # "yth"
mot[::-1]                    # "nohtyP" (inversé)
```

---

## 9. Compréhensions et outils d'itération (ch. 06)

```python
carres = [x ** 2 for x in range(5)]              # [0, 1, 4, 9, 16]
pairs = [x for x in range(10) if x % 2 == 0]     # [0, 2, 4, 6, 8]
longueurs = {mot: len(mot) for mot in ["a", "abc"]}  # {'a': 1, 'abc': 3}
uniques = {x % 3 for x in range(10)}             # {0, 1, 2}

for i, fruit in enumerate(["a", "b"], start=1):  # 1 a / 2 b
    print(i, fruit)

for nom, note in zip(["Ana", "Léo"], [14, 12]):  # parcourt en parallèle
    print(nom, note)

sorted([3, 1, 2])                        # [1, 2, 3] (nouvelle liste)
sorted(mots, key=len, reverse=True)      # trié par longueur décroissante
sorted(eleves, key=lambda e: e["note"])  # trié selon une clé
any(x > 5 for x in valeurs)              # au moins un ?
all(x > 0 for x in valeurs)              # tous ?
```

---

## 10. Fichiers, CSV, JSON (ch. 07)

```python
from pathlib import Path

# Texte
with open("notes.txt", "w", encoding="utf-8") as f:   # w = écrase
    f.write("Première ligne\n")
with open("notes.txt", "a", encoding="utf-8") as f:   # a = ajoute
    f.write("Suite\n")
with open("notes.txt", encoding="utf-8") as f:        # r par défaut
    for ligne in f:
        print(ligne.strip())

chemin = Path("donnees") / "fichier.txt"
chemin.parent.mkdir(exist_ok=True)
chemin.write_text("bonjour", encoding="utf-8")
chemin.read_text(encoding="utf-8")
chemin.exists(), chemin.suffix, chemin.stem           # True, ".txt", "fichier"

# CSV
import csv
with open("eleves.csv", "w", newline="", encoding="utf-8") as f:
    ecrivain = csv.DictWriter(f, fieldnames=["nom", "note"])
    ecrivain.writeheader()
    ecrivain.writerow({"nom": "Ana", "note": 15})
with open("eleves.csv", newline="", encoding="utf-8") as f:
    for ligne in csv.DictReader(f):
        print(ligne["nom"], int(ligne["note"]))

# JSON
import json
donnees = {"nom": "Ana", "notes": [15, 12]}
with open("data.json", "w", encoding="utf-8") as f:
    json.dump(donnees, f, ensure_ascii=False, indent=2)
with open("data.json", encoding="utf-8") as f:
    donnees = json.load(f)
```

---

## 11. Exceptions (ch. 08)

```python
try:
    nombre = int(input("Nombre : "))
    resultat = 100 / nombre
except ValueError:
    print("Ce n'est pas un nombre.")
except ZeroDivisionError:
    print("Division par zéro impossible.")
else:
    print(f"Résultat : {resultat}")     # si aucune erreur
finally:
    print("Toujours exécuté")

if age < 0:
    raise ValueError("L'âge ne peut pas être négatif")

class SoldeInsuffisant(Exception):     # exception personnalisée
    pass

breakpoint()                           # met le programme en pause (débogueur)
```

---

## 12. Modules utiles (ch. 09)

```python
import random
random.randint(1, 6)            # entier entre 1 et 6 inclus
random.choice(["a", "b"])       # élément au hasard
random.shuffle(liste)           # mélange sur place

import math
math.sqrt(16), math.pi, math.ceil(2.1), math.floor(2.9)   # 4.0, 3.14…, 3, 2

from datetime import date, datetime, timedelta
date.today()
datetime.now().strftime("%d/%m/%Y %H:%M")
date(2026, 12, 25) - date.today()       # timedelta
date.today() + timedelta(days=7)

from collections import Counter, defaultdict
Counter("abracadabra").most_common(2)   # [('a', 5), ('b', 2)]
groupes = defaultdict(list)

import os, sys
os.getcwd()                             # dossier courant
sys.argv                                # arguments de la ligne de commande

# Dans ses propres modules :
if __name__ == "__main__":
    main()      # exécuté seulement si on lance ce fichier directement
```

---

## 13. Classes (ch. 10 et 11)

```python
class Compte:
    taux = 0.02                          # attribut de classe (partagé)

    def __init__(self, titulaire, solde=0):
        self.titulaire = titulaire       # attributs d'instance
        self.solde = solde

    def deposer(self, montant):
        if montant <= 0:
            raise ValueError("Montant invalide")
        self.solde += montant

    def __str__(self):                   # affichage pour l'utilisateur
        return f"{self.titulaire} : {self.solde} €"

    def __repr__(self):                  # affichage pour le développeur
        return f"Compte({self.titulaire!r}, {self.solde})"


class CompteEpargne(Compte):             # héritage
    def __init__(self, titulaire, solde=0, plafond=10_000):
        super().__init__(titulaire, solde)
        self.plafond = plafond


c = CompteEpargne("Ana", 100)
c.deposer(50)
print(c)                                 # Ana : 150 €
isinstance(c, Compte)                    # True
```

**Dataclass et propriété**

```python
from dataclasses import dataclass, field

@dataclass
class Produit:
    nom: str
    prix: float
    tags: list[str] = field(default_factory=list)

    @property
    def prix_ttc(self) -> float:          # s'utilise comme un attribut
        return round(self.prix * 1.2, 2)

p = Produit("Stylo", 2.5)
p.prix_ttc                                # 3.0
```

---

## 14. Annotations de type (ch. 11)

```python
def moyenne(notes: list[float]) -> float:
    return sum(notes) / len(notes)

def trouver(nom: str, annuaire: dict[str, str]) -> str | None:
    return annuaire.get(nom)

age: int = 30
coordonnees: tuple[float, float] = (45.19, 5.72)
```

> Les annotations ne changent pas l'exécution : elles documentent le code et permettent à l'éditeur et à `mypy` de détecter des erreurs.

---

## 15. Commandes du terminal (ch. 00, 12, 13)

**Python et paquets**

| Action | macOS / Linux | Windows |
|---|---|---|
| Lancer un script | `python3 script.py` | `py script.py` ou `python script.py` |
| Version | `python3 --version` | `py --version` |
| Créer un venv | `python3 -m venv .venv` | `py -m venv .venv` |
| Activer le venv | `source .venv/bin/activate` | `.venv\Scripts\Activate.ps1` |
| Désactiver | `deactivate` | `deactivate` |
| Installer un paquet | `pip install requests` | `pip install requests` |
| Figer les dépendances | `pip freeze > requirements.txt` | idem |
| Réinstaller | `pip install -r requirements.txt` | idem |
| Lancer les tests | `pytest` | `pytest` |
| Vérifier / formater | `ruff check .` / `ruff format .` | idem |

**Navigation**

| Action | macOS / Linux | Windows (PowerShell) |
|---|---|---|
| Où suis-je ? | `pwd` | `pwd` |
| Lister | `ls` | `ls` ou `dir` |
| Changer de dossier | `cd dossier` / `cd ..` | idem |
| Créer un dossier | `mkdir nom` | idem |

**Git**

```bash
git init                         # créer un dépôt
git status                       # état des fichiers
git add fichier.py               # préparer (ou git add .)
git commit -m "Message clair"    # enregistrer une version
git log --oneline                # historique
git diff                         # voir les modifications
git switch -c nouvelle-branche   # créer une branche et y aller
git switch main                  # revenir sur main
git merge nouvelle-branche       # fusionner
git remote add origin URL        # lier à GitHub
git push -u origin main          # envoyer
git pull                         # récupérer
git clone URL                    # copier un dépôt existant
```

---

## 16. Erreurs courantes et leur sens

| Erreur | Signification | Cause typique |
|---|---|---|
| `SyntaxError` | Python ne comprend pas la ligne | `:` oublié, parenthèse non fermée, guillemet manquant |
| `IndentationError` | Indentation incorrecte | Mélange tabulations/espaces, bloc mal aligné |
| `NameError: name 'x' is not defined` | Nom inconnu | Faute de frappe, variable utilisée avant d'être créée |
| `TypeError` | Opération impossible sur ce type | `"âge : " + 30`, mauvais nombre d'arguments |
| `ValueError` | Bon type, mauvaise valeur | `int("abc")` |
| `IndexError: list index out of range` | Indice trop grand | `liste[len(liste)]` |
| `KeyError` | Clé absente du dictionnaire | `d["cle"]` au lieu de `d.get("cle")` |
| `AttributeError` | Attribut ou méthode inexistant | `liste.push()` au lieu de `append()`, variable à `None` |
| `ZeroDivisionError` | Division par zéro | Diviseur non vérifié |
| `FileNotFoundError` | Fichier introuvable | Mauvais chemin, script lancé depuis un autre dossier |
| `ModuleNotFoundError` | Module introuvable | Paquet non installé, venv non activé |
| `RecursionError` | Trop d'appels récursifs | Cas de base manquant |

> **Règle d'or** : lis toujours un traceback **de bas en haut**. La dernière ligne dit *quoi*, les lignes au-dessus disent *où*.

---

[← Projet final](15-projet-final.md) | [Sommaire](README.md) | [Ressources →](ressources.md)