18 - Une tâche une fonction
Nous allons maintenant utiliser la puissance des fonctions pour réaliser des choses sympathiques avec le module Turtle.
Vous allez également voir qu'il faut tenter d'associer chaque tâche avec une fonction dans vos programmes. Et on pourra les emboîter les unes dans les autres.
Logiciel nécessaire pour l'activité : Python 3
Evaluation ✎ : question 10-11-12-13-14-15
Documents de cours : open document ou pdf
1 - Fonction nouveau stylo
AVERTISSEMENT
Dans cette activité, il faudra garder vos différentes fonctions en mémoire puisque le but est de créer de nouvelles fonctions lançant des appels aux vielles fonctions.
Rappel sur la structure d'un programme :
- Importations
- Déclaration des CONSTANTES
- Déclaration des fonctions
- Programme principal
Nous allons commencer par créer une fonction nouveau_stylo() qui va nous permettre de créer un stylo en définissant ses caractéristiques.
01° Utiliser ce programme qui utilise une seule fonction. Donner les lignes suivies par l'interpréteur et noter un commentaire expliquant le rôle de la ligne.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18 | |
...CORRECTION...
Déroulé :
L1 - L3(déclaration) - L12(appel) - L3-L5-L6-L7-L8-L9-L10-L12(retour) - L13-L14-L15-L16-L17-L18
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18 | |
02-A° Lors de l'appel, dans quel paramètre sera stocké l'argument "red", l'argument "black" et l'argument 4 ? Pour répondre, il suffit d'aller lire l'appel (L12) avec la première ligne de la déclaration (L3).
12 | |
...CORRECTION...
..
3
..
12 | |
Le string "red" est stocké dans ecriture.
Le string "black" est stocké dans fond.
Le string 4 est stocké dans largeur.
02-B° Que renvoie cette fonction nouveau_stylo() ? Pour répondre, il suffit de chercher son return et comprendre ce qu'il renvoie en allant cherchant plus haut dans les instructions l'affectation de feutre.
- Un dessin
- La référence d'une "tortue" (Turtle) qui nous servira de crayon
- La couleur du crayon
- La réference d'un dessin
...CORRECTION...
1
2
3
4
5
6
7
8
9
10 | |
Ligne 5, on stocke dans feutre la référence d'un objet Turtle().
Ligne 10 : on renvoie feutre et donc la référence d'un objet Turtle qui va nous servir à dessiner.
2 - Déplacer le crayon avec une fonction
Nous allons maintenant rajouter une fonction deplacer() qui permet de modifier la position du crayon. Si vous vous souvenez, c'est assez pénible à taper à la main :
- Il faut soulever le crayon avec penup()
- Déplacer le crayon avec goto()
- Abaisser le crayon avec pendown() pour pouvoir dessiner à nouveau
03 ✔° Mettre le programme complet en mémoire. Lire les instructions pour vérifier qu'il comporte
- une partie Importation au début
- une partie Déclaration des fonctions
- une partie Programme, qui commence en ligne 36
Le programme permet de tracer trois traits en utilisant deux fonctions qui vont nous simplifier un peu le travail
Programme complet
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 | |
04° Questions
- lors de l'appel sur la ligne 36, quels sont les arguments envoyés ? Dans quels paramètres sont-ils stockés dans la fonction ?
- lors de l'appel sur la ligne 38, quels sont les arguments envoyés ? Dans quels paramètres sont-ils stockés dans la fonction ?
5
|
|
|
36 | |
21
|
|
|
38 | |
...CORRECTION...
- Les arguments "red","black", 4 vont être stockés dans les paramètres ecriture, fond, largeur.
- Les arguments s1, 0, 0 vont être stockés dans les paramètres feutre, x, y.
1 - Modifier l'état par effet de bord
Modifier par effet de bord veut dire modifier sans utiliser une nouvelle affectation (c'est à dire sans l'opérateur =).
Comme on peut le voir, la fonction deplacer() modifie l'état du "crayon" feutre reçu en paramètre, puisqu'il est déplacé.
28
30
31
32 | |
Sans retour. Le crayon est directement modifié.
Du coup, il faudrait l'indiquer dans la documentation :
21
22
23
24
25
26
27
28
29
30
31
32
33 | |
3 - Une fonction pour chaque tâche
Nous allons voir ici quelque chose de fondamental au niveau de la conception des fonctions : chaque fonction de base ne doit normalement réaliser qu'une tâche basique.
Si on a besoin de réaliser une tâche complexe comment faire alors ?
Réponse : on crée une autre fonction qui va faire appel aux fonctions de base précédentes.
05-A ✔° Trois choses à faire :
- Placer le nouveau programme ci-dessous en mémoire en remplacement de l'ancien.
- Allez lire la documentation de la fonction trois() directement dans le code (lignes 34 à 42) de façon à connaître les paramètres dont elle disposera pour faire ce travail.
- De façon plus professionnelle, taper ceci dans la console de façon à afficher la documentation dans la console :
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
79
80
81
82
83
84
85
86
87
88
89 | |
Pour rappel, setheading() sert à faire pointer la tortue dans une direction particulière.
>>> help(trois)
Help on function trois in module __main__:
trois(feutre, distance, angle)
Fait avancer le crayon de la distance, tourne de l'angle donné. Trois fois.
:: param feutre(Turtle) :: la référence du crayon
:: param distance(int) :: la distance à parcourir
:: param angle(int) :: l'angle de rotation en degrés
:: return (None) :: fonction sans retour
.. effet de bord :: modifie l'état de feutre
05-B° Maintenant que vous avez lu la documentation de la fonction et que vous savez donc ce qu'elle doit recevoir et dans quel ordre, réaliser le code interne de la fonction trois() de façon à ce qu'elle fasse trois fois ceci :
- trace un trait sur la bonne distance puis
- tourne à gauche de l'angle transmis en paramètre,
...CORRECTION...
1
2
3
4
5
6
7
8
9
10
11
12
13 | |
06 ✔° Observer dans votre code l'unique instruction de la fonction triangle() : elle lance un appel à la fonction trois() en fournissant un angle de 120° : cela lui permet de tracer un triangle.
..
..
..
..
..
..
..
..
..
..
..
..
..
..
..
..
..
..
.. | |
Modifier uniquement la partie PROGRAMME PRINCIPAL pour ne plus qu'y placer ces deux lignes visibles ci-dessus et lancer le programme pour observer le résultat.
07° Répondre aux questions suivantes qui sont liées au transfert de paramètres lors de l'utilisation de ces instructions :
..
..
..
.. |
|
- Que contiennent les paramètres ftr et cote lorsqu'on lance triangle(s1, 150) ?
- Que contiennent alors les paramètres feutre, distance et angle lorsqu'on lance trois(ftr, cote, 120) ?
Questions
Rappel : pour pouvoir répondre, il faut regarder la première ligne de la déclaration de la fonction et la ligne d'appel.
...CORRECTION...
Déclaration
..
Appel | |
On voit donc que ftr reçoit la référence de s1.
On voit que cote reçoit la valeur 150.
On agit de la même manière en comparant la déclaration et l'appel de trois
Déclaration
..
Appel | |
feutre stocke donc la même référence que ftr, à savoir s1, le crayon du départ !
distance reçoit cote, soit 150.
angle fait donc référence à 120.
On trace donc un triangle (car trois traits avec un angle de 120°) avec le crayon du départ.
08° Vous allez devoir parvenir à réaliser une nouvelle fonction : suivre cette méthode de travail en 3 étapes :
- Regarder la documentation de trace_triangle() pour voir quels sont les paramètres à fournir lors d'un appel et dans quel ordre les fournir.
- Compléter ensuite la fonction trace_triangle() dont les instructions internes doivent réaliser ceci :
- Créer un nouveau stylo f (en utilisant nouveau_stylo())
- Déplacer ce stylo en (x,y) (en utilisant deplacer())
- Demander de surveiller le dessin en vu de faire du remplissage ensuite (avec f.begin_fill())
- Dessiner un triangle à cet endroit (en utilisant triangle())
- Demander de remplir la forme qu'on vient de créer (avec f.end_fill())
- Demander de cacher le feutre-tortue (avec f.hideturtle())
- Renvoyer la référence f
- Tester en lançant le programme principal suivant qui ne comporte plus que cette uniquement instruction : un appel à votre nouvelle fonction.
1
2
3
4
5 | |
...CORRECTION...
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19 | |
2 - Une fonction, une tâche
Comme vous l'avez vu, nous sommes parvenus à réaliser cette action assez complexe en la décomposant en de multiples petites fonctions. C'est une manière de faire qu'il faudra prendre l'habitude d'utiliser.
Comme on peut le voir,
- on utilise des fonctions basiques et
- on crée des fonctions plus complexes qui utilisent ces fonctions basiques.
09 ✔° Localiser à la fin de votre programme cette fonction rapide_triangle() qui utilise en interne un appel à votre fonction trace_triangle(), en lui disant de tracer en bleu avec un fond orange.
1
2
3
4
5
6
7
8
9
10 | |
Tester en utilisant ce nouveau programme principal :
1
2
3
4
5
6
7 | |
Vous devriez obtenir ceci :
✎ 10° Travail à réaliser :
- Rajouter la fonction dessin1() (dans la partie DECLARATION DES FONCTIONS),
- lire sa documentation pour remarquer qu'elle ne reçoit aucune information,
- compléter pour que son appel provoque le dessin précédent : trois triangles,
- tester votre fonction en utilisant ce nouveau programme principal :
1 2 3 4 5... # Programme dessin1()
1
2
3
4
5
6
7 | |
On crée donc des fonctions basiques qui seront appelées par d'autres fonctions pour réaliser des choses plus complexes.
✎ 11° Travail à réaliser :
- Rajouter la fonction quatre() (dans la partie DECLARATION DES FONCTIONS),
- lire sa documentation pour connaître ses paramètres et leur ordre,
- compléter de façon à ce qu'elle réalise 4 fois la séquence : trace un trait, tourne de l'angle.
- tester votre fonction en utilisant ce nouveau programme principal :
1 2 3# Programme s1 = nouveau_stylo("red","black", 4) quatre(s1, 150, 90)
1
2
3
4
5
6
7
8
9
10 | |
✎ 12° Travail à réaliser :
- Rajouter la fonction carre() (dans la partie DECLARATION DES FONCTIONS),
- lire sa documentation pour connaître ses paramètres et leur ordre,
- compléter de façon à ce qu'elle trace un carré en utilisant... la fonction quatre().
- tester votre fonction en utilisant ce nouveau programme principal :
1 2 3# Programme s1 = nouveau_stylo("green","black", 4) carre(s1, 150)
1
2
3
4
5
6
7
8
9
10 | |
Une fois cette fonction carre() créée, on pourrait l'utiliser pour totalement encapsuler la réalisation d'un carré dans une fonction trace_carre() par exemple :
- création d'un stylo,
- déplacement du stylo au bon endroit,
- gestion du fond coloré et traçage du carré en utilisant carre().
✎ 13° Rajouter cette nouvelle fonction trace_carre() dans votre programme puis répondre à cette question : puisque les deux tâches sont presque les mêmes, quelle est la seule ligne différente entre les fonctions trace_carre() et trace_triangle() (en dehors de la documentation) ?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19 | |
3 - Méthodologie de programmation
Lorsqu'on vous demande de réaliser une fonction, il faut donc
- copier le code fourni dans la partie Déclaration de fonction ou réaliser votre propre déclaration sans réaliser le code proprement dit,
- lire la documentation pour savoir ce que sont les paramètres de votre fonction
- rajouter le code interne permettant de travailler (en utilisant si besoin d'autres fonctions) sans dépasser la vingtaine de lignes.
- Tester votre fonction.
✎ 14° Travail à réaliser :
- Rajouter la fonction tour() (dans la partie DECLARATION DES FONCTIONS),
- lire sa documentation pour voir qu'elle n'attend aucun paramètre,
- compléter de façon à ce qu'elle trace cette tour en lançant 6 appels à ... la fonction trace_carre().
- tester votre fonction en utilisant ce nouveau programme principal :
1 2 3 4 5... # Programme tour()
1
2
3
4
5
6
7 | |
Nous pourrions continuer et refaire le même cheminement pour créer des disques colorés. Voici de quoi réaliser ce type de dessin. Cette fois, j'ai crée les fonctions
- Tâche basique : arc_de_cercle() à qui on doit fournir un feutre Turtle et un angle,
- Tâche moyenne : cercle() qui utilise à l'interne arc_de_cercle() en lui demander de tracer sur 360°,
- Tâche complexe : trace_disque() qui crée elle-même un feutre avec nouveau_stylo(), qu'elle déplace avec deplacer() et qu'elle fournit à cercle()
Exemple d'utilisation :
>>> trace_disque("red", "orange", 10, 0, 0, 100)
<turtle.Turtle object at 0x7ff58c7d9be0>
Résultat :
Les déclarations de fonctions à rajouter (si vous le voulez):
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 | |
✎ 15° Utiliser la fonction trace_disque() pour réaliser un petit dessin comportant des ronds et des carrés.
4 - FAQ
Et left, forward... Ce sont des fonctions aussi non ?
Comme vous avez dû le remarquer, on peut agir sur le crayon / feutre en utilsant des sortes de fonctions : left, forward...
La syntaxe est néanmoins différentes de celles des fonctions : on doit placer le nom de l'objet sur lequel on agit, placer un point puis placer le nom de la fonction.
1
2 | |
Si vous regardez bien, vous pourrez d'ailleurs voir qu'elles sont en rouge foncé, contrairement aux fonctions qui sont en rouge clair.
Pourquoi ? Tout simplement car ces fonctions portent un nom particulier.
On les nomme des méthodes : ce sont des fonctions incorporées de base à l'intérieur de certaines structures qu'on nomme des objets. Comme notre Turtle.
Si vous regardez les codes Python que vous pouvez trouver sur le Web, vous risquez de tomber assez régulièrement sur ces drôles d'appels de fonctions avec le point.
En résumé, il s'agit juste de fonctions incorporées et on les nomme méthodes.
La codification est donc : objet.methode().
Activité publiée le 01 11 2020
Dernière modification : 13 07 2023
Auteur : ows. h.