20 - Exos Outils & Fonctions

⏪

⏬

⏩

1 - Création

2 - paramètres

3 - QCM

Attention, le soin est noté et les codes markdown identiques seront sanctionnés à moins de noter clairement que vous avez travaillé avec un autre élève de la classe.

MODE COURS (cacher les questions)

1 - Création de Fonctions

⇩ ⇧ ⤊

01° Créer une fonction qui attend un paramètre a de type int et qui renvoie le triple de a.

02° Créer une fonction qui attend un paramètre a de type int et qui renvoie True si la valeur est strictement supérieure à 12. Sinon, False.

03° Créer une fonction qui attend deux paramètres a et b de type int. Elle renvoie True si les deux paramètres sont strictement supérieures à 10. False sinon.

2 - Identification des paramètres

⇩ ⇧ ⤊

Nous allons analyser dans cette partie un ensemble de fonctions permettant de dessiner des carrés colorés dans le module Turtle.

Le programme en lui-même, hors partie importation et partie déclaration ressemble à ceci :

59
60
61

carre("red", "yellow", 5, 10, 20, 50)
carre("blue", "pink", 5, 35, 45, 50)
carre("purple", "cyan", 5, 60, 70, 50)

04° Comparer l'appel de la fonction carre avec le prototype de la fonction qu'on peut voir ligne 34.

Donner alors le type (str, int...) et le contenu des différents paramètres lors de cet appel.

contour ?
interne ?
epaisseur
x ?
y ?
largeur ?

# Importation
import turtle as trt
 
# Déclaration des fonctions
 
def stylo(couleur, largeur):
    """Renvoie la référence d'un nouveau crayon-Turtle
 
    :: param couleur(str) :: un string légitime en tant que couleur ('black', 'red'...)
    :: param largeur(int) :: la largeur du crayon
    :: return (Turtle)    :: la référence d'un crayon-Turtle, objet de type Turtle
 
    """
    feutre = trt.Turtle()
    feutre.color(couleur)
    feutre.pensize(largeur)
    feutre.speed(7)
    return feutre
 
def deplacer(crayon, x, y):
    """Déplace le crayon-Turtle nommé crayon à la position x et y, (0,0) étant le centre de l'écran
 
    :: param crayon(Turtle) :: la référence du crayon-Turtle sur lequel on agit
    :: param x(int)         :: la position x où on veut poser le crayon
    :: param y(int)         :: la position y où on veut poser le crayon
    :: return (None)        :: c'est une "fonction-procédure" de Python
 
    """
    crayon.penup() # On lève la pointe
    crayon.setheading(0) # On oriente le crayon vers la droite (angle 0)
    crayon.setpos(x, y)
    crayon.pendown() # On abaisse la pointe
 
def carre(contour, interne, epaisseur, x, y, largeur):
    """Dessine un carré en (x, y) à l'aide des couleurs et de la largeur fournies
 
    :: param contour(str)   :: la couleur du contour
    :: param interieur(str) :: la couleur de remplissage
    :: param epaisseur(int) :: l'épaisseur du trait du crayon utilisé
    :: param x(int)         :: la coordonnée x du point supérieur gauche du carré
    :: param y(int)         :: la coordonnée y du point supérieur gauche du carré
    :: param largeur(int)   :: la largeur du carré    
    :: return (None)        :: c'est une "fonction-procédure" de Python
 
    """
 
    feutre = stylo(contour, epaisseur)
    deplacer(feutre, x, y)
    feutre.fillcolor(interne)
    feutre.begin_fill()
    for etape in range(4):
        feutre.forward(largeur)
        feutre.left(90)
    feutre.end_fill()
    feutre.hideturtle()
 
# Instructions du programme principal
 
carre("red", "yellow", 5, 10, 20, 50)
carre("blue", "pink", 5, 35, 45, 50)
carre("purple", "cyan", 5, 60, 70, 50)

05° Lignes 47 : réécrire sur votre copie cet appel en notant clairement le contenu des arguments contour et epaisseur.

Faux exemple :

`47`	`feutre = stylo("black", 12)`

06° Quel est le type de la réponse de la fonction stylo ?

Un stylo, un vrai avec un capuchon et tout et tout
La référence d'un objet Turtle, référence qui permettra d'utliser ce "crayon"
Un string nommé Turtle
None, c'est une "procédure" Python

On voit ensuite ligne 48 qu'on stocke la référence de notre nouvel objet Turtle dans une variable qu'on nommme feutre.

07° Comment se nomme le paramètre de la fonction deplacer qui va recevoir la référence de l'objet Turtle feutre qu'on lui envoie ?

08° Aurait-on pu écrire le code ci-dessous (dans lequel la fonction deplacer utilise également une variable nommée feutre) ou cela aurait-il posé des problèmes ?

Pensez à répondre en parlant de l'espace des noms des deux fonctions. Cela devrait simplifier votre rédaction :o)

def deplacer(feutre, x, y):
    """Déplace le crayon-Turtle nommé feutre à la position x et y, (0,0) étant le centre de l'écran
 
    :: param feutre(Turtle) :: la référence du crayon-Turtle sur lequel on agit
    :: param x(int)         :: la position x où on veut poser le crayon
    :: param y(int)         :: la position y où on veut poser le crayon
    :: return (None)        :: c'est une "fonction-procédure" de Python
 
    """
    feutre.penup() # On lève la pointe
    feutre.setheading(0) # On oriente le crayon vers la droite (angle 0)
    feutre.setpos(x, y)
    feutre.pendown() # On abaisse la pointe

09° Est-ce l'identifiant-mémoire qui permet d'agir sur le bon "crayon" ou est-ce le nom de la variable ?

10° Mettre la fonction assemblage en mémoire en plus des fonctions précédentes. Lancer un appel à cet appel dans la console de façon à créer un assemblage commençant à 50 pixels sur l'axe horizontal.

Ecrire l'appel sur votre copie.

def assemblage(x,y):
    for ligne in range(5):
        for colonne in range(10):
            carre("grey", "black", 2, x + colonne*25, y + ligne*25, 20)

11° Que valent les variables de boucle ligne puis colonne

Lors du premier appel à carre ?
Lors du deuxième appel à carre ?
Lors du troisième appel à carre ?

12° Créer la fonction chateau qui permet de tracer un chateau en fournissant les coordonnées. Cette fonction devra bien entendu utiliser la fonction carre de façon à ne pas écrire un code qui est déjà écrite. Votre chateau devra comporter au moins 6 carrés. A vous de voir comment le représenter. Ce n'est de toutes manières pas un concours artistique.

Un peu d'interactivité maintenant.

Pour l'instant, nous sommes en programmation impérative : les instructions s'enchaînent les unes derrière les autres et on peut suivre le cheminement du programme.

Mais, on peut faire de la programmation événementielle : il s'agit de placer notre programme dans un certain état puis de surveiller les actions de l'utilisateur de façon à modifier l'état du programme en fonction des actions de l'utilisateur.

Exemple :

def dessin_au_click(x,y):
    carre("black", "grey", 5, x, y, 30)
 
ecran = trt.Screen()
ecran.setup(400,300)
ecran.onclick(dessin_au_click)

Ligne 27 à 29 : déclaration et mise en mémoire d'une fonction. On zappe pour l'instant.

Ligne 30 : on crée un objet ecran qui nous permettra d'agir sur la fenêtre graphique dans laquelle apparaissent les dessins.

Ligne 31 : on agit sur la fenêtre graphique pour dimensionner l'écran.

Ligne 32 : on utilise la méthode onclick sur l'écran. On donne en argument la fonction qu'il faudra activer lorsqu'on détecte un clic de la souris sur notre écran : ici, cela va lancer automatiquement la fonction dessin_au_click.

13° Lancer et tester le programme suivant, avec quelques clics sur l'écran.

Le propre des fonctions événementielles est de recevoir des informations sur l'événement qui les ont déclenchées.

Que semblent contenir automatiquement les paramètres x et y de la fonction événementielle dessin_au_click ?

import turtle as trt
 
def stylo(couleur, largeur):
    feutre = trt.Turtle()
    feutre.color(couleur)
    feutre.pensize(largeur)
    feutre.speed(7)
    return feutre
 
def deplacer(feutre, x, y):
    feutre.penup() # On lève la pointe
    feutre.setheading(0) # On oriente le crayon vers la droite (angle 0)
    feutre.setpos(x, y)
    feutre.pendown() # On abaisse la pointe
 
def carre(couleur, interne, largeur, x, y, cote):
    feutre = stylo(couleur, largeur)
    deplacer(feutre, x, y)
    feutre.fillcolor(interne)
    feutre.begin_fill()
    for etape in range(4):
        feutre.forward(cote)
        feutre.left(90)
    feutre.end_fill()
    feutre.hideturtle()
 
def dessin_au_click(x,y):
    carre("black", "grey", 5, x, y, 30)
 
ecran = trt.Screen()
ecran.setup(400,300)
ecran.onclick(dessin_au_click)

Si vous voulez le moyen de gérer le clavier, vous trouverez votre bonheur dans la documentation Python du module Turtle.

La partie suivante vous montre quelques utilisations possibles.

Documentation Turtle Evénements

3 - QCM

⇩ ⇧ ⤊

14° Lancer et tester le programme suivant. Il faut appuyer sur les flèches Haut et Bas pour déclencher un événement.

Quelques questions de type QCM sur le code ci-dessous.

# Phase d'importation
 
import turtle as trt
import random as rd
 
# Phase de déclaration
 
def stylo(couleur, largeur):
    feutre = trt.Turtle()
    feutre.color(couleur)
    feutre.pensize(largeur)
    feutre.speed(7)
    return feutre
 
def deplacer(feutre, x, y):
    feutre.penup() # On lève la pointe
    feutre.setheading(0) # On oriente le crayon vers la droite (angle 0)
    feutre.setpos(x, y)
    feutre.pendown() # On abaisse la pointe
 
def carre(couleur, interne, largeur, x, y, cote):
    feutre = stylo(couleur, largeur)
    deplacer(feutre, x, y)
    feutre.fillcolor(interne)
    feutre.begin_fill()
    for etape in range(4):
        feutre.forward(cote)
        feutre.left(90)
    feutre.end_fill()
    feutre.hideturtle()
 
def cercle(couleur, interne, largeur, x, y, rayon):
    feutre = stylo(couleur, largeur)
    deplacer(feutre, x, y)
    feutre.fillcolor(interne)
    feutre.begin_fill()
    feutre.circle(rayon)
    feutre.end_fill()
    feutre.hideturtle()
 
def dessiner_carre():
    print("Touche UP !")
    x = rd.randint(-largeur//2 + 20, largeur//2 - 20)
    y = rd.randint(-hauteur//2 + 20, hauteur//2 - 20)
    cote = rd.randint(20,40)
    carre(couleur(), couleur(), 2, x, y, cote)
 
def dessiner_cercle():
    print("Touche DOWN !")
    x = rd.randint(-largeur//2 + 20, largeur//2 - 20)
    y = rd.randint(-hauteur//2 + 20, hauteur//2 - 20)
    rayon = rd.randint(20,40)
    cercle(couleur(), couleur(), 2, x, y, rayon)
 
def couleur():
    choix = rd.randint(1,6)
    if choix == 1 :
        return "red"
    elif choix == 2 :
        return "blue"
    elif choix == 3 :
        return "yellow"
    elif choix == 4 :
        return "orange"
    elif choix == 5 :
        return "cyan"
    elif choix == 6 :
        return "pink"
 
# Instructions du programme principal
 
largeur = 400
hauteur = 300
ecran = trt.Screen()
ecran.setup(largeur, hauteur)
ecran.onkey(dessiner_carre, "Up")
ecran.onkey(dessiner_cercle, "Down")
ecran.listen()

15° Le lancement de la surveillance de la flèche du Haut se trouve

Ligne 74
Ligne 76
Ligne 48
Ligne 21

16° Lorsqu'on appuie sur la flèche du Haut, on active d'abord

la fonction couleur
la fonction stylo
la fonction carre
la fonction dessiner_carre

17° Ligne 26. La variable de boucle etape va prendre successivement les valeurs

0-1-2-3-4
1-2-3-4
0-1-2-3
1-2-3

18° Ligne 59. Nous avons mis deux signes = car

on veut vérifier deux fois que les valeurs soient vraiment égales
on veut comparer les expressions de chaque côté de ==
c'est un piège : il ne faut mettre qu'un seul égal
on compare à 2. Si on avait comparé à trois, nous aurions noté choix === 3

Activité publiée le 15 09 2020
Dernière modification : 15 09 2020
Auteur : ows. h.

⏪

⏫

⏩