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¶

Bases
Conditions
Boucles
Listes
Tuples et ensembles
Dictionnaires
Fonctions
Chaînes de caractères
Compréhensions et outils d'itération
Fichiers, CSV, JSON
Exceptions
Modules utiles
Classes
Annotations de type
Commandes du terminal
Erreurs courantes et leur sens

1. Bases (ch. 01)¶

# 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

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

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)¶

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`

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)¶

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)¶

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)¶

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)¶

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)¶

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)¶

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)¶

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)¶

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)¶

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)¶

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)¶

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é

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)¶

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

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 | Sommaire | Ressources →