fonctions Turtle

Identification

Infoforall

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
import turtle as trt def nouveau_stylo(ecriture, fond, largeur): """Renvoie la référence d'un stylo configuré""" feutre = trt.Turtle() feutre.color(ecriture) feutre.fillcolor(fond) feutre.pensize(largeur) feutre.speed(5) return feutre s1 = nouveau_stylo("red","black", 4) s1.forward(150) s1.left(120) s1.forward(150) s1.left(120) s1.forward(150) s1.left(120)

...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
import turtle as trt # Importation du module Turtle def nouveau_stylo(ecriture, fond, largeur): # Déclaration de la fonction nouveau_stylo """Renvoie la référence d'un stylo configuré""" feutre = trt.Turtle() # création et stockage dans feutre d'une nouvelle tortue feutre.color(ecriture) # choix de la couleur d'écriture feutre.fillcolor(fond) # choix de la couleur de fond coloré feutre.pensize(largeur) # choix de la taille du trait feutre.speed(5) # choix de la vitesse du tracé return feutre # on renvoie la référence de la tortue qu'on vient de créer s1 = nouveau_stylo("red","black", 4) # création d'une tortue nommée s1 s1.forward(150) # on l'avance de 150 pixels s1.left(120) # on tourne de 120° s1.forward(150) # on avance s1.left(120) # on tourne s1.forward(150) # on avance s1.left(120) # on tourne

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
s1 = nouveau_stylo("red","black", 4)

...CORRECTION...

.. 3 .. 12
def nouveau_stylo(ecriture, fond, largeur): s1 = nouveau_stylo("red","black", 4)

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.

  1. Un dessin
  2. La référence d'une "tortue" (Turtle) qui nous servira de crayon
  3. La couleur du crayon
  4. La réference d'un dessin

...CORRECTION...

1 2 3 4 5 6 7 8 9 10
import turtle as trt def nouveau_stylo(ecriture, fond, largeur): """Renvoie la référence d'un stylo configuré""" feutre = trt.Turtle() feutre.color(ecriture) feutre.fillcolor(fond) feutre.pensize(largeur) feutre.speed(5) return feutre

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

  1. une partie Importation au début
  2. une partie Déclaration des fonctions
  3. 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
# Importation des modules supplémentaires import turtle as trt # Déclaration des fonctions def nouveau_stylo(ecriture, fond, largeur): """Renvoie la référence d'un stylo configuré :: param ecriture(str) :: une couleur autorisée (pour l'écriture) :: param fond(str) :: une couleur autorisée (pour le fond éventuel) :: param largeur(int) :: la largeur d'écriture :: return (Turtle) :: la référence du crayon """ feutre = trt.Turtle() feutre.color(ecriture) feutre.fillcolor(fond) feutre.pensize(largeur) feutre.speed(5) return feutre def deplacer(feutre, x, y): """Lève le feutre, déplace le feutre et abaisse le feutre :: param feutre(Turtle) :: la référence du crayon :: param x(int) :: coordonnée horizontale (abscisse) :: param y(int) :: coordonnée verticale (ordonnée) :: return (None) :: c'est une fonction sans retour """ feutre.penup() # On lève la pointe feutre.goto(x, y) # On déplace le crayon feutre.pendown() # On abaisse la pointe # Programme s1 = nouveau_stylo("red","black", 4) s1.forward(150) deplacer(s1, 0, 0) s1.left(120) s1.forward(150) deplacer(s1, 0, 0) s1.left(120) s1.forward(150)

04° Questions

  1. 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 ?
  2. 5 | | | 36
    def nouveau_stylo(ecriture, fond, largeur): ... s1 = nouveau_stylo("red","black", 4)
  3. 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 ?
  4. 21 | | | 38
    def deplacer(feutre, x, y): ... deplacer(s1, 0, 0)

...CORRECTION...

  1. Les arguments "red","black", 4 vont être stockés dans les paramètres ecriture, fond, largeur.
  2. 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
def deplacer(feutre, x, y): feutre.penup() # On lève la pointe feutre.goto(x, y) # On déplace le crayon feutre.pendown() # On abaisse la pointe

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
def deplacer(feutre, x, y): """Lève le feutre, déplace le feutre et abaisse le feutre :: param feutre(Turtle) :: la référence du crayon :: param x(int) :: coordonnée horizontale (abscisse) :: param y(int) :: coordonnée verticale (ordonnée) :: return (None) :: c'est une fonction sans retour .. effet de bord :: modifie l'état de feutre """ feutre.penup() # On lève la pointe feutre.goto(x, y) # On déplace le crayon feutre.pendown() # On abaisse la pointe

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 :

  1. Placer le nouveau programme ci-dessous en mémoire en remplacement de l'ancien.
  2. 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
    # Importation des modules supplémentaires import turtle as trt # Déclaration des fonctions def nouveau_stylo(ecriture, fond, largeur): """Renvoie la référence d'un stylo configuré :: param ecriture(str) :: une couleur autorisée (pour l'écriture) :: param fond(str) :: une couleur autorisée (pour le fond éventuel) :: param largeur(int) :: la largeur d'écriture :: return (Turtle) :: la référence du crayon """ feutre = trt.Turtle() feutre.color(ecriture) feutre.fillcolor(fond) feutre.pensize(largeur) feutre.speed(5) return feutre def deplacer(feutre, x, y): """Lève le feutre, déplace le feutre et abaisse le feutre :: param feutre(Turtle) :: la référence du crayon :: param x(int) :: coordonnée horizontale (abscisse) :: param y(int) :: coordonnée verticale (ordonnée) :: return (None) :: c'est une fonction sans retour .. effet de bord :: modifie l'état de feutre """ feutre.penup() # On lève la pointe feutre.goto(x, y) # On déplace le crayon feutre.pendown() # On abaisse la pointe def 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 """ pass def triangle(ftr, cote): """Trace un triangle (equilatéral) à l'aide du crayon f :: param ftr(Turtle) :: la référence du crayon :: param cote(int) :: la valeur en pixel des côtés :: return (None) :: fonction sans retour .. effet de bord :: modifie l'état de ftr """ trois(ftr, cote, 120) def trace_triangle(ecrit, fd, epaisseur, cx, cy, c): """Trace un triangle (equilatéral) en (x, y) dans l'application graphique :: param ecrit(str) :: une couleur autorisée (pour l'écriture) :: param fd(str) :: une couleur autorisée (pour le fond éventuel) :: param epaisseur(int) :: la largeur d'écriture :: param cx(int) :: coordonnée horizontale (abscisse) :: param cy(int) :: coordonnée verticale (ordonnée) :: param c(int) :: la valeur en pixel des côtés :: return (Turtle) :: renvoie la référence du crayon ayant servi à dessiner """ pass def rapide_triangle(cx, cy, c): """Trace un triangle (equilatéral) en (x, y) dans l'application graphique :: param cx(int) :: coordonnée horizontale (abscisse) :: param cy(int) :: coordonnée verticale (ordonnée) :: param c(int) :: la valeur en pixel des côtés :: return (Turtle) :: renvoie la référence du crayon ayant servi à dessiner """ return trace_triangle("blue", "orange", 3, cx, cy, c) # Programme s1 = nouveau_stylo("red","black", 4) trois(s1, 100, 90) s1.setheading(0) deplacer(s1, 200, 50) trois(s1, 50, 45)

    Pour rappel, setheading() sert à faire pointer la tortue dans une direction particulière.

  3. 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.
  4. De façon plus professionnelle, taper ceci dans la console de façon à afficher la documentation dans la console :
  5. >>> 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
def 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 """ for _ in range(3): feutre.forward(distance) feutre.left(angle)

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.

.. .. .. .. .. .. .. .. .. .. .. .. .. .. .. .. .. .. ..
... def triangle(ftr, cote): """Trace un triangle (equilatéral) à l'aide du crayon f :: param ftr(Turtle) :: la référence du crayon :: param cote(int) :: la valeur en pixel des côtés :: return (None) :: fonction sans retour .. effet de bord :: modifie l'état de ftr """ trois(ftr, cote, 120) ... # Programme s1 = nouveau_stylo("red","black", 4) triangle(s1, 150)

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 :

.. .. .. ..
# Programme s1 = nouveau_stylo("red","black", 4) triangle(s1, 150)

    Questions

  1. Que contiennent les paramètres ftr et cote lorsqu'on lance triangle(s1150) ?
  2. Que contiennent alors les paramètres feutre, distance et angle lorsqu'on lance trois(ftr, cote, 120) ?

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
def triangle(ftr, cote): ... triangle(s1, 150)

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
def trois(feutre, distance, angle): ... trois(ftr, cote, 120)

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 :

  1. Regarder la documentation de trace_triangle() pour voir quels sont les paramètres à fournir lors d'un appel et dans quel ordre les fournir.

  2. Compléter ensuite la fonction trace_triangle() dont les instructions internes doivent réaliser ceci :
    1. Créer un nouveau stylo f (en utilisant nouveau_stylo())
    2. Déplacer ce stylo en (x,y) (en utilisant deplacer())
    3. Demander de surveiller le dessin en vu de faire du remplissage ensuite (avec f.begin_fill())
    4. Dessiner un triangle à cet endroit (en utilisant triangle())
    5. Demander de remplir la forme qu'on vient de créer (avec f.end_fill())
    6. Demander de cacher le feutre-tortue (avec f.hideturtle())
    7. Renvoyer la référence f
  3. Tester en lançant le programme principal suivant qui ne comporte plus que cette uniquement instruction : un appel à votre nouvelle fonction.
  4. 1 2 3 4 5
    ... # Programme trace_triangle("blue", "yellow", 4, 50, 50, 200)

...CORRECTION...

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19
def trace_triangle(ecrit, fd, epaisseur, cx, cy, c): """Trace un triangle (equilatéral) en (x, y) dans l'application graphique :: param ecrit(str) :: une couleur autorisée (pour l'écriture) :: param fd(str) :: une couleur autorisée (pour le fond éventuel) :: param epaisseur(int) :: la largeur d'écriture :: param cx(int) :: coordonnée horizontale (abscisse) :: param cy(int) :: coordonnée verticale (ordonnée) :: param c(int) :: la valeur en pixel des côtés :: return (Turtle) :: renvoie la référence du crayon ayant servi à dessiner """ f = nouveau_stylo(ecrit, fd, epaisseur) deplacer(f, cx, cy) f.begin_fill() triangle(f, c) f.end_fill() f.hideturtle() return f
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
def rapide_triangle(cx, cy, c): """Trace un triangle (equilatéral) en (x, y) dans l'application graphique :: param cx(int) :: coordonnée horizontale (abscisse) :: param cy(int) :: coordonnée verticale (ordonnée) :: param c(int) :: la valeur en pixel des côtés :: return (Turtle) :: renvoie la référence du crayon ayant servi à dessiner """ return trace_triangle("blue", "orange", 3, cx, cy, c)

Tester en utilisant ce nouveau programme principal :

1 2 3 4 5 6 7
... # Programme t1 = rapide_triangle(0, 0, 100) t2 = rapide_triangle(50, 90, 100) t3 = rapide_triangle(-50, 90, 100)

Vous devriez obtenir ceci :

✎ 10° Travail à réaliser :

  1. Rajouter la fonction dessin1() (dans la partie DECLARATION DES FONCTIONS),
  2. 1 2 3 4 5 6 7
    def dessin1(): """Réalise le dessin voulu :: return (None) :: Aucun retour """ pass
  3. lire sa documentation pour remarquer qu'elle ne reçoit aucune information,
  4. compléter pour que son appel provoque le dessin précédent : trois triangles,
  5. tester votre fonction en utilisant ce nouveau programme principal :

    1 2 3 4 5
    ... # Programme dessin1()

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 :

  1. Rajouter la fonction quatre() (dans la partie DECLARATION DES FONCTIONS),
  2. 1 2 3 4 5 6 7 8 9 10
    def quatre(feutre, distance, angle): """Fait avancer le crayon de la distance, tourne de l'angle donné. Quatre 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 """ pass
  3. lire sa documentation pour connaître ses paramètres et leur ordre,
  4. compléter de façon à ce qu'elle réalise 4 fois la séquence : trace un trait, tourne de l'angle.
  5. tester votre fonction en utilisant ce nouveau programme principal :

    1 2 3
    # Programme s1 = nouveau_stylo("red","black", 4) quatre(s1, 150, 90)

✎ 12° Travail à réaliser :

  1. Rajouter la fonction carre() (dans la partie DECLARATION DES FONCTIONS),
  2. 1 2 3 4 5 6 7 8 9 10
    def carre(ftr, cote): """Trace un carre à l'aide du crayon f :: param ftr(Turtle) :: la référence du crayon :: param cote(int) :: la valeur en pixel des côtés :: return (None) :: fonction sans retour .. effet de bord :: modifie l'état de ftr """ pass
  3. lire sa documentation pour connaître ses paramètres et leur ordre,
  4. compléter de façon à ce qu'elle trace un carré en utilisant... la fonction quatre().
  5. tester votre fonction en utilisant ce nouveau programme principal :

    1 2 3
    # Programme s1 = nouveau_stylo("green","black", 4) carre(s1, 150)

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 :

  1. création d'un stylo,
  2. déplacement du stylo au bon endroit,
  3. 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
def trace_carre(ecrit, fd, epaisseur, cx, cy, c): """Trace un carré en (x, y) dans l'application graphique :: param ecrit(str) :: une couleur autorisée (pour l'écriture) :: param fd(str) :: une couleur autorisée (pour le fond éventuel) :: param epaisseur(int) :: la largeur d'écriture :: param cx(int) :: coordonnée horizontale (abscisse) :: param cy(int) :: coordonnée verticale (ordonnée) :: param c(int) :: la valeur en pixel des côtés :: return (Turtle) :: renvoie la référence du crayon ayant servi à dessiner """ f = nouveau_stylo(ecrit, fd, epaisseur) deplacer(f, cx, cy) f.begin_fill() carre(f, c) f.end_fill() f.hideturtle() return f
3 - Méthodologie de programmation

Lorsqu'on vous demande de réaliser une fonction, il faut donc

  1. 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,
  2. lire la documentation pour savoir ce que sont les paramètres de votre fonction
  3. rajouter le code interne permettant de travailler (en utilisant si besoin d'autres fonctions) sans dépasser la vingtaine de lignes.
  4. Tester votre fonction.

✎ 14° Travail à réaliser :

  1. Rajouter la fonction tour() (dans la partie DECLARATION DES FONCTIONS),
  2. 1 2 3 4 5 6 7
    def tour(): """Réalise le dessin voulu :: return (None) :: Aucun retour """ pass
  3. lire sa documentation pour voir qu'elle n'attend aucun paramètre,
  4. compléter de façon à ce qu'elle trace cette tour en lançant 6 appels à ... la fonction trace_carre().
  5. tester votre fonction en utilisant ce nouveau programme principal :

    1 2 3 4 5
    ... # Programme tour()

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
def arc_de_cercle(feutre, rayon, angle): """Trace l'arc de cercle voulu. :: param feutre(Turtle) :: la référence du crayon :: param rayon(int) :: le rayon de l'arc de cercle :: param angle(int) :: l'angle de rotation en degrés :: return (None) :: fonction sans retour """ feutre.circle(rayon, angle) def cercle(ftr, rayon): """Trace un cercle à l'aide du crayon f :: param ftr(Turtle) :: la référence du crayon :: param rayon(int) :: la valeur en pixels du rayon :: return (None) :: fonction sans retour .. effet de bord :: modifie l'état de ftr """ arc_de_cercle(ftr, rayon, 360) def trace_disque(ecrit, fd, epaisseur, cx, cy, r): """Trace un disque coloré en (x, y) dans l'application graphique :: param ecrit(str) :: une couleur autorisée (pour l'écriture) :: param fd(str) :: une couleur autorisée (pour le fond éventuel) :: param epaisseur(int) :: la largeur d'écriture :: param cx(int) :: coordonnée horizontale (abscisse) :: param cy(int) :: coordonnée verticale (ordonnée) :: param r(int) :: la valeur en pixels du rayon :: return (Turtle) :: renvoie la référence du crayon ayant servi à dessiner """ f = nouveau_stylo(ecrit, fd, epaisseur) deplacer(f, cx, cy) f.begin_fill() cercle(f, r) f.end_fill() f.hideturtle() return f

✎ 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
feutre.forward(distance) feutre.left(angle)

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().

Il faut donc veiller à ce qu'une fonction ne soit conçue que pour répondre à UNE tâche.

On retiendra que pour réaliser une tâĉhe un peu complexe, il faut :

  • isoler les tâches basiques dans des fonctions
  • réaliser les tâches "moyennes" à l'aide de fonctions qui utilisent les tâches basiques
  • réaliser les tâches complexes en utilisant les fonctions basiques et moyennes précédentes

Une sorte d'emboîtement.

Activité publiée le 01 11 2020
Dernière modification : 13 07 2023
Auteur : ows. h.