.. _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.