Aujourd'hui

1. Le cours : où nous allons, comment il est noté (15 min)
2. Vos machines : uv, et un dépôt GitHub pour vos TP (55 min)
3. Quand ? : comment tourne une boucle de jeu (15 min)
4. Le TP T1 : un Snake jouable, écrit par vous (le reste, avec une pause)

À la fin de la séance, vous saurez créer et lancer un projet avec uv, et vous saurez dire à quel moment s'exécute chaque partie de votre code.

Le cours en une phrase

Nous allons partir d'un jeu, un Snake, et remonter peu à peu vers le fonctionnement du langage lui-même, jusqu'à écrire en S7 un petit interpréteur.

Vous savez déjà écrire du Python qui marche. L'idée ici est de comprendre pourquoi il marche : ce que fait une classe, ce qu'est une fonction, ce que vérifie un type, et ce qui se passe quand on tape import.

Le parcours : du jeu au langage

Chaque séance : ce qu'on construit, ce qu'on y comprend du langage, et une question « Quand ? », où l'on sépare décrire et exécuter.

Le tournoi de bots

En S3, votre Snake devient un bot : une fonction qui reçoit l'état du plateau et renvoie un coup.

• lancement du tournoi en S3, avec un premier bot (parcours en largeur) ;
• vous l'améliorez au fil des séances, quand vous voulez ;
• finale en S9.

Le Snake d'aujourd'hui est donc la première brique : soignez-le.

La notation

• Quiz Q3 à Q9, sur papier, 10 minutes en début de séance, sur la séance précédente. Le numéro est celui de la séance : le premier, Q3, ouvre la séance 3 et porte sur S1 et S2.
• TP maison, de T2 à T8, alternativement en binôme et en individuel. Rendus dans votre dépôt python-homework, la veille de la séance suivante à 23 h 59.
• Checkoffs à partir de S2, pendant le TP en classe : trois personnes tirées au sort viennent chacune 3 minutes m'expliquer leur dernier TP. Non noté : c'est validé, ou on réexplique à la séance suivante.

Aujourd'hui : pas de quiz, et le TP T1 se fait en séance, sans rendu.

Et l'IA ?

L'IA est tolérée, comme un outil pour comprendre : vous expliquer une erreur, une notion, un bout de doc, ou vous proposer une piste quand vous êtes bloqués.

Une seule règle, pour tout le cours :

• la complétion automatique (Copilot ou autre) écrit à votre place : coupez-la dans VS Code ;
• chaque ligne de votre code doit pouvoir s'expliquer, et c'est précisément ce que vérifient les checkoffs.

Une séance type

Pendant le TP, je reprends la main à quelques points d'arrêt, et je fais passer les checkoffs. La clôture : ce qu'il faut retenir, et la présentation du TP maison.

Avant chaque séance : une courte préparation, indiquée sur la page de la séance, et deux questions à me poser depuis le site.

Ce qui s'est passé

AttributeError: `np.float_` was removed in the NumPy 2.0 release.

Il n'y a qu'un numpy dans un environnement : en installant celui du projet B, nous avons cassé le projet A, sans même y toucher.

La solution : un environnement par projet

• conda sait le faire, mais il est lent, lourd, et il s'invite dans votre terminal (le fameux (base)) ;
• uv crée un environnement par projet (le dossier .venv), installe même la bonne version de Python, en quelques secondes.

Si conda vous gêne encore : https://python.mines.prasquier.dev/setup/

Les mêmes projets avec uv

uv init --bare --python 3.12 a && cd a     # numpy 1 n'existe pas pour les Python récents
uv add "numpy<2" && uv run projet_a.py     # projet A, numpy 1.26.4 : 3.14
cd .. && uv init --bare b && cd b
uv add "numpy>=2" && uv run projet_b.py    # projet B, numpy 2.5.4 : SNAKE
cd ../a && uv run projet_a.py              # projet A, numpy 1.26.4 : 3.14

Cette fois, les deux projets cohabitent : chacun a son .venv, et son pyproject.toml garde la trace de ce dont il a besoin.

Trois commandes suffisent

uv init demo          # crée un projet : pyproject.toml, main.py
cd demo
uv add rich           # ajoute une bibliothèque au projet
uv run main.py        # lance le programme dans l'environnement du projet

• uv add met à jour pyproject.toml et uv.lock, et installe dans .venv/ ;
• uv run vérifie d'abord que .venv/ est à jour, puis lance ;
• vous n'« activez » jamais rien à la main.

Ce qu'il y a dans un projet uv

Les outils du cours sont aussi des dépendances du projet : pytest (les tests) et ruff (le style). On les lance avec uv run pytest et uv run ruff check .

Vos TP : le dépôt python-homework

Un seul dépôt GitHub pour tout le cours, un dossier par TP :

python-homework/
├── T1/      ← le zip du TP, dézippé ici
├── T2/
└── ...

La procédure complète : https://python.mines.prasquier.dev/rendre/

Point d'arrêt : uv --version répond, et votre dépôt est cloné.

T1, étape 0

cd python-homework/T1
uv add pygame-ce
uv run snake.py
uv run pytest

On installe pygame-ce, mais on écrit import pygame.

Point d'arrêt : une fenêtre qui change de couleur, et 1 test vert.

uv : ce qu'il faut retenir

Un jeu, c'est une boucle

while running:
    clock.tick(6)

    for event in pg.event.get():
        ...

    move(snake, direction, fruit)

    draw(screen, snake, fruit)
    pg.display.update()

Chaque tour de boucle produit une image : tout le jeu tient dans ces trois temps, plus une attente.

Quand l'écran change-t-il ?

Les fonctions de dessin travaillent sur une image en mémoire : rien n'apparaît à l'écran tant que pg.display.update() ne l'y a pas envoyée. Comme c'est lent, on l'appelle une fois par tour.

Et clock.tick(6) ? Il attend juste ce qu'il faut pour que le tour dure 1/6 de seconde. C'est lui qui fixe la vitesse du jeu.

Quand une touche est-elle prise en compte ?

pygame range l'événement dans une file d'attente ; votre code ne le voit qu'au tour suivant, quand il appelle pg.event.get().

Un demi-tour en deux temps

Chaque appel à turn est correct : ↑ est permis quand on va à droite, ← est permis quand on va en haut. Mais le serpent n'a pas bougé entre les deux, et le voilà qui repart sur son propre corps.

Le souci ne vient pas d'une ligne fausse, mais du moment où la direction change. Pouvez-vous le corriger ? (bonus du T1)

Quand le fichier s'exécute-t-il ?

# snake.py
print("A")          # à l'import

def main():         # à l'import : on DÉFINIT
    print("B")      # seulement à l'APPEL

print("C")          # à l'import

if __name__ == "__main__":
    main()

Python exécute tout le fichier, de haut en bas, au moment de l'import. Un def décrit, il n'exécute pas. C'est pourquoi la boucle de jeu vit dans main().

Qui décide quand ?

Aujourd'hui, c'est notre boucle while qui décide de tout. Jeudi, avec arcade, c'est arcade qui aura la boucle, et qui appellera nos fonctions.

« Quand ? » n° 1 : ce qu'il faut retenir

Ces trois points reviendront dans le quiz Q3.

T1 : les étapes

Étape	Quoi
1	lire la boucle (questions)
2	quitter avec q ou la croix
3	le damier
4	un serpent immobile
5	il avance : in_scope, next_head, move
6	les flèches : turn
7	le fruit : random_fruit
8	fin de partie, score

Un commit par étape qui marche. Les tests passent au vert au fur et à mesure.

Pour finir

uv run pytest          # tout vert
uv run ruff check .    # aucune remarque
git add T1 && git commit -m "T1 : étape 8" && git push

Pas de TP maison ni de quiz pour jeudi. Si vous n'avez pas fini, les étapes 7 et 8 se font tranquillement chez vous, sans obligation.

Jeudi 29 octobre, 9 h, salle L107 : les objets, avec une nuée d'oiseaux. Le premier quiz, Q3, ouvrira la séance 3 et portera sur S1 et S2.

Pour ceux qui avancent vite

• corriger le demi-tour en deux temps (indice : comparer à la direction du début du tour) ;
• les bonus de l'énoncé : pause, accélération, deux fréquences, argparse, plateau sans bord, meilleur score ;
• un serpent qui joue tout seul : une fonction auto(snake, fruit) qui renvoie une direction vers le fruit, sans se mordre.

Ce dernier point vous donnera une longueur d'avance pour le tournoi…