Cours 4 - Modules

Tuples

Séquence non modifiable d’éléments Les éléments d’un tuple ne peuvent pas être réassignés et on ne peut pas en ajouter ou en enlever

Définition d’un tuple avec () Parenthèses pas obligatoires lorsqu’au moins un élément

# Tuple vide
a = ()

# Tuples contenant un seul élément
b = 1,
c = (1,)

# Tuples contenant trois éléments
d = 1, 2, 3
e = (1, 2, 3)

Utilisation d’un tuple similaire à celle des listes

Emballage et déballage

On peut emballer plusieurs valeurs dans un tuple Elles sont toutes accessibles à partir d’une seule variable
On peut déballer un tuple dans plusieurs variables Chaque variable reçoit la valeur d’un élément du tuple

t = 1, 2, 3
print(t)

a, b, c = t
print(a, b, c)

(1, 2, 3) 1 2 3

Toutes les séquences peuvent se déballer (tuple, list, str, …)

Les énumérations

La fonction enumerate() permet d’énumérer les éléments d’une séquence
Elle génère une séquence de tuple contenant un numéro d’ordre et un élément

L = ['un', 'deux', 'trois']
print(enumerate(L))        # affiche <enumerate at 0x10035e570>
print(list(enumerate(L)))  # affiche [(0, 'un'), (1, 'deux'), (2, 'trois')]

Les tuples peuvent être déballés pendant un for

for i, value in enumerate(L):
    print("l'élément d'indice", i, "est", value)

l'élément d'indice 0 est un l'élément d'indice 1 est deux l'élément d'indice 2 est trois

Modules

Un gros programme est rarement écrit en un fichier.
- Longs fichiers → pas pratique.
- Travail à plusieurs.
Un même module peut être utiliser dans plusieurs projets.

Utilisation d’un module

Importation d’un module:

import turtle

turtle.forward(90)
turtle.done()

Importation des fonctions d’un module:

from turtle import forward, done

forward(90)
done()

Pour importer toutes les fonctions, on utilise le * (non recommandé):
```
from turtle import *
```

Définition d’un module

Créer un fichier .py contenant des définitions de fonctions.
Exemple: définissons le module shape dans le fichier shape.py.

from turtle import color, up, down, goto, done

def polygon(center, nbsides, radius, col='black'):
    # Dessiner un polygone régulier

def square(center, radius, col='black'):
    polygon(center, 4, radius, col)

On peut importer un module dans un autre.

Dessiner un polygone régulier

Polygone: Code

from turtle import color, up, down, goto, done
from math import cos, sin, pi


def polygon(center, nb_sides, radius, col="black"):
    x, y = center  # déballage de séquence
    angle = 2 * pi / nb_sides
    up()
    goto(x + radius, y)
    down()
    color(col)
    for i in range(1, nb_sides+1):
        goto(
            x + radius * cos(i * angle),
            y + radius * sin(i * angle),
        )


def square(center, radius, col="black"):
    polygon(center, 4, radius, col)

Définition d’un module

On peut ensuite écrire le programme suivant:

from shape import square, polygone, done

polygon((150, 150), 5, 100, 'red')
square((-50, -50), 50, 'blue')

done()

Documentation de turtle

`import` égal exécution

Lors de l’import d’un module, tout le code du module est exécuté
Ce n’est pas toujours désirable
Un même fichier est parfois exécuté comme programme et parfois importé comme module.

La variable `name`

La variable globale __name__ est définie dans chaque fichier Python :
- Elle contient un string égal au nom du module.
- Dans le programme principal, elle vaut "__main__".
Pour qu’un module puisse aussi être exécuté comme un programme, on teste souvent la variable __name__:
```
# ...

if __name__ == "__main__":
    polygon((0, 0), 5, 200, 'blue')
    done()
```

Application interactive

Nous vous avons préparé un petit module permettant de faire des applications interactives dans le terminal: stge.py

`stge.py`: Utilisation

import stge

def setup():
  # cette fonction doit renvoyer
  # l'état initial de l'application
  return state

def loop(state):
  # cette fonction reçoit l'état précédent
  # de l'application et renvoie l'état suivant
  return state

stge.run(setup, loop)

Fonctions disponibles

stge.quit(): Termine l’application
stge.size(): Renvoie la taille du terminal
stge.write_at(): Affiche à une position déterminée du terminal
stge.keypresses(): Renvoie les touches appuyées depuis la dernière frame
stge.pixels(): Affiche une grille de pixels en utilisant le caractère “demi-bloc”

Utilisez la documentation incluse dans Zed pour savoir comment utiliser ces fonctions

Exemple

Un entier est affiché au milieu de l’écran. La touche espace le fait augmenter de 1. La touche q quitte le programme.

import stge

def setup():
  return 0

def loop(state):
  width, height = stge.size()

  for key in stge.keypresses():
    if key == "SPACE":
      state += 1
    if key == "q":
      stge.quit()

  stge.write_at(width//2, height//2, state)
  return state

stge.run(setup, loop)

Game Mode: déplacements

L’état pourrait représenter la position (x, y) d’un “personnage”

import stge

def setup():
    return 0, 0

def loop(state):
    x, y = state
    xn, yn = x, y

    width, height = stge.size()

    for key in stge.keypresses():
        if key == "q":
            stge.quit()
        if key == "RIGHT":
            xn += 1
        if key == "LEFT":
            xn -= 1
        if key == "UP":
            yn -= 1
        if key == "DOWN":
            yn += 1

    if xn >= 0 and xn < width and yn >= 0 and yn < height:
        x, y = xn, yn

    stge.write_at(x, y, "ጰ", fg=(0, 255, 0))

    return x, y

stge.run(setup, loop)

Game Mode: labyrinthe

Ajoutons un labyrinthe pour qu’il y ait un challenge

import stge

maze = [
    "══╦═══════════════╦═════╦═══════════╦═════╦═══════╗",
    "  ║               ║     ║           ║     ║       ║",
    "║ ╚═══╦══ ╔═════╗ ╚═══╗ ║ ══╗ ╔═══╗ ╚══ ║ ║ ══╦══ ║",
    "║     ║   ║     ║     ║ ║   ║ ║   ║     ║ ║   ║   ║",
    "╠═══╗ ║ ╔═╝ ══╗ ╠════ ║ ╚══ ║ ║ ║ ╚═╦═══╬═╩══ ║ ══╣",
    "║   ║   ║     ║ ║     ║     ║   ║   ║   ║     ║   ║",
    "║ ══╩═══╩═════╝ ║ ╔═══╝ ╔═══╬═══╩═╗ ║ ║ ║ ╔═══╣ ║ ║",
    "║               ║ ║     ║   ║     ║   ║   ║   ║ ║ ║",
    "╠══════ ╔══════ ║ ╚═════╝ ║ ║ ╔══ ║ ╔═╬═══╣ ║ ╚═╣ ║",
    "║       ║       ║         ║ ║ ║   ║ ║ ║   ║ ║   ║ ║",
    "║ ╔═════╝ ╔═════╩═══════╦═╣ ║ ║ ╔═╝ ║ ║ ║ ║ ╠══ ║ ║",
    "║ ║       ║             ║ ║   ║ ║     ║ ║   ║   ║ ║",
    "║ ╚═══╗ ══╣ ══╗ ╔═════╗ ║ ╚═╦═╝ ║ ══╦═╝ ╠═══╣ ╔═╝ ║",
    "║     ║   ║   ║ ║     ║ ║   ║   ║   ║   ║   ║ ║   ║",
    "║ ╔═╗ ╠══ ╚══ ║ ║ ══╗ ║ ╚═╗ ║ ══╩═╦═╝ ╔═╝ ╔═╝ ║ ══╣",
    "║ ║ ║ ║       ║ ║   ║ ║   ║ ║     ║   ║   ║   ║   ║",
    "║ ║ ║ ║ ╔═══╗ ╠═╩═╗ ║ ╠══ ║ ╠═══╗ ║ ╔═╣ ══╣ ══╣ ║ ║",
    "║   ║ ║ ║   ║ ║   ║ ║ ║     ║   ║ ║ ║ ║   ║   ║ ║ ║",
    "╠══ ║ ╚═╝ ║ ╚═╝ ║ ║ ║ ╚═════╝ ║ ║ ║ ║ ║ ║ ╚══ ╚═╝ ║",
    "║   ║     ║     ║   ║         ║     ║   ║         E",
    "╚═══╩═════╩═════╩═══╩═════════╩═════╩═══╩══════════",
]


def draw_maze():
    for i, line in enumerate(maze):
        stge.write_at(0, i, line)

def setup():
    return 0, 1

def loop(state):
    x, y = state
    xn, yn = x, y

    for key in stge.keypresses():
        if key == "q":
            stge.quit()
        if key == "RIGHT":
            xn += 1
        if key == "LEFT":
            xn -= 1
        if key == "UP":
            yn -= 1
        if key == "DOWN":
            yn += 1

    if maze[yn][xn] == " ":
        x, y = xn, yn

    draw_maze()
    stge.write_at(x, y, "ጰ", fg=(0, 255, 0))

    return x, y

stge.run(setup, loop)

Cours 4 Modules

Tuples

Emballage et déballage

Les énumérations

Modules

Utilisation d’un module

Définition d’un module

Dessiner un polygone régulier

Polygone: Diagramme

Polygone: Code

Définition d’un module

`import` égal exécution

La variable `name`

Application interactive

`stge.py`: Utilisation

Fonctions disponibles

Exemple

Game Mode: déplacements

Game Mode: labyrinthe

Tuples

Emballage et déballage

Les énumérations

Modules

Utilisation d’un module

Définition d’un module

Dessiner un polygone régulier

Polygone: Diagramme

Polygone: Code

Définition d’un module

import égal exécution

La variable __name__

Application interactive

stge.py: Utilisation

Fonctions disponibles

Exemple

Game Mode: déplacements

Game Mode: labyrinthe

`import` égal exécution

La variable `name`

`stge.py`: Utilisation