Exo Outils Fonctions

Identification

Infoforall

10 - Exos Outils & Fonctions


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.

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.

  1. contour ?
  2. interne ?
  3. epaisseur
  4. x ?
  5. y ?
  6. largeur ?
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61
# 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() # 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 ?

  1. Un stylo, un vrai avec un capuchon et tout et tout
  2. La référence d'un objet Turtle, référence qui permettra d'utliser ce "crayon"
  3. Un string nommé Turtle
  4. 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)

20 21 22 23 24 25 26 27 28 29 30 31 32
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 le Shell de façon à créer un assemblage commençant à 50 pixels sur l'axe horizontal.

Ecrire l'appel sur votre copie.

1 2 3 4
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

  1. Lors du premier appel à carre ?
  2. Lors du deuxième appel à carre ?
  3. 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 :

27 28 29 30 31 32
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 ?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32
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.

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78
# 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" # 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

  1. Ligne 74
  2. Ligne 76
  3. Ligne 48
  4. Ligne 21

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

  1. la fonction couleur
  2. la fonction stylo
  3. la fonction carre
  4. la fonction dessiner_carre

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

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

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

  1. on veut vérifier deux fois que les valeurs soient vraiment égales
  2. on veut comparer les expressions de chaque côté de ==
  3. c'est un piège : il ne faut mettre qu'un seul égal
  4. 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.