.. _guide-rapide-python-pygame:
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.