526 lines
16 KiB
Markdown
526 lines
16 KiB
Markdown
# 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)
|