Python et Pygame - Guide rapide

Python est un langage de programmation simple et facile à apprendre. Ces notes ne constituent pas une documentation complète de ce langage, mais ont pour but de vous amener à écrire rapidement vos premiers programmes. Pour des informations plus détaillées et plus complètes, n’hésitez pas à consulter la documentation officielle de Python.

Un premier programme

Afin de vérifier que Python est correctement installé et que vous disposez de tous les outils nécessaires, la première étape consiste à rédiger et à exécuter le programme le plus simple que l’on puisse imaginer.

A l’aide d’Emacs ou d’un autre éditeur, créez un fichier hello.py contenant simplement:

print("hello, world!")

Vous pouvez maintenant exécuter ce programme en lançant dans un terminal la commande

python3 hello.py

Syntaxe

Python est un langage structuré, mais à la différence de C, C++ ou Java, les blocs ne sont pas délimités par les marqueurs de début et de fin { et }, mais par l’indentation, c’est-à-dire leur décalage par rapport au début de la ligne.

Exemple:

str = input("Entrez un nombre: ")

n = int(str)  # Convertit l'entrée en un nombre entier.

if n < 0:
    print("Le nombre doit être positif.")
else:
    f = 1
    i = 2
    while i <= n:
        f *= i
        i += 1

    print("La factorielle de", n, "vaut", f)

Dans cet exemple, l’indentation exprime que la dernière instruction print(...) fait partie de la clause else, mais pas du corps de la boucle while.

Ne vous privez pas d’expérimenter en modifiant certaines instructions de ce programme. (Vous êtes-vous déjà demandé combien de chiffres contient la factorielle de 100000?)

Variables et types

En Python, il n’est pas nécessaire de déclarer les variables. Le type de celles-ci est automatiquement déterminé lors de leur première affectation.

Exemple:

str = "abc"  # Chaîne de caractères
i = 10       # Entier
f = 3.14     # Réel

Deux structures de données fréquemment utilisées sont les tuples et les listes. Exemple:

t = (10, 20, 30)  # Tuple
l = [10, 20, 30]  # Liste

Les éléments d’une liste ou d’un tuple peuvent être de n’importe quel type (y compris une liste ou un tuple). La différence entre un tuple et une liste est que les tuples sont invariables (en d’autres termes, ils ne peuvent pas être modifiés après avoir été créés), alors que l’on peut modifier, ajouter ou retirer des éléments à une liste.

Dans les deux cas, l’opérateur [ ] permet d’accéder aux éléments d’une liste ou d’un tuple. Ceux-ci sont indicés à partir de 0.

Exemple:

lm = (31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31)

for m in range(12):
    print("le mois", m + 1, "contient", lm[m], "jours")

Note: L’instruction for m in range(12) effectue ici 12 itérations, en faisant prendre à m les valeurs 0, 1, …, 11.

Enfin, en Python, il est possible d’attribuer une valeur à plusieurs variables à l’aide d’une seule instruction d’affectation. Par exemple, l’instruction:

x, y = (y, x)

crée le tuple (y, x), et en attribue ensuite la première composante à la variable x et la seconde à y. L’effet de cette instruction est donc de permuter la valeur de ces deux variables.

Les dictionnaires

Un autre structure de données fréquemment utilisée est le dictionnaire, qui représente une table associant des clés à des valeurs. Les valeurs peuvent être de n’importe quel type, et les clés également si ce n’est qu’elles doivent être invariables. (On peut donc utiliser un tuple comme clé, mais pas une liste.)

Syntaxe et exemple:

etat = { 'position': (10, 30), 'vitesse': -2.5 }

print(etat['position'])  # Recherche dans le dictionnaire
print(etat['vitesse'])

etat['acceleration'] = 0.5  # Ajout d'une entrée

del etat['vitesse']  # Suppression d'une entrée

Les fonctions

Les fonctions Python se déclarent grâce au mot-clé def. Exemple:

def factorielle(n):
    f = 1
    i = 2
    while i <= n:
        f *= i
        i += 1
    return f

print(factorielle(1000))

Note: Les modifications de valeurs de variables effectuées au sein d’une fonction restent locales à celle-ci. Si une fonction doit modifier une variable globale, il est nécessaire de le déclarer à l’intérieur de celle-ci à l’aide du mot-clé global. Exemple:

def compter(n):
    global compteur
    compteur += n

compteur = 10
compter(5)
print(compteur)

La bibliothèque mathématique

L’environnement de programmation Python met à votre disposition un certain nombre de modules, qui sont des ensembles de fonctions préprogrammées. Parmi ceux-ci, le module math fournit une implémentation des fonctions mathématiques les plus courantes: fonctions trigonométriques, exponentielle, logarithmes, …

Exemple d’utilisation:

import math

print(math.cos(math.pi / 4))

La documentation complète de ce module peut être consultée ici.

Pygame

Pygame est un module Python destiné à faciliter la programmation de jeux et d’applications graphiques. Ses fonctions permettent de créer une fenêtre, d’y effectuer des opérations graphiques, et de réagir aux actions effectuées par l’utilisateur du programme.

Voici un exemple de programme simple utilisant Pygame:

import pygame
import sys

### Constante(s)

BLEUCLAIR = (127, 191, 255)
ROUGE = (255, 0, 0)

### Paramètre(s)

dimensions_fenetre = (800, 600)  # en pixels

### Programme

# Initialisation

pygame.init()

fenetre = pygame.display.set_mode(dimensions_fenetre)
pygame.display.set_caption("Premier programme Pygame");

# Dessin

fenetre.fill(BLEUCLAIR)
pygame.draw.circle(fenetre, ROUGE,
                   (dimensions_fenetre[0] // 2, dimensions_fenetre[1] // 2),
                   50)

pygame.display.flip()

# Boucle principale

while True:
  evenement = pygame.event.wait()
  if evenement.type == pygame.QUIT:
      pygame.quit()
      sys.exit();

Ce programme commence par initialiser le module Pygame en invoquant:

pygame.init()

Ensuite, il crée une fenêtre de dimension donnée, et lui attribue un titre:

fenetre = pygame.display.set_mode(dimensions_fenetre)
pygame.display.set_caption("Premier programme Pygame");

Les instructions suivantes peignent le fond de cette fenêtre et dessinent un disque au milieu de celle-ci:

fenetre.fill(BLEUCLAIR)
pygame.draw.circle(fenetre, ROUGE,
                   (dimensions_fenetre[0] // 2, dimensions_fenetre[1] // 2),
                   50)

Notes:

  • L’opérateur // effectue une division qui retourne un résultat entier plutôt que réel. On l’utilise ici car la fonction circle permettant de dessiner un disque attend des coordonnées entières pour le centre de celui-ci.
  • Les couleurs sont représentées par des tuples (rouge, vert, bleu), dont chacune des composantes peut varier entre 0 et 255.

Ces instructions sont suivies par:

pygame.display.flip()

qui rend visibles les modifications apportées au contenu de la fenêtre. En effet, par défaut, les opérations graphiques de Pygame sont effectuées dans une mémoire de travail dont le contenu n’est pas immédiatement répercuté vers la fenêtre affichée à l’écran. Ce mécanisme permet d’eviter des clignotements ou d’autres artifices qui pourraient être perçus par l’utilisateur lorsqu’une zone de l’écran est redessinée juste après avoir été effacée. Le fonction pygame.display.flip() recopie le contenu de la mémoire de travail vers la fenêtre, ce qui rend visible les dernières modifications apportées.

La dernière partie du programme sert simplement à attendre que l’utilisateur ferme la fenêtre. Elle est constituée d’une boucle dans laquelle on exécute l’instruction:

evenement = pygame.event.wait()

qui sert à attendre un évènement produit par l’utilisateur. Différents évènements sont définis, correspondant à des actions de la souris, des frappes au clavier, etc. L’évènement qui nous intéresse ici est celui qui indique que l’utilisateur souhaite fermer la fenêtre. Dès qu’un tel évènement est détecté, le programme clôt les opérations du module Pygame, et termine son exécution.

Encore une fois, n’hesitez pas à modifier ce programme et à expérimenter! La documentation officielle de Pygame est également disponible comme référence.