Vous souhaitez écrire votre premier jeu mais vous ne savez pas par où commencer avec le développement de jeux? Pygame supprime cet obstacle. Vous codez en pur Python et voyez immédiatement le résultat à l'écran: un sprite qui se déplace, une réponse aux touches du clavier, des mécaniques vivantes. Pas de moteur lourd, pas de milliers de lignes de code standard.

Le problème avec la plupart des tutoriels, c'est qu'ils vous noient sous 40 pages de théorie ou vous laissent avec un «finissez-le vous-même». Ici, nous allons prendre une voie médiane: expliquer juste assez pour que vous compreniez chaque ligne, et construire immédiatement un jeu fonctionnel avec un personnage qui se déplace à l'écran avec les touches ZQSD. L'ensemble du code tient en 60 lignes.

💡 Aperçu rapide:

• Installez Pygame via pip et créez un fichier de jeu, cela prend quelques minutes
• Comprenez la boucle de jeu: événements, calculs, rendu, trois phases qui vivent dans un while True infini
• Écrivez une classe joueur et donnez-lui vie: les touches ZQSD déplacent le sprite, l'écran se redessine 60 fois par seconde
• Comprenez le système de coordonnées et la gestion des couleurs, deux piliers qui soutiennent tout graphisme 2D

Qu'est-ce que Pygame et pourquoi le choisir

Pygame est une bibliothèque pour Python qui enveloppe la couche multimédia SDL (Simple DirectMedia Layer) dans une API Python pratique. SDL gère le travail de bas niveau sur les graphismes, le son et les périphériques d'entrée, tandis que Pygame y donne accès via des classes et des méthodes familières. La version actuelle, 2.6.0, est activement maintenue et fonctionne sur Windows, macOS et Linux.

Pour les débutants, Pygame présente trois avantages indéniables. Premièrement, une barrière à l'entrée faible: vous utilisez du code Python ordinaire, pas de nouveau langage ni d'éditeur visuel. Deuxièmement, un retour visuel instantané: vous écrivez pygame.draw.rect(...) et un rectangle apparaît à l'écran, sans magie. Troisièmement, la compréhension des fondations: Pygame ne vous cache pas la boucle de jeu et la file d'événements, vous voyez comment tout jeu fonctionne de l'intérieur. Après Pygame, passer à Godot ou Unity sera plus facile car vous savez déjà ce que sont le delta time et le polling d'événements.

La bibliothèque ne cherche pas à être un moteur de jeu. Elle n'a pas de système de scène, de physique ni d'éditeur de niveaux intégré, et c'est un choix délibéré. Vous contrôlez chaque pixel et chaque tick, ce qui signifie que vous apprenez à penser comme un développeur de jeux, pas comme un opérateur de l'outil de quelqu'un d'autre.

Installer Pygame en deux minutes

Vous avez déjà Python 3.9 ou plus récent? Alors ouvrez un terminal et exécutez une commande:

1
pip install pygame

Pour l'isolation du projet, il est préférable de créer un environnement virtuel:

1
python -m venv game_env
2
game_env\Scripts\activate     # Windows
3
source game_env/bin/activate  # macOS / Linux
4
pip install pygame

Vérifiez que la bibliothèque est installée:

1
import pygame
2
print(pygame.version.ver)

Si vous obtenez 2.6.0 en réponse (ou plus récent, vous pouvez vérifier la version actuelle sur pygame.org), vous êtes prêt. Créez un dossier de projet, placez-y une image de sprite de 80×80 pixels nommée player.png, et un fichier texte game.py, nous allons commencer avec cela.

Comment fonctionne la boucle de jeu: événements, calculs, rendu

Le cœur de tout jeu est la boucle principale. Tant que le jeu tourne, à l'intérieur d'un while True infini, trois phases alternent:

• Traitement des événements, que s'est-il passé depuis la dernière frame? Une touche pressée? La souris déplacée? La fenêtre fermée? Pygame collecte tous les événements dans une file, et nous la parcourons avec for event in pygame.event.get().

• Calcul de la logique, comment le monde a-t-il changé en réponse aux événements? Le joueur a pressé Z, augmenter la coordonnée Y. La balle est entrée en collision avec un astéroïde, marquer les deux pour suppression.

• Rendu, dessinez tout ce qui doit être à l'écran. Remplissez l'arrière-plan, placez les sprites aux nouvelles coordonnées, appelez pygame.display.update(), et le joueur voit une frame.

Ces trois étapes se répètent 60 fois par seconde, exactement la fréquence d'images (FPS) que nous fixerons sur le minuteur. L'illusion de mouvement repose sur le déplacement du sprite de quelques pixels entre les frames, tandis que l'œil perçoit cela comme une animation continue.

Écrire le premier code: déplacer un sprite à l'écran

Voici le code complet du jeu. Sauvegardez-le sous game.py et placez player.png dans le même dossier:

1
#!/usr/bin/env python3
2
 
3
import pygame
4
import sys
5
 
6
WIDTH, HEIGHT = 360, 480
7
WHITE = (255, 255, 255)
8
 
9
class Player(pygame.sprite.Sprite):
10
 
11
    def __init__(self, image_path):
12
        super().__init__()
13
        self.image = pygame.image.load(image_path)
14
        self.x = WIDTH / 2
15
        self.y = HEIGHT / 2
16
        self.speed = 5
17
 
18
    def move(self, dx, dy):
19
        self.x += dx
20
        self.y += dy
21
 
22
def main():
23
    pygame.init()
24
    screen = pygame.display.set_mode((WIDTH, HEIGHT))
25
    pygame.display.set_caption("First Game on Pygame")
26
 
27
    clock = pygame.time.Clock()
28
    fps = 60
29
 
30
    player = Player("player.png")
31
    dx, dy = 0, 0
32
 
33
    running = True
34
    while running:
35
        for event in pygame.event.get():
36
            if event.type == pygame.QUIT:
37
                running = False
38
 
39
            elif event.type == pygame.KEYDOWN:
40
                if event.key == pygame.K_d:
41
                    dx = player.speed
42
                elif event.key == pygame.K_a:
43
                    dx = -player.speed
44
                elif event.key == pygame.K_w:
45
                    dy = -player.speed
46
                elif event.key == pygame.K_s:
47
                    dy = player.speed
48
 
49
            elif event.type == pygame.KEYUP:
50
                if event.key in (pygame.K_d, pygame.K_a):
51
                    dx = 0
52
                elif event.key in (pygame.K_w, pygame.K_s):
53
                    dy = 0
54
 
55
        player.move(dx, dy)
56
        screen.fill(WHITE)
57
        screen.blit(player.image, (player.x, player.y))
58
        pygame.display.update()
59
        clock.tick(fps)
60
 
61
    pygame.quit()
62
    sys.exit()
63
 
64
if __name__ == "__main__":
65
    main()

Exécutez python game.py, une fenêtre avec un fond blanc et votre sprite au centre s'ouvrira. Maintenez Z, Q, S ou D, le personnage se déplace. Relâchez, il s'arrête. C'est déjà un vrai jeu, bien que minimal.

Ce qui est amélioré par rapport aux tutoriels classiques: le gestionnaire KEYUP est ajouté pour le relâchement des touches. Sans lui, le sprite continuerait à l'infini hors de l'écran après la première pression. Et le code est enveloppé dans la construction if __name__ == "__main__", une bonne pratique qui permet d'importer le fichier comme un module sans lancer le jeu.

Système de coordonnées et gestion des couleurs

Dans Pygame, les coordonnées sont comptées depuis le coin supérieur gauche: (0, 0), tout en haut à gauche. Se déplacer vers la droite augmente X, se déplacer vers le bas augmente Y. Cela diffère du système de coordonnées scolaire où Y croît vers le haut, retenez-le simplement et vérifiez par vous-même lors des deux premières exécutions: vous pressez S, le sprite descend, vous pressez Z, il monte.

La couleur est spécifiée par un tuple de trois nombres (R, G, B), chacun de 0 à 255. Le blanc correspond à (255, 255, 255), le noir à (0, 0, 0), le rouge à (255, 0, 0). La méthode screen.fill(WHITE) remplit tout l'écran avec la couleur choisie avant de dessiner chaque frame. Si vous ne le faites pas, le sprite laissera une traînée de ses positions précédentes.

Ce qui se passe sous le capot: décryptage ligne par ligne

La classe Player hérite de pygame.sprite.Sprite, la classe intégrée de Pygame pour les objets de jeu. Dans le constructeur, nous chargeons l'image via pygame.image.load() et définissons la position de départ au centre de l'écran: WIDTH / 2 et HEIGHT / 2. La méthode move(dx, dy) reçoit le déplacement et l'ajoute aux coordonnées actuelles, de l'arithmétique pure, sans magie.

La fonction main() rassemble le tout. pygame.init() démarre les sous-systèmes internes. pygame.display.set_mode() crée une fenêtre, et screen est une Surface sur laquelle nous dessinons. pygame.time.Clock() crée un minuteur: sa méthode tick(fps) à la fin de la boucle dit à Pygame «attends que 1/60 de seconde se soit écoulé depuis la dernière frame», c'est ainsi que nous fixons la fréquence d'images et ne gaspillons pas le CPU.

La boucle principale while running tourne jusqu'à ce que le drapeau running devienne False. À l'intérieur, les trois phases dont nous avons parlé ci-dessus:

Dans la boucle for event in pygame.event.get(), nous interrogeons la file d'événements. pygame.QUIT est le signal «l'utilisateur a cliqué sur le bouton de fermeture de la fenêtre»: mettez running = False, et à l'itération suivante la boucle se terminera. pygame.KEYDOWN se déclenche quand une touche est pressée, et KEYUP quand elle est relâchée. Pour D et Q nous changeons dx, pour Z et S nous changeons dy. Quand la touche est relâchée, nous mettons à zéro la composante de vitesse correspondante, le sprite s'arrête.

screen.blit(player.image, (player.x, player.y)), la méthode qui «superpose» une image sur une autre. Dans notre cas, le sprite du joueur sur la surface de l'écran principal aux coordonnées actuelles. pygame.display.update() rafraîchit la fenêtre, et le joueur voit la frame terminée.

Note: player.move() est appelé avant screen.fill(). Si vous les inversez, le sprite sera effacé à la même milliseconde où il apparaît, vous ne le verrez tout simplement pas à l'écran. L'ordre des opérations dans la boucle de jeu est critique.

Cliquez sur le bouton de fermeture, pygame.quit() décharge correctement les sous-systèmes Pygame, et sys.exit() termine le processus Python. Sans pygame.quit(), la fenêtre peut se figer à la fermeture, un petit détail, mais le code doit être propre.

Courte vidéo sur le sujet

Si l'instruction textuelle ne fait pas tout à fait tilt, voici un excellent cours vidéo en anglais où ils construisent Space Invaders sur Pygame étape par étape. Tous les concepts de l'article sont montrés en direct:

⁉️🤔 Foire aux questions

Dois-je connaître la POO pour Pygame?

Oui, à un niveau de base. Classes, méthodes, héritage et self vous seront nécessaires dès le premier jour: le joueur, les ennemis, les balles et les bonus s'intègrent naturellement dans un modèle objet. Si vous avez suivi un cours d'introduction à Python qui expliquait class et __init__, c'est suffisant. Vous apprendrez le reste en cours de route: Pygame n'exige pas de design patterns, l'héritage ordinaire de Sprite suffit pour des dizaines de prototypes. Un objet de jeu dans Pygame est une classe héritée de pygame.sprite.Sprite. Dans le constructeur, vous chargez le sprite via pygame.image.load(), définissez les coordonnées initiales et la vitesse. La méthode update() (ou la vôtre, comme move()) change la position à chaque frame. La boucle principale appelle update() sur tous les objets, puis les affiche via screen.blit(). Pas de magie, juste des appels de méthodes dans le bon ordre 60 fois par seconde.

Pygame ralentit-il sur des graphismes 2D complexes?

Avec un nombre raisonnable de sprites, non. Les Surfaces dans Pygame vivent en RAM, et blit est une copie rapide de pixels, pas un rendu logiciel. Avec un millier d'objets se déplaçant simultanément, vous pourriez atteindre la limite de performance de Python, mais pour un jeu de plateforme, un shooter vue de dessus ou un tower defense, il y a de la marge. Si vous avez besoin d'extraire le maximum de performances, utilisez pygame.sprite.Group avec le rendu automatique et les dirty rectangles pour des mises à jour partielles de l'écran.

Puis-je ajouter du son et de la musique dans Pygame?

Oui, de manière native. Le module pygame.mixer peut lire des WAV et des MP3. Un son de tir est lancé via pygame.mixer.Sound("shoot.wav").play(), et la musique de fond est chargée via pygame.mixer.music.load("theme.mp3") et pygame.mixer.music.play(-1) (le drapeau -1 la met en boucle). La seule subtilité: pygame.mixer.init() doit être appelé avant de charger les sons, et pour le MP3 sous Linux, vous pourriez avoir besoin de la bibliothèque libmpg123.

Est-ce utile d'apprendre Pygame en 2026 alors qu'il y a Godot et Unity?

Absolument. Pygame n'est pas un concurrent de Godot, c'est un outil éducatif et une couche légère pour les prototypes 2D. Vous n'apprenez pas le C# juste pour déplacer un carré, et vous ne vous débattez pas avec le système de nœuds pour un Pong. Pygame vous donne une compréhension du fonctionnement des jeux à un niveau plus bas: boucle de jeu, buffering de frame, collisions. Les programmeurs qui ont commencé par Pygame ont plus de facilité avec Unity et Godot parce qu'ils voient les mécaniques vivantes derrière les abstractions du moteur. De vrais projets indépendants sont écrits en Pygame, y compris des projets commerciaux, un petit jeu de plateforme ou un puzzle peut sortir sur Steam sans toucher au C++.

Que faire si le sprite sort de l'écran?

Ajoutez une vérification des limites à la méthode move(): si self.x < 0, mettez-le à 0; si self.x + sprite_width > WIDTH, mettez-le à WIDTH - sprite_width. Même chose pour Y. Cela s'appelle le clamping, et sans cela, le personnage finira par voyager dans une zone invisible. Dans les jeux plus avancés, les limites sont des murs de niveau définis via une grille de tuiles ou un tableau de collisions.

Prêt à lancer votre premier jeu?

Copiez le code de la section «Écrire le premier code», sauvegardez-le sous game.py, placez n'importe quelle image de sprite à côté, et en quelques secondes vous verrez une fenêtre avec un personnage en mouvement. C'est le point d'entrée dans le développement de jeux: ne pas lire, mais lancer et commencer à modifier les paramètres.

Changez WIDTH et HEIGHT, la fenêtre s'agrandira. Mettez player.speed = 10, le personnage accélérera. Remplacez WHITE par (35, 35, 35), vous obtiendrez un fond sombre. Expérimentez, et vous comprendrez qu'un programme de jeu n'est pas de la magie, mais une séquence d'étapes que vous contrôlez.

Une fois le déplacement maîtrisé, attaquez-vous aux collisions (pygame.sprite.collide_rect()), à l'animation (changement de frame de la feuille de sprite) et à la génération procédurale de niveaux. Pour commencer, un fichier game.py et l'envie de comprendre comment cela fonctionne suffisent.