fbpx

Comment coder l’escargot de Pythagore en Python ?

Partage cet article sur tes réseaux sociaux

Partager sur facebook
Partager sur linkedin
Partager sur twitter
Partager sur email

Tu te rappelles du théorème de Pythagore que tu as découvert en 3ème et qui dit que dans une triangle ABC rectangle en B, on a AB² + BC² = AC², le côté AC s’appelle l’hypoténuse. Hé bien c’est grâce à ce théorème et le principe de récurrence que nous allons construire l’escargot de Pythagore. 

Pour cela, on part d’un triangle rectangle isocèle de longueur l qui nous génère un hypoténuse de longueur l*racine(2) et avec ce nouvel hypoténuse on recrée un triangle rectangle on lui ajoutant un côté de longueur l. 

Pour coder l’escargot de Pythagore, il faut donc comprendre la récurrence. En programmation informatique, un algorithme récurrent et un algorithme qui s’appelle lui même. Mais cela ne suffit pas, afin d’éviter que les appels durent à l’infini, une condition de sortie doit apparaitre, assez tôt dans le code avant l’appel de la fonction.

Dans cet article on va commencer par reprendre un exemple simple de fonction de récurrence, celui du calcul de la fonction factorielle pour identifier l’appel récurrent et la condition de sortie

Avant l'escargot de Pythagore, la fonction factorielle

Très utilisées en probabilités, les fonctions factorielles sont simples à comprendre. Il suffit de multiplier les nombres en décrémentant jusqu’à 1. Rien de bien compliquer. La notation avec le point d’exclamation placée après le nombre nous induit d’ailleurs en erreur. On aurait tendance à dire pour le chiffre 5: 5 factorielle alors que la bonne expression pour expression est de dire fonction de l’antécédent comme “f de x” pour f(x). Ainsi disons plutôt factorielle de 5 !

Mais que vaut factorielle de 5 et comme cela s’écrit -il ? Sans parenthèse et en toute simplicité écrivons que 5! = 5x4x3x2x1

Mais si on regarde de plus près on constate que 5! est égal à 5×4!

En effet il suffit de distinguer les deux facteurs de la manière suivantes: 5! = (5)x(4x3x2x1) et comme 4! = 4x3x2x1 on a bien que 5! = 5×4!

Vous en déduirez que par récurrence 5! = 5 x 4 x 3!. On peut donc appeler la fonction factorielle sur 3 et sur 4 en voulant la calculer sur 5. C’est là que nait l’idée de la récurrence.

Et si on écrivait tout simplement :

1 def factorielle(a):
2    a*factorielle(a-1)
3
4 factorielle(5)

 On arrive rapidement à une erreur car l’interpreteur nous indique : “RecursionError: maximum recursion depth exceeded” Logique, on indique pas quand l’appel de la fonction factorielle doit s’arrête.

C’est là qu’intervient la condition de sortie. On peut déjà restreindre au nombre positif ? C’est une bonne idée ! La fonction devient alors:

1 def factorielle(a):
2    if (a>1):
3        return a*factorielle(a-1)
4    else:
5        return 1
6
7 factorielle(5)

Dans ce code, si on veut calculer la factorielle de 6, il faut le changer dans le code et relancer le script. pour éviter celà, nous allons utiliser la fonction input qui permet de demander à l’utilisateur d’entrer un nombre.

L’appel de la fonction input renvoie une chaine de caractère, c’est pourquoi on le suivre d’une conversion de type. Et pour avoir un script qui réitère la demande d’un nombre, on implémentera le tout à l’intérieur d’une boucle “while”. Voici le code amélioré: 

1  def factorielle(a):
2      if(a > 1):
3          return a*factorielle(a-1)
4      else:
5          return 1
6  
7  while(True):
8      nombre = input("Entrez un nombre: ")
9      num = int(nombre)
10     print(factorielle(num))

Après la fonction factorielle, l'escargot de Pythagore

Maintenant que nous avons compris le principe de l’implémentation de la récurrence, à savoir l’appel de la fonction à elle-même et la condition de sortie. Nous sommes prêts pour implémenter l’escargot de Pythagore. Il s’agit de réaliser une dessin et nous allons utiliser le module “turtle” qui est le module graphique le plus accessible

La première chose à faire est de dessiner un triangle rectangle isocèle avec le module turtle

1  from turtle import*
2  
3  forward(100)
4  left(90)
5  forward(100)

Mais réfléchissons un instant, qu’est ce que l’escargot de Pythagore, c’est une succession de triangle dont l’hypoténuse est recalculé à chaque étape en fonction de l’hypoténuse précédent.

Il faut donc créer une fonction “hypo_k” qui dépdent de “hypo_k_moins_1”. On doit être cacpable de calculer l’hypoténuse hypo_k avec le théorème de Pythagore mais il faut aussi calculer l’angle adjacent au côté mesurant une unité. On utilisera la fonction “acos” pour cela. Voici le code pour cette partie:

1  from turtle import*
2  from math import*
3  
4  def hypo_k(hypo_k_moins_1):
5      hypo_k = sqrt(hypo_k_moins_1**2 + 1)
6      angle = acos(1/hypo_k)
7      return hypo_k, angle
8  
9
10  forward(100)
11  left(90)
12  forward(100)

Créons une fonction “escargot” qui dessine un triangle avec la récurrence appropriée et un appel de fonction pour lancer le programme

1  from turtle import*
2  from math import*
3  
4   def hypo_k(hypo_k_moins_1):
5      hypo_k = sqrt(hypo_k_moins_1**2 + 1)
6      angle = acos(1/hypo_k)
7      return hypo_k, angle
8  
9
10  def escargot(hypo):
11     if(hypo > 4):
12         return
13     forward(100*hypo)
14     left(90)
15     forward(100)
16     hypo, angle = hypo_n(hypo)
17     left(180-degrees(angle))
18     forward(100*hypo)
19     escargot(hypo)
20
21  escargot(1)
22  done()

On s’aperçoit qu’il y a un petit problème, les triangles sont mal placés. On le voit avec les numéros 1, 2 et 3. En observant de plus près on voit que le triangle 2 est fait dans la prolongation du triangle 1. C’est à dire que quand l’hypoténuse du triangle 1 est dessiné, la stylo continu tout droit pour dessiner le triangle 2. Il suffit de le réorienter en le tournant d’un demi-tour c’est à dire 180°. Ajoutons la ligne de code left(180) à la ligne 13 afin de réorienter le stylo avant de dessiner le triangle suivant.

1  from turtle import*
2  from math import*
3  
4   def hypo_k(hypo_k_moins_1):
5      hypo_k = sqrt(hypo_k_moins_1**2 + 1)
6      angle = acos(1/hypo_k)
7      return hypo_k, angle
8  
9
10  def escargot(hypo):
11     if(hypo > 4):
12         return
13     left(180)
14     forward(100*hypo)
15     left(90)
16     forward(100)
17     hypo, angle = hypo_n(hypo)
18     left(180-degrees(angle))
19     forward(100*hypo)
20     escargot(hypo)
21
22  escargot(1)
23  done()

Une simple ligne de code left(180) a changé radicalement l’allure de la figure. C’est fou ! Maintenant, il nous manque les couleur pour embellir la figure et distinguer les triangles ! Il faudrait générer une couleur aléatoire avant de dessiner le triangle. 

Si tu souhaites te former à Python pour réviser les bases de ce langage alors tu peux visiter notre webinaire co-organisé avec Hachette Technique

Le code complet

Pour cela, nous allons générer 3 nombre pour les 3 couleurs primaires avec la fonction uniform. Ces valeurs passeront en  argument d’une autre fonction du module turtle, la fonction fillcolor. Voici le code finalisé:

1   from turtle import*
2   from math import*
3   from random import uniform
4
5   def change_color():
6       e1 = uniform(0,1)
7       e2 = uniform(0,1)
8       e3 = uniform(0,1)
9       return e1,e2,e3
10
11  def hypo_n(hypo_n_moins_1):
12      hypo_n = sqrt(hypo_n_moins_1**2 + 1)
13      angle = acos(1/hypo_n)
14      return hypo_n, angle
15    
16  def escargot(hypo):
17      if(hypo > 4):
18          return
19      left(180)
20      e1,e2,e3 = change_color()
21      fillcolor(e1,e2,e3)
22      begin_fill()
23      forward(100*hypo)
24      left(90)
25      forward(100)
26      hypo, angle = hypo_n(hypo)
27      left(180-degrees(angle))
28      forward(100*hypo)
29      end_fill()
30      escargot(hypo)
31  
32  escargot(1)
33  done()

S'incrire à la Newsletter Evolukode

Reste informé des nouveaux cours, de nos actualités, de nos derniers articles. Participe à nos jeux concours exclusifs, et à bien d'autres choses! Bref tu es au courant de tout avant tout le monde !

Nos autres articles

Connaissez-vous nos formules d'abonnements ?

Profitez d'un accès à tous nos parcours e-learning

Retour haut de page