Voici ce que ton programme affichera à la fin du niveau 8, quand ton héros sera un objet Python :

>>> Aria [60/60 PV] affronte Gobelin [18/18 PV]
Aria lance une boule de feu sur Gobelin : -11 PV (7/18)
Gobelin frappe Aria : -6 PV (54/60)
Aria lance une boule de feu sur Gobelin : -14 PV (0/18)

>>> Aria [54/60 PV] affronte Ogre [40/40 PV]
Aria lance une boule de feu sur Ogre : -16 PV (24/40)
...
Victoire ! Aria [31/60 PV] — 62 or — sac : potion, épée d'argent

Les règles du jeu

Chaque niveau suit le même déroulé. Tu peux le parcourir seul ou en séance avec ton enseignant.

Chaque défi relevé et chaque bonne réponse au quiz te rapportent de l'XP. Ton rang progresse de Rat de cave à Légende du Python. Ta progression est enregistrée dans ce navigateur uniquement.

Python en 2 minutes

Python est un langage de programmation : une façon d'écrire des instructions qu'un ordinateur peut exécuter. Trois choses le rendent idéal pour débuter :

• Il se lit presque comme de l'anglais. if age >= 18: print("Bienvenue") se comprend sans formation.
• Il est interprété. Pas besoin de compiler : tu écris une ligne, tu l'exécutes, tu vois le résultat tout de suite.
• Il sert partout. Intelligence artificielle, analyse de données, sites web, cybersécurité, automatisation, jeux vidéo, scripts pour Blender ou QGIS…

Contrepartie : Python est plus lent que C ou Java à l'exécution. Pour un jeu en terminal ou un script, la différence ne se voit pas. Pour l'IA, les bibliothèques comme NumPy font le calcul lourd en C et gardent la simplicité de Python côté utilisateur.

Installer ton équipement

1. Python : télécharge la dernière version sur python.org. Sous Windows, coche Add python.exe to PATH sur le premier écran de l'installateur : c'est l'oubli le plus fréquent. Sous macOS et Linux, Python 3 est souvent déjà là (python3 --version).
2. VS Code : installe Visual Studio Code, puis l'extension Python de Microsoft (onglet Extensions, à gauche). PyCharm Community fonctionne aussi très bien.
3. Vérifie en ouvrant un terminal :

python --version        # Windows
python3 --version       # macOS / Linux

Parler à l'interpréteur

Tape python (ou python3) dans le terminal. Les trois chevrons >>> signifient que Python t'écoute. Chaque ligne est exécutée dès que tu appuies sur Entrée.

>>> 2 + 3
5
>>> 7 / 2
3.5
>>> 7 // 2        # division entière
3
>>> 2 ** 10       # puissance
1024
>>> "Py" + "thon"
'Python'
>>> "Ha" * 3
'HaHaHa'
>>> help(print)   # l'aide intégrée ; q pour quitter

Pour sortir : exit() ou Ctrl+D (macOS/Linux), Ctrl+Z puis Entrée (Windows).

print("=" * 5 + "!" * 2)
print(10 - 2 * 3)
print((10 - 2) * 3)

=====!!
4
24

Ton premier script

L'interpréteur oublie tout quand tu le fermes. Pour garder ton travail, écris un script : un fichier texte qui finit par .py. Dans VS Code, crée un dossier crypte, puis un fichier bonjour.py :

# Ceci est un commentaire : Python l'ignore.
# Il sert aux humains qui liront ton code (toi dans trois semaines, par exemple).

print("Bonjour, aventurier !")
print("Tu as", 20, "ans.")      # print accepte plusieurs valeurs, séparées par des virgules
print()                         # ligne vide
print("Fin du programme.")

Lance-le avec le bouton ▷ en haut à droite de VS Code, ou dans le terminal : python bonjour.py. Python exécute les lignes de haut en bas, une par une.

Lire un message d'erreur

Tu vas faire des erreurs. Tout le monde en fait, tout le temps. La compétence qui compte, c'est de lire le message au lieu de paniquer. Il se lit de bas en haut :

  File "bonjour.py", line 4
    print("Bonjour, aventurier !)
          ^
SyntaxError: unterminated string literal (detected at line 4)

• Dernière ligne : le type d'erreur et son explication. Ici, une chaîne de caractères non terminée : il manque le guillemet fermant.
• Au-dessus : le fichier, le numéro de ligne, et un ^ qui pointe l'endroit du problème.

Défis

print("=" * 40)
print("        LA CRYPTE DU SERPENT")
print("=" * 40)
print("   /^\\/^\\")
print(" _|__|  O|")
print("        \\/     /~     \\_/ \\")
print("         \\____|__________/  \\")
print("=" * 40)
print("Version 0.1 — par", "Aria")

Les variables : des étiquettes sur des valeurs

Une variable est un nom qui désigne une valeur. Le signe = ne veut pas dire « égal » : il veut dire « range la valeur de droite sous le nom de gauche ».

nom = "Aria"
pv = 60
pv = pv - 15        # on calcule pv - 15 (45), puis on range le résultat dans pv
pv -= 5             # raccourci pour pv = pv - 5 ; existe aussi : +=  *=  /=
print(nom, "a", pv, "PV")

Bien nommer

• Lettres, chiffres et _, sans commencer par un chiffre : pv_max oui, 2pv non.
• Majuscules et minuscules comptent : Pv et pv sont deux variables différentes.
• Convention Python (PEP 8) : snake_case, en minuscules avec des tirets bas.
• Un bon nom dit ce que contient la variable : points_de_vie plutôt que x.
• Interdit : les mots-clés du langage (if, for, class, or…). D'où or_ pour stocker de l'or !

Les quatre types de base

La fonction type() te dit le type d'une valeur. Python devine le type tout seul : on dit qu'il est typé dynamiquement.

print(type(42))
print(type(4.2))
print(type("42"))
print(type(4 > 2))
print(7 / 7)

<class 'int'>
<class 'float'>
<class 'str'>
<class 'bool'>
1.0

Dialoguer avec le joueur : input

input() affiche un message, attend que le joueur tape quelque chose puis appuie sur Entrée, et renvoie ce qu'il a tapé.

nom = input("Comment t'appelles-tu ? ")
print("Bienvenue,", nom)

Convertir entre types

age = int(input("Âge : "))          # "19"  -> 19
taille = float(input("Taille : "))  # "1.75" -> 1.75
texte = str(42)                     # 42 -> "42"
int(3.99)                           # 3 : on coupe, on n'arrondit pas
round(3.99)                         # 4
bool(0), bool(""), bool("non")      # False, False, True

a = "5"
b = 3
print(a * b)
print(int(a) * b)
print(a + str(b))

555
15
53

Les opérateurs

Les priorités sont celles des maths : **, puis * / // %, puis + -. Dans le doute, mets des parenthèses.

Les chaînes de caractères

nom = "  aria la Rapide  "
nom = nom.strip()           # "aria la Rapide" : enlève les espaces au bord
print(nom.upper())          # ARIA LA RAPIDE
print(nom.title())          # Aria La Rapide
print(len(nom))             # 14 caractères
print(nom[0])               # a : le premier caractère est à l'indice 0
print(nom[-1])              # e : le dernier
print(nom.replace("Rapide", "Lente"))

Les f-strings : la mise en forme facile

Un f devant les guillemets, et tout ce qui est entre { } est remplacé par sa valeur :

nom, pv, or_ = "Aria", 47, 1250.5
print(f"{nom} a {pv} PV et {or_} pièces.")
print(f"PV restants : {pv / 60 * 100:.1f} %")   # :.1f -> 1 chiffre après la virgule
print(f"|{nom:<10}|")      # aligné à gauche sur 10 caractères
print(f"|{nom:>10}|")      # aligné à droite
print(f"|{nom:^10}|")      # centré
print(f"{pv = }")          # astuce de débogage : affiche "pv = 47"

force = 7
print(f"Dégâts : {force * 2 + 1}")
print(f"[{'#' * 3:<6}]")

Dégâts : 15
[###   ]

Défis

+------------------------------+
|     FICHE DE PERSONNAGE      |
+------------------------------+
| Nom       : Aria             |
| PV        : 85               |
| Force     : 7                |
| Agilité   : 5                |
| Puissance : 19               |
| Or        : 10               |
+------------------------------+
Peut entrer dans la taverne : True

Comparer : vrai ou faux

Une comparaison produit un booléen, True ou False.

if, elif, else

pv = int(input("PV du héros : "))

if pv <= 0:
    print("Tu es mort.")
elif pv < 20:
    print("Tu es gravement blessé.")
    print("Trouve vite une potion !")
elif pv < 50:
    print("Tu es blessé.")
else:
    print("Tu es en pleine forme.")

print("Fin du bilan de santé.")   # hors du if : toujours exécuté

Python teste les conditions dans l'ordre et exécute uniquement le premier bloc dont la condition est vraie. elif et else sont facultatifs.

L'indentation n'est pas décorative

En Python, ce sont les 4 espaces en début de ligne qui disent ce qui appartient au if. Pas d'accolades comme en C ou en Java. Les deux-points : en fin de ligne annoncent un bloc indenté.

or_ = 30
if or_ >= 50:
    print("Tu achètes l'épée.")
    or_ -= 50
print("Il te reste", or_, "pièces.")

Il te reste 30 pièces.

Combiner : and, or, not

a_la_cle = True
force = 4

if a_la_cle or force >= 8:
    print("La porte s'ouvre.")         # avec la clé OU en la défonçant

if force >= 3 and not a_la_cle:
    print("Tu pourrais forcer la serrure.")

if 1 <= force <= 10:                   # Python accepte les comparaisons enchaînées
    print("Force valide.")

classe = "Mage"
print(classe == "mage")
print(classe.lower() == "mage")
print("ag" in classe)
print(not (3 > 2 and 2 > 5))

False
True
True
True

L'expression ternaire

Pour choisir entre deux valeurs en une ligne :

etat = "en forme" if pv > 50 else "blessé"
titre = "Dame" if genre == "f" else "Sire"

match / case : l'aiguillage

Depuis Python 3.10, match compare une valeur à plusieurs motifs. C'est plus lisible qu'une longue suite de elif sur la même variable.

direction = input("Direction (n/s/e/o) : ").lower()

match direction:
    case "n" | "nord":            # | : l'un OU l'autre
        print("Tu montes l'escalier.")
    case "s":
        print("Tu redescends vers l'entrée.")
    case "e" | "o":
        print("Un mur. Tu te cognes le nez.")
    case _:                       # _ : tous les autres cas
        print("Direction inconnue.")

Un peu de hasard

Un jeu a besoin d'imprévu. Le module random fournit des nombres aléatoires. On le charge avec import, en haut du fichier :

import random

de = random.randint(1, 20)          # entier entre 1 et 20 inclus
if de == 20:
    print("Coup critique !")
elif de == 1:
    print("Échec critique : tu lâches ton arme.")

Défis

Tu arrives à un carrefour. Trois couloirs s'ouvrent devant toi.
Où vas-tu ? (gauche / droite / tout droit) : Tout Droit
Un gobelin te barre la route !
Tu le repousses après un combat serré.
PV restants : 60 (en forme) — Or : 10

if x > 20:
    print("A")
elif x > 10:
    print("B")
elif x > 5:
    print("C")

while : tant que…

while répète un bloc tant que sa condition est vraie. La condition est vérifiée avant chaque tour.

pv_monstre = 30
tour = 1

while pv_monstre > 0:
    print(f"Tour {tour} : tu frappes ! ({pv_monstre} PV)")
    pv_monstre -= 8
    tour += 1

print("Le monstre est vaincu en", tour - 1, "tours.")

n = 1
while n < 50:
    n = n * 3
print(n)

81

Le modèle « redemander jusqu'à ce que ce soit bon »

reponse = ""
while reponse not in ("o", "n"):
    reponse = input("Ouvrir le coffre ? (o/n) ").lower()

for : pour chaque…

for parcourt une suite de valeurs, une par une. Avec range, on répète un nombre de fois connu à l'avance.

for i in range(3):            # 0, 1, 2  (3 est exclu !)
    print("Coup d'épée", i)

for salle in range(1, 6):     # 1, 2, 3, 4, 5
    print("Salle", salle)

for pv in range(100, 0, -25): # 100, 75, 50, 25 : de 100 à 0 exclu, pas de -25
    print(pv)

for lettre in "PYTHON":       # on peut parcourir une chaîne
    print(lettre, end=" ")    # end=" " : pas de retour à la ligne

Compteurs et accumulateurs

Deux modèles reviennent sans cesse. On initialise une variable avant la boucle, on la met à jour dans la boucle.

import random

total_degats = 0        # accumulateur
critiques = 0           # compteur
for coup in range(10):
    de = random.randint(1, 20)
    total_degats += de
    if de == 20:
        critiques += 1
print(f"Total : {total_degats}, moyenne : {total_degats / 10}, critiques : {critiques}")

somme = 0
for i in range(1, 5):
    somme += i
    print(i, somme)

1 1
2 3
3 6
4 10

break et continue

• break sort immédiatement de la boucle.
• continue abandonne le tour en cours et passe directement au suivant.

while True:                           # boucle infinie volontaire…
    commande = input("> ")
    if commande == "quitter":
        break                         # …dont on sort avec break
    if commande == "":
        continue                      # ligne vide : on redemande
    print("Tu as tapé :", commande)

for n in range(10):
    if n % 2 == 0:
        continue
    if n > 6:
        break
    print(n)

1
3
5

Boucles imbriquées

Une boucle dans une boucle : pour chaque tour de la boucle extérieure, la boucle intérieure fait tous ses tours.

for ligne in range(4):
    for colonne in range(8):
        print("#" if ligne in (0, 3) or colonne in (0, 7) else ".", end="")
    print()

########
#......#
#......#
########

Défis

   *
  ***
 *****
*******
   |

=== Salle 1 : un squelette (25 PV) surgit ! ===
[60/60 PV, 2 potion(s)] (a)ttaquer, (p)otion, (f)uir ? a
COUP CRITIQUE !
Tu infliges 18 dégâts.
Le squelette riposte : -7 PV.
[53/60 PV, 2 potion(s)] (a)ttaquer, (p)otion, (f)uir ? a
Tu infliges 9 dégâts.
Le squelette s'effondre en tas d'os.

pv = 10
while pv > 0:
    print("Aïe")
pv -= 1

Définir et appeler

def saluer(nom):                       # définition : rien ne s'affiche encore
    print(f"Salutations, {nom} !")

saluer("Aria")                         # appel : le code de la fonction s'exécute
saluer("Brom")

• def, un nom, des parenthèses avec les paramètres, deux-points, puis un bloc indenté.
• À l'appel, les valeurs passées ("Aria") s'appellent les arguments.
• Une fonction doit être définie avant d'être appelée.

return : rendre un résultat

return renvoie une valeur à l'endroit de l'appel et arrête la fonction. Sans return, la fonction renvoie None.

def calculer_degats(force, bonus):
    return force * 2 + bonus

degats = calculer_degats(7, 3)         # degats vaut 17
print(calculer_degats(5, 0) + 10)      # 20 : on peut utiliser le résultat dans un calcul

def double_affiche(x):
    print(x * 2)

def double_renvoie(x):
    return x * 2

a = double_affiche(5)
b = double_renvoie(5)
print(a, b)

10
None 10

Paramètres : valeurs par défaut et arguments nommés

import random

def lancer_des(nombre=1, faces=6):
    """Lance `nombre` dés à `faces` faces et renvoie la somme."""
    total = 0
    for _ in range(nombre):            # _ : variable dont on ne se sert pas
        total += random.randint(1, faces)
    return total

lancer_des()                 # 1d6
lancer_des(2)                # 2d6
lancer_des(1, 20)            # 1d20
lancer_des(faces=20)         # 1d20, en nommant l'argument : plus lisible

Le texte entre triples guillemets sous le def est une docstring : help(lancer_des) l'affiche, et VS Code la montre au survol.

Renvoyer plusieurs valeurs

def convertir(cuivres):
    return cuivres // 10000, cuivres // 100 % 100, cuivres % 100   # un tuple

or_, argent, cuivre = convertir(123456)      # on « déballe » le tuple

La portée des variables

Une variable créée dans une fonction est locale : elle n'existe que pendant l'exécution de la fonction et disparaît ensuite.

pv = 100

def prendre_coup():
    pv = 80
    print("Dans la fonction :", pv)

prendre_coup()
print("Dehors :", pv)

Dans la fonction : 80
Dehors : 100

Le pv de la fonction est une autre variable que celui du dehors. La bonne pratique est de passer les données en paramètre et récupérer le résultat avec return, plutôt que de modifier des variables globales.

def prendre_coup(pv, degats):
    return max(0, pv - degats)

pv = prendre_coup(pv, 20)

Une fonction qui s'appelle elle-même

Une fonction récursive s'appelle elle-même sur un problème plus petit, jusqu'à un cas de base qui arrête la récursion.

def factorielle(n):
    if n <= 1:                         # cas de base : on s'arrête
        return 1
    return n * factorielle(n - 1)      # 5! = 5 × 4!

print(factorielle(5))                  # 120

Les modules : ranger le grimoire

Un module est simplement un fichier .py. On importe ses fonctions depuis un autre fichier du même dossier.

import random

def lancer(faces=6):
    return random.randint(1, faces)

def est_critique(chance=0.15):
    return random.random() < chance

if __name__ == "__main__":
    # Exécuté seulement si on lance des.py directement (pour tester),
    # pas quand un autre fichier fait « import des »
    for _ in range(5):
        print(lancer(20))

import des                       # on utilise ensuite des.lancer(...)
from des import est_critique     # on utilise directement est_critique()
import math                      # module de la bibliothèque standard

print(des.lancer(20))
print(est_critique())
print(math.sqrt(16), math.pi)

Défis

==============================
        Aria VS Ogre
==============================
-- Tour 1 --
  Ogre       [###########.........]
  Aria       [##########..........]
-- Tour 2 --
  COUP CRITIQUE !
  Ogre       [....................]
Victoire ! Aria sort de la crypte avec 40 PV.

def f(x):
    return x + 1
    print("fini")

print(f(f(1)))

def compte_a_rebours(n):
    print(n)
    compte_a_rebours(n - 1)

Quelle structure pour quel usage ?

Les listes

sac = ["torche", "corde", "potion"]

print(sac[0])          # torche   (le premier élément est à l'indice 0)
print(sac[-1])         # potion   (le dernier)
print(len(sac))        # 3

sac.append("épée")             # ajoute à la fin
sac.insert(0, "carte")         # insère à l'indice 0
sac.remove("corde")            # retire la première occurrence de "corde"
objet = sac.pop()              # retire et renvoie le dernier élément ("épée")
sac[1] = "torche magique"      # remplace l'élément d'indice 1

if "potion" in sac:
    print("Tu as une potion.")

for objet in sac:              # parcourir les éléments
    print("-", objet)

for i, objet in enumerate(sac, start=1):   # avec leur numéro
    print(f"{i}. {objet}")

Le découpage (slicing)

salles = ["entrée", "couloir", "crypte", "trésor", "sortie"]
salles[1:3]     # ['couloir', 'crypte']          de 1 inclus à 3 exclu
salles[:2]      # ['entrée', 'couloir']          depuis le début
salles[2:]      # ['crypte', 'trésor', 'sortie'] jusqu'à la fin
salles[::-1]    # la liste à l'envers (fonctionne aussi sur les chaînes)

Trier

scores = [42, 7, 99, 15]
scores.sort()                       # trie LA liste elle-même, renvoie None
classement = sorted(scores, reverse=True)   # renvoie une NOUVELLE liste triée
print(max(scores), min(scores), sum(scores))

a = [1, 2, 3]
b = a
b.append(4)
print(a)
c = a.copy()
c.append(5)
print(a, c)

[1, 2, 3, 4]
[1, 2, 3, 4] [1, 2, 3, 4, 5]

Les tuples

Un tuple est une liste figée : une fois créé, on ne peut plus le modifier. On l'utilise pour des valeurs qui vont ensemble et ne doivent pas changer, comme des coordonnées.

position = (2, 5)
ligne, colonne = position        # déballage
position = (ligne + 1, colonne)  # on ne modifie pas le tuple, on en crée un nouveau
# position[0] = 3                -> TypeError : 'tuple' object does not support item assignment

DIRECTIONS = {"z": (-1, 0), "s": (1, 0), "q": (0, -1), "d": (0, 1)}

Les ensembles

Un ensemble est un sac sans ordre et sans doublons. Tester l'appartenance avec in y est très rapide, même avec un million d'éléments.

vus = {"rat", "gobelin", "squelette", "rat"}     # le doublon disparaît
vaincus = {"rat", "gobelin"}
vus.add("ogre")

print(vus - vaincus)        # différence : vus mais pas vaincus  -> {'squelette', 'ogre'}
print(vus & vaincus)        # intersection : les deux             -> {'rat', 'gobelin'}
print(vus | {"dragon"})     # union
print(vaincus <= vus)       # inclusion : True

sans_doublons = list(set(["a", "b", "a", "c"]))   # astuce classique

Les dictionnaires

Un dictionnaire associe des clés à des valeurs, comme un vrai dictionnaire associe un mot à sa définition. On n'accède pas aux éléments par position mais par clé.

heros = {"nom": "Aria", "pv": 60, "force": 7, "inventaire": ["torche"]}

print(heros["nom"])                 # Aria
heros["pv"] -= 15                   # modifier
heros["or"] = 120                   # ajouter une nouvelle clé
del heros["force"]                  # supprimer
heros["inventaire"].append("potion")   # une valeur peut être une liste

print(heros.get("mana", 0))         # 0 : valeur par défaut si la clé n'existe pas
# heros["mana"]                     -> KeyError : 'mana'

for cle, valeur in heros.items():
    print(f"{cle:>10} : {valeur}")

Liste de dictionnaires : le bestiaire

bestiaire = [
    {"nom": "Rat géant", "pv": 10, "force": 3},
    {"nom": "Gobelin", "pv": 18, "force": 5},
    {"nom": "Ogre", "pv": 40, "force": 8},
]
for monstre in bestiaire:
    print(monstre["nom"], "-", monstre["pv"], "PV")

le_plus_fort = max(bestiaire, key=lambda m: m["force"])   # key : critère de comparaison

compte = {}
for mot in "le rat et le chat et le chien".split():
    compte[mot] = compte.get(mot, 0) + 1
print(compte)

{'le': 3, 'rat': 1, 'et': 2, 'chat': 1, 'chien': 1}

Les compréhensions

Une compréhension construit une liste (ou un ensemble, ou un dictionnaire) en une ligne, à partir d'une autre collection. Elle se lit comme une phrase.

# « les carrés de n, pour n de 1 à 5 »
carres = [n ** 2 for n in range(1, 6)]                     # [1, 4, 9, 16, 25]

# « le nom de chaque monstre, pour chaque monstre du bestiaire, si ses pv dépassent 15 »
costauds = [m["nom"] for m in bestiaire if m["pv"] > 15]   # ['Gobelin', 'Ogre']

# compréhension de dictionnaire
pv_par_nom = {m["nom"]: m["pv"] for m in bestiaire}

# compréhension d'ensemble
initiales = {m["nom"][0] for m in bestiaire}

Elle remplace ce modèle en quatre lignes :

costauds = []
for m in bestiaire:
    if m["pv"] > 15:
        costauds.append(m["nom"])

mots = ["épée", "arc", "hallebarde", "dague"]
print([len(m) for m in mots])
print([m.upper() for m in mots if len(m) < 5])
print({m: m[0] for m in mots[:2]})

[4, 3, 10, 5]
['ÉPÉE', 'ARC']
{'épée': 'é', 'arc': 'a'}

Listes de listes : une carte en 2D

CARTE = [
    "#######",
    "#..M..#",
    "#.#.#T#",
    "#######",
]
grille = [list(ligne) for ligne in CARTE]   # chaque ligne devient une liste modifiable
print(grille[1][3])                          # 'M' : ligne 1, colonne 3
grille[1][3] = "."                           # le monstre est vaincu
for ligne in grille:
    print("".join(ligne))                    # "".join : recolle une liste de caractères

Défis

#########
#...?...#
#?##.##?#
#??.@.??#
#?##?##?#
#???????#
#########
PV 60/60 | Or 30 | Sac : torche, potion
Déplacement (z/q/s/d), (i)nventaire, (x) quitter :

Texte ou binaire ?

• Fichier texte : des caractères lisibles dans n'importe quel éditeur (.txt, .csv, .json, .py…).
• Fichier binaire : des octets bruts, illisibles dans un éditeur (images, sons, .exe, .zip…).

Ouvrir un fichier : with open

with open("journal.txt", "w", encoding="utf-8") as f:
    f.write("Jour 1 : entrée dans la crypte.\n")    # \n : retour à la ligne, à mettre soi-même
    f.write("Jour 2 : rencontre avec un gobelin.\n")
# en sortant du bloc with, le fichier est fermé automatiquement, même en cas d'erreur

Lire

with open("journal.txt", encoding="utf-8") as f:
    contenu = f.read()             # tout le fichier dans une seule chaîne

with open("journal.txt", encoding="utf-8") as f:
    for ligne in f:                # ligne par ligne : idéal pour les gros fichiers
        print(ligne.strip())       # strip() enlève le \n de fin de ligne

with open("journal.txt", encoding="utf-8") as f:
    lignes = f.readlines()         # une liste de chaînes, une par ligne

with open("test.txt", "w", encoding="utf-8") as f:
    f.write("A\n")
with open("test.txt", "a", encoding="utf-8") as f:
    f.write("B\n")
with open("test.txt", "w", encoding="utf-8") as f:
    f.write("C\n")
with open("test.txt", encoding="utf-8") as f:
    print(f.read())

C

CSV : des tableaux en texte

Un fichier CSV contient une ligne par enregistrement, avec des valeurs séparées par une virgule ou un point-virgule. Excel et LibreOffice l'ouvrent directement.

nom;score
Aria;1250
Brom;980

import csv

with open("scores.csv", "a", newline="", encoding="utf-8") as f:
    ecrivain = csv.writer(f, delimiter=";")
    ecrivain.writerow(["Aria", 1250])

with open("scores.csv", newline="", encoding="utf-8") as f:
    for ligne in csv.DictReader(f, delimiter=";"):     # chaque ligne devient un dict
        print(ligne["nom"], int(ligne["score"]))       # tout est lu comme du texte !

JSON : sauvegarder des dictionnaires et des listes

JSON est le format d'échange de données du web. Il ressemble énormément aux dictionnaires et aux listes de Python.

import json

heros = {"nom": "Aria", "pv": 45, "inventaire": ["torche", "potion"], "position": (3, 4)}

with open("partie.json", "w", encoding="utf-8") as f:
    json.dump(heros, f, ensure_ascii=False, indent=2)   # indent : fichier lisible

with open("partie.json", encoding="utf-8") as f:
    charge = json.load(f)

print(charge["position"])     # [3, 4] : une liste, plus un tuple !

{
  "nom": "Aria",
  "pv": 45,
  "inventaire": [
    "torche",
    "potion"
  ],
  "position": [
    3,
    4
  ]
}

json.dumps(objet) et json.loads(texte), avec un s pour string, font la même chose avec une chaîne au lieu d'un fichier. Tu les retrouveras au niveau 10 avec les API web.

Les fichiers binaires

with open("carte.png", "rb") as source, open("copie.png", "wb") as dest:
    donnees = source.read()            # un objet bytes : b'\x89PNG\r\n...'
    print(donnees[:4])                 # les 4 premiers octets identifient le format
    dest.write(donnees)

Le module pickle sauvegarde n'importe quel objet Python en binaire. Il est pratique, mais ne charge jamais un fichier pickle reçu de quelqu'un d'autre : il peut exécuter du code arbitraire. Pour une sauvegarde de jeu, JSON est plus sûr et lisible.

Défis

# nom,pv,force,or
Rat géant,10,3,2
Gobelin,18,5,8
Squelette,22,6,12
Araignée de crypte,15,7,10

Trois familles d'erreurs

Les erreurs de logique sont les plus traîtresses. Seuls les tests, et ta lecture attentive, peuvent les détecter.

Les exceptions que tu croiseras

Lire une trace d'erreur (traceback)

Traceback (most recent call last):
  File "main.py", line 12, in <module>
    main()
  File "main.py", line 8, in main
    pv = calculer_pv(force)
  File "main.py", line 3, in calculer_pv
    return 50 + force * 5
           ~~~^~~~~~~~~~~
TypeError: can only concatenate str (not "int") to str

1. La dernière ligne donne le type et le message : on a additionné une chaîne et un nombre.
2. Juste au-dessus : où ça a planté (ligne 3, dans calculer_pv).
3. En remontant : le chemin des appels. main a appelé calculer_pv avec force… qui venait d'un input() jamais converti en int.

try / except : désamorcer le piège

try:
    force = int(input("Force : "))         # code qui peut échouer
    ratio = 100 / force
except ValueError:
    print("Ce n'est pas un nombre.")      # exécuté seulement si ValueError
except ZeroDivisionError:
    print("La force ne peut pas être nulle.")

Si une ligne du try lève une exception, Python saute immédiatement au except correspondant. Les lignes suivantes du try ne sont pas exécutées.

Le bloc complet

try:
    f = open("partie.json", encoding="utf-8")
    donnees = f.read()
except FileNotFoundError as e:          # « as e » : on récupère l'exception
    print("Pas de sauvegarde :", e)
else:
    print("Sauvegarde lue.")            # seulement si AUCUNE exception
    f.close()
finally:
    print("Fin de la tentative.")       # TOUJOURS exécuté, erreur ou pas

def test(x):
    try:
        print("A")
        r = 10 / x
        print("B")
    except ZeroDivisionError:
        print("C")
    else:
        print("D")
    finally:
        print("E")

test(0)
print("---")
test(5)

A
C
E
---
A
B
D
E

Le modèle « redemander jusqu'à ce que ce soit valide »

def demander_entier(message, mini, maxi):
    while True:
        try:
            valeur = int(input(message))
        except ValueError:
            print("Entre un nombre entier.")
            continue
        if mini <= valeur <= maxi:
            return valeur
        print(f"Entre un nombre entre {mini} et {maxi}.")

raise : déclencher un piège

Ta propre fonction peut signaler une situation impossible en levant une exception. C'est le code qui l'appelle qui décide comment réagir.

def retirer_or(heros, montant):
    if montant < 0:
        raise ValueError("le montant doit être positif")
    if montant > heros["or"]:
        raise ValueError(f"pas assez d'or ({heros['or']} < {montant})")
    heros["or"] -= montant

Tes propres exceptions

class ErreurJeu(Exception):          # on hérite d'Exception (tu comprendras au niveau 8)
    pass

class ActionImpossible(ErreurJeu):
    pass

try:
    raise ActionImpossible("le coffre est verrouillé")
except ActionImpossible as e:
    print(f"Impossible : {e}.")

Déboguer comme un pro

• Lis le message. Vraiment. En entier.
• Affiche les valeurs : print(f"{pv=} {type(pv)=}") juste avant la ligne qui plante.
• Utilise le débogueur de VS Code : clique à gauche d'un numéro de ligne pour poser un point d'arrêt (un rond rouge), lance avec F5, puis avance ligne par ligne en regardant les variables.
• Explique ton code à un canard en plastique, ligne par ligne, à voix haute. Tu trouveras le bug avant la fin. C'est une vraie technique, le rubber duck debugging.

Défis

prix = {"potion": 15, "torche": 3}
panier = ["potion", "épée", "torche"]
total = 0
for article in panier:
    total += prix[article]
print(total)

Sauvegarde abîmée (partie.json illisible (ligne 1)). On repart de zéro.
Aria — 40/60 PV, 50 or, sac : ['torche']
Action (boire/acheter/sauver/quitter) : boire
Impossible : tu n'as pas de potion.
Action (boire/acheter/sauver/quitter) : acheter
Combien de potions ? trois
« trois » n'est pas un nombre entier. Réessaie.

Pourquoi des objets ?

Jusqu'ici, les données (le dictionnaire du héros) et les actions (les fonctions qui le modifient) étaient séparées. Un objet regroupe les deux. Il sait des choses (ses attributs) et il sait faire des choses (ses méthodes).

Ta première classe

class Personnage:
    def __init__(self, nom, pv_max, force):     # le constructeur : appelé à la création
        self.nom = nom                           # self = l'objet en cours de construction
        self.pv_max = pv_max
        self.pv = pv_max
        self.force = force

    def est_vivant(self):
        return self.pv > 0

    def attaquer(self, cible):
        cible.pv -= self.force
        print(f"{self.nom} frappe {cible.nom} : -{self.force} PV")


aria = Personnage("Aria", 60, 7)       # création d'une instance : __init__ est appelé
gob = Personnage("Gobelin", 18, 4)
aria.attaquer(gob)                     # équivaut à Personnage.attaquer(aria, gob)
print(gob.pv, gob.est_vivant())        # 11 True

Encapsulation : protéger l'état interne

Rien n'empêche d'écrire gob.pv = -500. Pour garantir qu'un objet reste toujours cohérent, on cache l'attribut et on contrôle son accès.

• _pv (un tiret bas) : une convention qui dit « usage interne, n'y touche pas ».
• __pv (deux tirets bas) : Python renomme l'attribut en _Personnage__pv, ce qui le rend difficile d'accès depuis l'extérieur.
• @property : un accès qui ressemble à un attribut mais passe par une méthode, dans laquelle on peut vérifier les valeurs.

class Personnage:
    def __init__(self, nom, pv_max, force):
        self.nom = nom
        self.pv_max = pv_max
        self.__pv = pv_max
        self.force = force

    @property
    def pv(self):                      # lecture :  print(perso.pv)
        return self.__pv

    @pv.setter
    def pv(self, valeur):              # écriture : perso.pv = 12
        self.__pv = max(0, min(self.pv_max, valeur))   # toujours entre 0 et pv_max

gob = Personnage("Gobelin", 18, 4)
gob.pv -= 500
print(gob.pv)          # 0 : impossible de descendre en dessous
gob.pv += 1000
print(gob.pv)          # 18 : impossible de dépasser le max

Les méthodes spéciales

Les méthodes entourées de doubles tirets bas (dunder methods) permettent à tes objets de fonctionner avec les opérateurs et les fonctions natives de Python.

class Monstre(Personnage):
    def __str__(self):                  # print(monstre), str(monstre), f"{monstre}"
        return f"{self.nom} [{self.pv}/{self.pv_max} PV]"

    def __repr__(self):                 # affichage technique, dans une liste par exemple
        return f"Monstre({self.nom!r}, pv={self.pv})"

    def __eq__(self, autre):            # monstre1 == monstre2
        return self.nom == autre.nom

    def __lt__(self, autre):            # monstre1 < monstre2, et donc sorted(monstres)
        return self.pv_max < autre.pv_max

Héritage : la classe fille

Un Guerrier est un Heros, qui est un Personnage. La classe fille hérite de tout ce que sait la classe mère, puis ajoute ou modifie ce qui lui est propre.

class Heros(Personnage):                       # Heros hérite de Personnage
    def __init__(self, nom, pv_max, force):
        super().__init__(nom, pv_max, force)   # on laisse la mère initialiser sa partie
        self.or_ = 0                           # puis on ajoute ce qui est spécifique

class Mage(Heros):
    def __init__(self, nom):
        super().__init__(nom, pv_max=60, force=3)
        self.mana = 50

    def attaquer(self, cible):                 # on REDÉFINIT la méthode de la mère
        if self.mana >= 10:
            self.mana -= 10
            cible.pv -= 15
            print(f"{self.nom} lance une boule de feu sur {cible.nom} !")
        else:
            super().attaquer(cible)            # plus de mana : attaque normale de la mère

classDiagram
    Personnage <|-- Heros
    Personnage <|-- Monstre
    Heros <|-- Guerrier
    Heros <|-- Mage
    Heros *-- Inventaire
    class Personnage {
      nom
      pv
      force
      attaquer(cible)
      est_vivant()
    }
    class Mage {
      mana
      attaquer(cible)
    }
    class Guerrier {
      degats()
    }

Polymorphisme : même ordre, réactions différentes

Le code du combat appelle combattant.attaquer(cible) sans savoir s'il a affaire à un guerrier, un mage ou un ogre. Chacun réagit à sa manière. Ajouter une nouvelle classe de héros ne demande donc aucune modification du code du combat.

equipe = [Guerrier("Brom"), Mage("Aria"), Monstre("Ogre", 40, 6)]
for combattant in equipe:
    combattant.attaquer(cible)        # chaque objet utilise SA version de attaquer

class Animal:
    def cri(self):
        return "..."
    def presenter(self):
        return f"Je fais {self.cri()}"

class Chat(Animal):
    def cri(self):
        return "miaou"

class Chaton(Chat):
    pass

for a in [Animal(), Chat(), Chaton()]:
    print(a.presenter())
print(isinstance(Chaton(), Animal))

Je fais ...
Je fais miaou
Je fais miaou
True

Composition : « a un » plutôt que « est un »

Un héros n'est pas un inventaire, il a un inventaire. Dans ce cas, on ne passe pas par l'héritage : on met un objet dans un autre.

class Inventaire:
    def __init__(self, capacite=10):
        self.__objets = []
        self.capacite = capacite

    def ajouter(self, objet):
        if len(self.__objets) >= self.capacite:
            raise ValueError("sac plein")
        self.__objets.append(objet)

    def __contains__(self, objet):
        return objet in self.__objets

    def __len__(self):
        return len(self.__objets)

class Heros(Personnage):
    def __init__(self, nom, pv_max, force):
        super().__init__(nom, pv_max, force)
        self.inventaire = Inventaire()        # composition

aria = Heros("Aria", 60, 7)
aria.inventaire.ajouter("potion")
print("potion" in aria.inventaire, len(aria.inventaire))   # True 1

Défis

random : le hasard maîtrisé

import random

random.randint(1, 20)                       # entier entre 1 et 20 inclus
random.random()                             # flottant dans [0, 1[
random.choice(["rat", "gobelin", "ogre"])   # un élément au hasard
random.sample(range(1, 50), 6)              # 6 éléments distincts (un tirage de loto)
random.shuffle(paquet)                      # mélange une liste sur place
random.choices(["commun", "rare", "légendaire"], weights=[70, 25, 5])[0]   # tirage pondéré
random.seed(42)                             # même graine = même suite de « hasard »

datetime et time : maîtriser le temps

from datetime import datetime, timedelta
import time

maintenant = datetime.now()
print(maintenant.strftime("%d/%m/%Y %H:%M:%S"))      # 03/10/2026 14:05:09
print(f"{maintenant:%Y-%m-%d}")                       # même chose dans une f-string

dans_100_jours = maintenant + timedelta(days=100, hours=10)
fin_quete = datetime.strptime("31/12/2026", "%d/%m/%Y")   # texte -> date
reste = fin_quete - maintenant                         # une timedelta
print(reste.days, "jours restants")

debut = time.perf_counter()
time.sleep(0.5)                                         # pause d'une demi-seconde
print(f"{time.perf_counter() - debut:.2f} s")          # mesurer une durée

collections : des structures sur mesure

from collections import Counter, defaultdict

journal = ["attaque", "attaque", "potion", "attaque", "fuite", "potion"]
stats = Counter(journal)
print(stats)                    # Counter({'attaque': 3, 'potion': 2, 'fuite': 1})
print(stats.most_common(1))     # [('attaque', 3)]
print(Counter("abracadabra").most_common(3))

butin_par_salle = defaultdict(list)   # une clé absente reçoit automatiquement []
butin_par_salle["crypte"].append("épée")      # pas de KeyError

os, pathlib, shutil : fichiers et dossiers

from pathlib import Path
import shutil

dossier = Path("sauvegardes")
dossier.mkdir(exist_ok=True)                    # crée le dossier s'il n'existe pas
fichier = dossier / "partie_1.json"             # l'opérateur / assemble les chemins
print(fichier.exists(), fichier.suffix, fichier.stem)   # False .json partie_1

for chemin in Path(".").glob("*.py"):           # tous les .py du dossier courant
    print(chemin.name, chemin.stat().st_size, "octets")

shutil.copy("partie.json", dossier / "backup.json")   # copier un fichier

Le module plus ancien os fait la même chose avec des fonctions : os.listdir, os.path.exists, os.path.splitext, os.path.join. Tu le croiseras dans beaucoup de code existant.

re : les expressions régulières

Une expression régulière décrit un motif de texte. Elle sert à vérifier, trouver ou extraire des morceaux d'une chaîne.

import re

texte = "Rapport : ID-4521 suspect, ID-12 invalide, ID-9087 confirmé."
print(re.findall(r"ID-\d{4}\b", texte))         # ['ID-4521', 'ID-9087']

m = re.match(r"^(\d+)d(\d+)([+-]\d+)?$", "2d6+3")   # une formule de dés de jeu de rôle
if m:
    nombre, faces, bonus = m.groups()           # ('2', '6', '+3')

print(re.sub(r"\s+", " ", "trop    d'   espaces"))   # remplacer

import re
from collections import Counter
cmd = "prendre 3 potions"
m = re.match(r"(\w+)\s+(\d+)\s+(\w+)", cmd)
print(m.group(1), int(m.group(2)) * 2)
print(Counter(cmd.split()[2]).most_common(1))

prendre 6
[('o', 2)]

Pour aller plus loin : faire plusieurs choses à la fois

Un thread est un fil d'exécution. Plusieurs threads avancent « en même temps » dans le même programme. C'est utile quand on attend quelque chose : une réponse réseau, un fichier, le joueur.

import threading
import time

def horloge(nom, intervalle, nombre):
    for _ in range(nombre):
        time.sleep(intervalle)
        print(nom)

t1 = threading.Thread(target=horloge, args=("Tic", 2, 3))
t2 = threading.Thread(target=horloge, args=("Tac", 3, 2))
t1.start(); t2.start()          # les deux démarrent
t1.join(); t2.join()            # on attend qu'ils aient fini
print("Fin")

Défis

> attaquer gobelin
Tu attaques gobelin : 9 dégâts.
L'ennemi lâche un objet rare : bouclier runique !
> prendre 3 potions
Tu fais l'action « prendre » x3 sur potions.
> fin
Statistiques : [('attaque', 1), ('butin', 1), ('prendre', 1)]
Journal enregistré dans journaux/partie_2026-10-03_14h05.txt

Installer des modules : pip et venv

La bibliothèque standard ne fait pas tout. Plus de 500 000 paquets sont publiés sur PyPI, et on les installe avec pip. Pour ne pas mélanger les dépendances de tous tes projets, chaque projet a son environnement virtuel.

python -m venv .venv                 # crée l'environnement (une seule fois)

.venv\Scripts\activate               # Windows : active-le
source .venv/bin/activate            # macOS / Linux

python -m pip install requests beautifulsoup4
python -m pip freeze > requirements.txt   # note les versions installées
python -m pip install -r requirements.txt # réinstalle tout sur une autre machine

Comment les machines se parlent

TCP ou UDP ?

HTTP : le langage du web

HTTP fonctionne en requête / réponse. Le client envoie une méthode et une adresse, le serveur répond avec un code de statut et un contenu. Chaque requête est indépendante : on dit que HTTP est sans état, d'où les cookies pour se souvenir de toi.

Codes de statut : 2xx succès (200 OK, 201 Created), 3xx redirection, 4xx erreur du client (400, 401, 403, 404 Not Found, 429 trop de requêtes), 5xx erreur du serveur (500).

requests : interroger une API

Une API web est un serveur qui renvoie des données brutes, le plus souvent en JSON, au lieu de pages HTML. Exemple avec l'API gratuite de Donjons & Dragons :

import requests

reponse = requests.get("https://www.dnd5eapi.co/api/2014/monsters/goblin", timeout=5)
print(reponse.status_code)              # 200
gobelin = reponse.json()                # le JSON devient un dict Python
print(gobelin["name"], gobelin["hit_points"], "PV")
print(gobelin["actions"][0]["damage"][0]["damage_dice"])   # '1d6+2' : ta regex du niveau 9 !

# paramètres d'URL : ?challenge_rating=1
r = requests.get("https://www.dnd5eapi.co/api/2014/monsters",
                 params={"challenge_rating": 1}, timeout=5)
noms = [m["name"] for m in r.json()["results"]]

Télécharger un fichier binaire

r = requests.get("https://www.python.org/static/img/python-logo.png", timeout=10)
with open("logo.png", "wb") as f:
    f.write(r.content)        # .content : les octets bruts (.text : le texte décodé)

Le web scraping, avec respect

Quand un site n'a pas d'API, on peut lire son HTML et en extraire les données. C'est le scraping. Avant de commencer :

• Lis les conditions d'utilisation et le fichier /robots.txt du site.
• Espace tes requêtes avec time.sleep(1) : un script trop rapide ressemble à une attaque.
• Identifie-toi avec un en-tête User-Agent honnête.
• Ne collecte pas de données personnelles : le RGPD s'applique. Les contenus restent aussi protégés par le droit d'auteur.

Le site books.toscrape.com a été créé exprès pour s'entraîner :

import requests
from bs4 import BeautifulSoup

page = requests.get("https://books.toscrape.com/", timeout=10)
soupe = BeautifulSoup(page.content, "html.parser")   # .content : BeautifulSoup détecte l'encodage
for livre in soupe.select("article.product_pod")[:5]:
    titre = livre.h3.a["title"]
    prix = livre.select_one(".price_color").text
    print(f"{prix:>8}  {titre}")

Pour les sites qui construisent leur page en JavaScript, il faut piloter un vrai navigateur avec Selenium ou Playwright.

Les sockets : parler directement en TCP

Sous HTTP, il y a TCP. Avec le module socket, tu écris toi-même le client et le serveur.

import socket

with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as serveur:   # SOCK_STREAM = TCP
    serveur.bind(("127.0.0.1", 5000))     # IP et port d'écoute
    serveur.listen()
    print("En attente d'un client…")
    client, adresse = serveur.accept()    # bloque jusqu'à une connexion
    with client:
        while data := client.recv(1024):  # jusqu'à 1024 octets
            client.sendall(data.upper())  # on renvoie en majuscules

import socket

with socket.create_connection(("127.0.0.1", 5000)) as s:
    s.sendall("bonjour la crypte".encode())    # str -> bytes
    print(s.recv(1024).decode())               # bytes -> str : BONJOUR LA CRYPTE

Défis

Un Giant Vulture (22 PV) traverse le portail !
Il utilise Beak (2d4+2) : 10 dégâts.

* Aria pousse la porte de la taverne.
* Brom pousse la porte de la taverne.
[Brom] Une bière pour tout le monde !

Qu'est-ce que Pygame ?

Pygame est une bibliothèque pour créer des jeux 2D : fenêtre, dessin, images, clavier, souris, sons. Elle est simple, multiplateforme et utilisée depuis plus de 20 ans par des milliers de débutants. On l'installe dans un environnement virtuel, comme au niveau 10 :

python -m pip install pygame
python -m pygame.examples.aliens      # un jeu de démonstration pour vérifier l'installation

La boucle de jeu

Tout jeu vidéo est une boucle infinie qui répète trois étapes, des dizaines de fois par seconde :

1. Événements : qu'a fait le joueur ? (touches, souris, fermeture de la fenêtre)
2. Mise à jour : on fait avancer le monde (positions, collisions, score).
3. Dessin : on efface l'écran et on redessine tout.

import pygame

pygame.init()
ecran = pygame.display.set_mode((800, 600))      # largeur, hauteur en pixels
pygame.display.set_caption("Mon jeu")
horloge = pygame.time.Clock()

en_cours = True
while en_cours:
    # 1. Événements
    for evenement in pygame.event.get():
        if evenement.type == pygame.QUIT:        # clic sur la croix
            en_cours = False

    # 2. Mise à jour
    # ...

    # 3. Dessin
    ecran.fill((20, 22, 30))                     # efface avec une couleur de fond
    pygame.draw.circle(ecran, (240, 170, 70), (400, 300), 40)
    pygame.display.flip()                        # affiche l'image qu'on vient de dessiner
    horloge.tick(60)                             # au maximum 60 images par seconde

pygame.quit()

Coordonnées et couleurs

• L'origine (0, 0) est en haut à gauche. x augmente vers la droite, et y augmente vers le bas, à l'inverse des maths.
• Une couleur est un tuple (rouge, vert, bleu), chaque composante allant de 0 à 255. (255, 0, 0) est rouge, (0, 0, 0) noir, (255, 255, 255) blanc.

pygame.draw.rect(ecran, (60, 64, 82), (x, y, largeur, hauteur))      # rectangle plein
pygame.draw.rect(ecran, (0, 0, 0), (x, y, largeur, hauteur), 2)      # contour de 2 px
pygame.draw.circle(ecran, couleur, (cx, cy), rayon)
pygame.draw.line(ecran, couleur, (x1, y1), (x2, y2), epaisseur)
pygame.draw.polygon(ecran, couleur, [(10, 0), (20, 10), (10, 20), (0, 10)])   # un losange

Images par seconde

horloge.tick(60) fait patienter la boucle pour ne pas dépasser 60 tours par seconde. Sans ça, ton jeu tournerait à 2000 FPS sur un PC puissant et à 40 sur un vieux portable : un personnage qui avance de 3 pixels par tour n'irait pas à la même vitesse partout.

Défis

TUILE = 48
CARTE = [
    "############",
    "#..........#",
    "#.###..###.#",
    "#..........#",
    "#.#..##..#.#",
    "#..........#",
    "############",
]
LARGEUR, HAUTEUR = len(CARTE[0]) * TUILE, len(CARTE) * TUILE
COULEURS = {"#": (60, 64, 82), ".": (28, 30, 40)}

# dans la boucle, partie Dessin :
for l, ligne in enumerate(CARTE):
    for c, case in enumerate(ligne):
        rect = pygame.Rect(c * TUILE, l * TUILE, TUILE, TUILE)
        pygame.draw.rect(ecran, COULEURS[case], rect)
        pygame.draw.rect(ecran, (0, 0, 0), rect, 1)

Deux façons de lire le clavier

for evenement in pygame.event.get():
    if evenement.type == pygame.KEYDOWN and evenement.key == pygame.K_SPACE:
        print("Saut !")                         # une seule fois par appui

touches = pygame.key.get_pressed()              # l'état de TOUT le clavier
if touches[pygame.K_LEFT]:
    x -= vitesse                                # à chaque image

La souris

for evenement in pygame.event.get():
    if evenement.type == pygame.MOUSEBUTTONDOWN and evenement.button == 1:   # clic gauche
        torches.append(evenement.pos)            # (x, y) du clic

x, y = pygame.mouse.get_pos()                   # position actuelle

Surface et Rect : les deux briques de Pygame

• Une Surface est une image : la fenêtre en est une, chaque sprite aussi.
• Un Rect est un rectangle : position et taille. Il a des attributs très pratiques comme x, y, center, top, bottom, left, right ou topleft.

image = pygame.Surface((32, 32), pygame.SRCALPHA)      # SRCALPHA : fond transparent
pygame.draw.circle(image, (240, 170, 70), (16, 16), 15)
rect = image.get_rect(center=(400, 300))                # un Rect de la taille de l'image
rect.x += 5                                             # on déplace le rectangle
ecran.blit(image, rect)                                 # on colle l'image à cet endroit

La classe Sprite

Ton niveau 8 sert enfin à quelque chose de visible ! Un sprite est un objet du jeu qui hérite de pygame.sprite.Sprite et possède deux attributs obligatoires : image et rect.

class Heros(pygame.sprite.Sprite):
    def __init__(self, x, y):
        super().__init__()
        self.image = pygame.Surface((32, 32), pygame.SRCALPHA)
        pygame.draw.circle(self.image, (240, 170, 70), (16, 16), 15)
        self.rect = self.image.get_rect(center=(x, y))
        self.vitesse = 4

    def update(self, touches):
        if touches[pygame.K_LEFT] or touches[pygame.K_q]:
            self.rect.x -= self.vitesse
        if touches[pygame.K_RIGHT] or touches[pygame.K_d]:
            self.rect.x += self.vitesse
        if touches[pygame.K_UP] or touches[pygame.K_z]:
            self.rect.y -= self.vitesse
        if touches[pygame.K_DOWN] or touches[pygame.K_s]:
            self.rect.y += self.vitesse
        self.rect.clamp_ip(ecran.get_rect())      # reste à l'intérieur de l'écran

Charger une vraie image

image = pygame.image.load("images/heros.png").convert_alpha()   # convert_alpha : rapide + transparence
image = pygame.transform.scale(image, (48, 48))
image_gauche = pygame.transform.flip(image, True, False)          # miroir horizontal

Défis

Les groupes de sprites

Un pygame.sprite.Group est un ensemble de sprites. On peut tous les mettre à jour, tous les dessiner, et tester les collisions avec eux, en une seule ligne.

murs = pygame.sprite.Group()
gemmes = pygame.sprite.Group()
for l, ligne in enumerate(CARTE):
    for c, case in enumerate(ligne):
        if case == "#":
            murs.add(Mur(c * TUILE, l * TUILE))
        elif case == "G":
            gemmes.add(Gemme(c * TUILE + 24, l * TUILE + 24))

gemmes.update(temps)        # appelle update(temps) sur chaque gemme
murs.draw(ecran)            # blit de chaque image à son rect

Détecter les collisions

ramassees = pygame.sprite.spritecollide(heros, gemmes, dokill=True)
score += 10 * len(ramassees)

if pygame.sprite.spritecollideany(heros, slimes):
    vies -= 1

Glisser le long des murs

Si on déplace le héros en diagonale puis qu'on annule tout le mouvement dès qu'il touche un mur, il reste collé. L'astuce : bouger un axe à la fois, et après chaque axe, recaler le héros contre le mur touché.

def deplacer(self, dx, dy, murs):
    self.rect.x += dx * self.vitesse
    for mur in pygame.sprite.spritecollide(self, murs, False):
        if dx > 0:                       # on allait à droite : on se cale à gauche du mur
            self.rect.right = mur.rect.left
        elif dx < 0:
            self.rect.left = mur.rect.right
    self.rect.y += dy * self.vitesse
    for mur in pygame.sprite.spritecollide(self, murs, False):
        if dy > 0:
            self.rect.bottom = mur.rect.top
        elif dy < 0:
            self.rect.top = mur.rect.bottom

Avec dx = touches[K_RIGHT] - touches[K_LEFT], on obtient -1, 0 ou 1 : un booléen vaut 1 quand il est vrai et 0 quand il est faux.

Animer

Avec le temps et les maths

pygame.time.get_ticks() donne le nombre de millisecondes écoulées depuis le lancement. Avec un sinus, on obtient une oscillation douce, parfaite pour une gemme qui flotte ou un slime qui respire.

temps = pygame.time.get_ticks() / 1000                         # en secondes
self.rect.centery = self.base_y + math.sin(temps * 4) * 4      # oscille de ±4 pixels

Avec une planche de sprites

Une animation dessinée, c'est une suite d'images posées côte à côte sur une seule « planche ». On en découpe une à la fois avec subsurface et on change d'image toutes les N millisecondes.

planche = pygame.image.load("heros_marche.png").convert_alpha()   # 4 images de 32x32 côte à côte
images = [planche.subsurface((i * 32, 0, 32, 32)) for i in range(4)]

indice = (pygame.time.get_ticks() // 120) % len(images)   # une nouvelle image toutes les 120 ms
self.image = images[indice]

Défis

Les sons

pygame.mixer.init()
son_gemme = pygame.mixer.Sound("sons/gemme.wav")     # effet court, en mémoire
son_gemme.play()

pygame.mixer.music.load("musique.ogg")               # musique, lue en continu depuis le disque
pygame.mixer.music.set_volume(0.4)
pygame.mixer.music.play(-1)                          # -1 : en boucle

Fabriquer ses propres sons, sans rien installer

Un son est une suite de nombres qui décrivent une onde. Avec le module standard wave, tu peux écrire un fichier .wav toi-même :

import math, struct, wave

FREQ = 22050                                   # échantillons par seconde

def bip(f_debut, f_fin, duree):
    n = int(FREQ * duree)
    for i in range(n):
        f = f_debut + (f_fin - f_debut) * i / n          # la note glisse
        onde = 1 if math.sin(2 * math.pi * f * i / FREQ) > 0 else -1   # onde carrée : son « 8 bits »
        yield onde * (1 - i / n) * 0.5                   # le volume décroît

with wave.open("sons/gemme.wav", "wb") as f:
    f.setnchannels(1); f.setsampwidth(2); f.setframerate(FREQ)
    f.writeframes(b"".join(struct.pack("<h", int(e * 20000)) for e in bip(880, 1760, 0.12)))

Afficher du texte

police = pygame.font.Font(None, 32)                      # None : police par défaut
texte = police.render(f"Score {score}", True, (235, 235, 245))   # True : lissage
ecran.blit(texte, texte.get_rect(center=(LARGEUR // 2, 20)))

Vies et invincibilité temporaire

Sans protection, un slime touché enlève une vie à chaque image : 60 vies par seconde ! Après un coup, le héros devient invincible pendant 1,5 s et clignote.

maintenant = pygame.time.get_ticks()
if maintenant >= heros.invincible_jusqua and pygame.sprite.spritecollideany(heros, slimes):
    vies -= 1
    heros.invincible_jusqua = maintenant + 1500

# clignotement : une image sur deux toutes les 100 ms
visible = maintenant >= heros.invincible_jusqua or (maintenant // 100) % 2 == 0

La machine à états

Ton jeu passe par plusieurs écrans : menu, jeu, fin. Une variable etat indique l'écran actif. La boucle de jeu ne met à jour et ne dessine que ce qui le concerne.

stateDiagram-v2
    [*] --> menu
    menu --> jeu : Entrée
    jeu --> jeu : toutes les gemmes ramassées / niveau suivant
    jeu --> fin : plus de vies
    fin --> jeu : Entrée
    fin --> [*] : Échap

class Jeu:
    def __init__(self):
        # init de Pygame, fenêtre, polices, sons, record
        self.etat = "menu"

    def nouvelle_partie(self): ...        # score 0, 3 vies, niveau 0, etat = "jeu"
    def charger_niveau(self): ...         # construit les groupes depuis NIVEAUX[self.niveau]
    def mettre_a_jour(self): ...          # déplacements, collisions, score, changement d'état
    def dessiner(self): ...               # selon self.etat : menu, jeu ou fin

    def lancer(self):
        while True:
            for evenement in pygame.event.get():
                if evenement.type == pygame.QUIT:
                    pygame.quit()
                    return
                if evenement.type == pygame.KEYDOWN and evenement.key == pygame.K_RETURN and self.etat != "jeu":
                    self.nouvelle_partie()
            if self.etat == "jeu":
                self.mettre_a_jour()
            self.dessiner()
            self.horloge.tick(60)

if __name__ == "__main__":
    Jeu().lancer()

Le record, gravé dans un fichier

def lire_record():
    try:
        with open("record.json", encoding="utf-8") as f:
            return json.load(f)["record"]
    except (FileNotFoundError, KeyError, json.JSONDecodeError):
        return 0

Fichiers (niveau 6), exceptions (niveau 7), classes (niveau 8), structures de données (niveau 5) : ton jeu d'arcade utilise tout ce que tu as appris.

Défis

Choisis ta quête

Les étapes du projet

Le barème (20 points)

Les décorateurs : enchanter une fonction

En Python, une fonction est une valeur comme une autre : on peut la passer en paramètre et en renvoyer une. Un décorateur est une fonction qui prend une fonction et renvoie une version améliorée de celle-ci.

from datetime import datetime
from functools import wraps

def journaliser(fonction):
    @wraps(fonction)                        # conserve le nom et la docstring d'origine
    def enveloppe(*args, **kwargs):         # accepte n'importe quels arguments
        print(f"[LOG] {fonction.__name__} appelée à {datetime.now():%H:%M:%S}")
        resultat = fonction(*args, **kwargs)
        return resultat
    return enveloppe

@journaliser                                # équivaut à : soigner = journaliser(soigner)
def soigner(pv, quantite):
    return pv + quantite

soigner(40, 25)     # [LOG] soigner appelée à 14:05:09  -> 65

Un décorateur avec un argument

Il faut un étage de plus : une fonction qui reçoit l'argument et fabrique le décorateur.

import time

def chronometrer(seuil=0.5):
    def decorateur(fonction):
        @wraps(fonction)
        def enveloppe(*args, **kwargs):
            debut = time.perf_counter()
            resultat = fonction(*args, **kwargs)
            duree = time.perf_counter() - debut
            if duree > seuil:
                print(f"[WARNING] {fonction.__name__} : {duree:.2f} s")
            return resultat
        return enveloppe
    return decorateur

@chronometrer(seuil=0.1)
def requete_lente():
    time.sleep(0.3)

@classmethod : un constructeur alternatif

class Monstre:
    def __init__(self, nom, pv):
        self.nom, self.pv = nom, pv

    @classmethod
    def depuis_json(cls, data):             # cls = la classe elle-même
        return cls(data["name"], data["hit_points"])

ogre = Monstre.depuis_json({"name": "Ogre", "hit_points": 59})

Ton propre with

Une classe qui définit __enter__ et __exit__ s'utilise avec with. __exit__ est toujours appelée, même en cas d'exception.

import csv

class Rapport:
    def __init__(self, chemin):
        self.chemin = chemin

    def __enter__(self):
        self.fichier = open(self.chemin, "a", newline="", encoding="utf-8")
        self.ecrivain = csv.writer(self.fichier, delimiter=";")
        return self                          # c'est ce que reçoit « as r »

    def ecrire(self, *valeurs):
        self.ecrivain.writerow(valeurs)

    def __exit__(self, type_exc, exc, trace):
        self.fichier.close()
        return False                         # False : on laisse remonter l'éventuelle exception

with Rapport("alertes.csv") as r:
    r.ecrire("BTC", 84642.01, "CRITICAL")

Lancer plusieurs requêtes en parallèle

from concurrent.futures import ThreadPoolExecutor

symboles = ["BTCUSDT", "ETHUSDT", "SOLUSDT"]
with ThreadPoolExecutor(max_workers=5) as pool:
    resultats = list(pool.map(recuperer_prix, symboles))   # même ordre que symboles

Trois requêtes de 300 ms chacune prennent environ 900 ms à la suite, et environ 300 ms en parallèle.

Les secrets dans un fichier .env

API_KEY=ma-cle-secrete-de-test

import os
from dotenv import load_dotenv        # python -m pip install python-dotenv

load_dotenv()
API_KEY = os.getenv("API_KEY")
if API_KEY is None:
    raise RuntimeError("API_KEY manquante : crée un fichier .env")