« Mathématiques avec Python et Ruby/Une tortue qui accélère la résolution de problèmes » : différence entre les versions
m <source> -> <syntaxhighlight> (phab:T237267) |
|||
Ligne 7 : | Ligne 7 : | ||
Avant d'utiliser la tortue de ''Python'', on doit l'importer, en faisant |
Avant d'utiliser la tortue de ''Python'', on doit l'importer, en faisant |
||
< |
<syntaxhighlight lang="python"> |
||
from turtle import * |
from turtle import * |
||
</syntaxhighlight> |
|||
</source> |
|||
Ensuite, une connaissance du vocabulaire de situation et de déplacement en anglais peut aider; en voici un échantillon: |
Ensuite, une connaissance du vocabulaire de situation et de déplacement en anglais peut aider; en voici un échantillon: |
||
Ligne 38 : | Ligne 38 : | ||
Pour représenter l'addition de 21 et 34, on peut tout simplement entrer |
Pour représenter l'addition de 21 et 34, on peut tout simplement entrer |
||
< |
<syntaxhighlight lang="python"> |
||
from turtle import * |
from turtle import * |
||
Ligne 45 : | Ligne 45 : | ||
print(position()) |
print(position()) |
||
</syntaxhighlight> |
|||
</source> |
|||
Ce qui oblige à ignorer une information superflue (l'ordonnée de la tortue). La variante suivante permet d'éviter cela: |
Ce qui oblige à ignorer une information superflue (l'ordonnée de la tortue). La variante suivante permet d'éviter cela: |
||
< |
<syntaxhighlight lang="python"> |
||
reset() |
reset() |
||
forward(21) |
forward(21) |
||
Ligne 55 : | Ligne 55 : | ||
print(distance(0,0)) |
print(distance(0,0)) |
||
</syntaxhighlight> |
|||
</source> |
|||
Ligne 62 : | Ligne 62 : | ||
Pour soustraire 21 à 34, il suffit de faire reculer la tortue au lieu de la faire avancer: |
Pour soustraire 21 à 34, il suffit de faire reculer la tortue au lieu de la faire avancer: |
||
< |
<syntaxhighlight lang="python"> |
||
reset() |
reset() |
||
forward(34) |
forward(34) |
||
Ligne 68 : | Ligne 68 : | ||
print(position()) |
print(position()) |
||
</syntaxhighlight> |
|||
</source> |
|||
Si on intervertit l'amplitude des mouvements, on découvre que ''Python'' choisit d'afficher négativement une position à gauche de l'origine: |
Si on intervertit l'amplitude des mouvements, on découvre que ''Python'' choisit d'afficher négativement une position à gauche de l'origine: |
||
< |
<syntaxhighlight lang="python"> |
||
reset() |
reset() |
||
forward(21) |
forward(21) |
||
Ligne 78 : | Ligne 78 : | ||
print(position()) |
print(position()) |
||
</syntaxhighlight> |
|||
</source> |
|||
Assez naturellement, on est amené à poser 21-34=-13: Découverte expérimentale des nombres négatifs... |
Assez naturellement, on est amené à poser 21-34=-13: Découverte expérimentale des nombres négatifs... |
||
Ligne 91 : | Ligne 91 : | ||
Pour additionner deux nombres négatifs, on peut faire |
Pour additionner deux nombres négatifs, on peut faire |
||
< |
<syntaxhighlight lang="python"> |
||
reset() |
reset() |
||
backward(34) |
backward(34) |
||
Ligne 97 : | Ligne 97 : | ||
position() |
position() |
||
</syntaxhighlight> |
|||
</source> |
|||
Tout ceci permet assez rapidement d'explorer les différents autres cas de figure (deux cas différents pour la somme de deux nombres de signes différents). Puis la découverte spontanée du fait que les deux instructions suivantes ont le même effet: |
Tout ceci permet assez rapidement d'explorer les différents autres cas de figure (deux cas différents pour la somme de deux nombres de signes différents). Puis la découverte spontanée du fait que les deux instructions suivantes ont le même effet: |
||
< |
<syntaxhighlight lang="python"> |
||
forward(-34) |
forward(-34) |
||
backward(34) |
backward(34) |
||
</syntaxhighlight> |
|||
</source> |
|||
Ce qui facilite grandement l'exploration de la soustraction de deux nombres relatifs: |
Ce qui facilite grandement l'exploration de la soustraction de deux nombres relatifs: |
||
Ligne 112 : | Ligne 112 : | ||
Pour calculer 34-(-21), on peut faire |
Pour calculer 34-(-21), on peut faire |
||
< |
<syntaxhighlight lang="python"> |
||
reset() |
reset() |
||
forward(34) |
forward(34) |
||
Ligne 118 : | Ligne 118 : | ||
position() |
position() |
||
</syntaxhighlight> |
|||
</source> |
|||
Pour l'apprentissage des opérations sur les nombres négatifs, ''turtle'' constitue un [[w:Micromonde|outil expérimental]] intéressant à explorer. |
Pour l'apprentissage des opérations sur les nombres négatifs, ''turtle'' constitue un [[w:Micromonde|outil expérimental]] intéressant à explorer. |
||
Ligne 126 : | Ligne 126 : | ||
De même, les deux instructions suivantes ont le même effet (rotation de 60° vers la gauche): |
De même, les deux instructions suivantes ont le même effet (rotation de 60° vers la gauche): |
||
< |
<syntaxhighlight lang="python"> |
||
left(60) |
left(60) |
||
right(-60) |
right(-60) |
||
</syntaxhighlight> |
|||
</source> |
|||
mais ce n'est nullement évident pour des lycéens qui n'ont jamais fait ce genre de manipulation, surtout depuis que la notion de [[w:rotation plane|rotation]] a totalement disparu de l'enseignement des mathématiques. Pourtant le module ''turtle'' permet de visualiser l'addition des angles et d'introduire des notions comme celle d'angles [[w:angles complémentaires|complémentaires]] ou [[w:angles supplémentaires|supplémentaires]] avec |
mais ce n'est nullement évident pour des lycéens qui n'ont jamais fait ce genre de manipulation, surtout depuis que la notion de [[w:rotation plane|rotation]] a totalement disparu de l'enseignement des mathématiques. Pourtant le module ''turtle'' permet de visualiser l'addition des angles et d'introduire des notions comme celle d'angles [[w:angles complémentaires|complémentaires]] ou [[w:angles supplémentaires|supplémentaires]] avec |
||
< |
<syntaxhighlight lang="python"> |
||
left(30) |
left(30) |
||
left(60) |
left(60) |
||
</syntaxhighlight> |
|||
</source> |
|||
Ligne 149 : | Ligne 149 : | ||
La [[w:planche de Galton|planche de Galton]] réalise une [[w:marche aléatoire|marche aléatoire]] de dimension 1 (le mouvement vertical de la bille n'ayant aucune influence sur le numéro de la case où elle aboutit). On peut donc simuler le mouvement d'une bille avec ce script: |
La [[w:planche de Galton|planche de Galton]] réalise une [[w:marche aléatoire|marche aléatoire]] de dimension 1 (le mouvement vertical de la bille n'ayant aucune influence sur le numéro de la case où elle aboutit). On peut donc simuler le mouvement d'une bille avec ce script: |
||
< |
<syntaxhighlight lang="python"> |
||
from turtle import * |
from turtle import * |
||
from random import * |
from random import * |
||
Ligne 160 : | Ligne 160 : | ||
print(position()) |
print(position()) |
||
</syntaxhighlight> |
|||
</source> |
|||
On peut améliorer ce script en utilisant ''randrange'' qui va de -1 à 1 (donc 2 exclu) par pas de 2, ce qui économise un test: |
On peut améliorer ce script en utilisant ''randrange'' qui va de -1 à 1 (donc 2 exclu) par pas de 2, ce qui économise un test: |
||
< |
<syntaxhighlight lang="python"> |
||
from turtle import * |
from turtle import * |
||
from random import * |
from random import * |
||
Ligne 172 : | Ligne 172 : | ||
print(position()) |
print(position()) |
||
</syntaxhighlight> |
|||
</source> |
|||
==Statistiques sur 100 billes== |
==Statistiques sur 100 billes== |
||
Ligne 178 : | Ligne 178 : | ||
Pour effectuer des statistiques sur 100 billes, on a intérêt à accélérer la tortue, avec |
Pour effectuer des statistiques sur 100 billes, on a intérêt à accélérer la tortue, avec |
||
< |
<syntaxhighlight lang="python"> |
||
from turtle import * |
from turtle import * |
||
from random import * |
from random import * |
||
Ligne 185 : | Ligne 185 : | ||
hideturtle() |
hideturtle() |
||
penup() |
penup() |
||
</syntaxhighlight> |
|||
</source> |
|||
Ensuite on crée un tableau d'effectifs pour simuler le bas de la planche de Galton: |
Ensuite on crée un tableau d'effectifs pour simuler le bas de la planche de Galton: |
||
< |
<syntaxhighlight lang="python"> |
||
effectifs=[0 for x in range(-24,25)] |
effectifs=[0 for x in range(-24,25)] |
||
</syntaxhighlight> |
|||
</source> |
|||
Après ça il n'y a plus qu'à remplir le tableau en recommençant 100 fois l'expérience précédente (lancer d'une bille): |
Après ça il n'y a plus qu'à remplir le tableau en recommençant 100 fois l'expérience précédente (lancer d'une bille): |
||
< |
<syntaxhighlight lang="python"> |
||
from turtle import * |
from turtle import * |
||
from random import * |
from random import * |
||
Ligne 207 : | Ligne 207 : | ||
forward(randrange(-1,2,2)) |
forward(randrange(-1,2,2)) |
||
effectifs[int(xcor()]+=1 |
effectifs[int(xcor()]+=1 |
||
</syntaxhighlight> |
|||
</source> |
|||
Ce script, bien qu'assez court, met du temps à s'exécuter (de l'ordre d'une minute). Pour l'accélérer, on peut ajouter un degré d'abstraction en n'utilisant pas la tortue. En effet, chaque pas est égal à -1 ou 1 au hasard, donc d'après ce qu'on a vu au début de ce chapitre (opérations sur les nombres relatifs), on ne fait qu'additionner 24 nombres égaux à 1 ou -1, ce qui donne ce script: |
Ce script, bien qu'assez court, met du temps à s'exécuter (de l'ordre d'une minute). Pour l'accélérer, on peut ajouter un degré d'abstraction en n'utilisant pas la tortue. En effet, chaque pas est égal à -1 ou 1 au hasard, donc d'après ce qu'on a vu au début de ce chapitre (opérations sur les nombres relatifs), on ne fait qu'additionner 24 nombres égaux à 1 ou -1, ce qui donne ce script: |
||
< |
<syntaxhighlight lang="python"> |
||
from random import * |
from random import * |
||
effectifs=[0 for x in range(-24,25)] |
effectifs=[0 for x in range(-24,25)] |
||
for n in range(100): |
for n in range(100): |
||
effectifs[sum(randrange(-1,2,2) for h in range(24))]+=1 |
effectifs[sum(randrange(-1,2,2) for h in range(24))]+=1 |
||
</ |
</syntaxhighlight> |
||
Cette fois-ci, l'effet est presque instantané. |
Cette fois-ci, l'effet est presque instantané. |
||
Ligne 224 : | Ligne 224 : | ||
Une fois le tableau d'effectifs rempli, le module ''turtle'' peut le représenter graphiquement sous forme d'un polygone des effectifs. Comme la méthode précédente est très rapide et que les effectifs des nombres impairs sont nuls, on va plutôt utiliser la variante suivante, avec 256 cases et 1000 essais: |
Une fois le tableau d'effectifs rempli, le module ''turtle'' peut le représenter graphiquement sous forme d'un polygone des effectifs. Comme la méthode précédente est très rapide et que les effectifs des nombres impairs sont nuls, on va plutôt utiliser la variante suivante, avec 256 cases et 1000 essais: |
||
< |
<syntaxhighlight lang="python"> |
||
from turtle import * |
from turtle import * |
||
from random import * |
from random import * |
||
Ligne 234 : | Ligne 234 : | ||
for x in range(256): |
for x in range(256): |
||
goto(x,effectifs[x]) |
goto(x,effectifs[x]) |
||
</ |
</syntaxhighlight> |
||
On obtient alors un histogramme de ce genre (la tortue est encore visible à droite): |
On obtient alors un histogramme de ce genre (la tortue est encore visible à droite): |
||
Ligne 250 : | Ligne 250 : | ||
Comme le script qui va dessiner le triangle fractal sera assez long, on va utiliser des abréviations: ''fd'' au lieu de ''forward'', ''lt'' au lieu de ''left'' et ''rt'' au lieu de ''right''. Alors pour dessiner un triangle on peut faire ceci: |
Comme le script qui va dessiner le triangle fractal sera assez long, on va utiliser des abréviations: ''fd'' au lieu de ''forward'', ''lt'' au lieu de ''left'' et ''rt'' au lieu de ''right''. Alors pour dessiner un triangle on peut faire ceci: |
||
< |
<syntaxhighlight lang="python"> |
||
from turtle import * |
from turtle import * |
||
fd(100); rt(120); fd(100); rt(120); fd(100); rt(120) |
fd(100); rt(120); fd(100); rt(120); fd(100); rt(120) |
||
</syntaxhighlight> |
|||
</source> |
|||
Ou mieux, en stockant ce programme en Python dans une variable ''programme'': |
Ou mieux, en stockant ce programme en Python dans une variable ''programme'': |
||
< |
<syntaxhighlight lang="python"> |
||
from turtle import * |
from turtle import * |
||
programme='fd(100); rt(120); fd(100); rt(120); fd(100); rt(120)' |
programme='fd(100); rt(120); fd(100); rt(120); fd(100); rt(120)' |
||
exec(programme) |
exec(programme) |
||
</syntaxhighlight> |
|||
</source> |
|||
Dans un premier temps, on va abréger encore plus, en notant chaque instruction de ce programme par une seule lettre: |
Dans un premier temps, on va abréger encore plus, en notant chaque instruction de ce programme par une seule lettre: |
||
Ligne 277 : | Ligne 277 : | ||
Alors le programme pour créer un programme qui dessine un triangle devient: |
Alors le programme pour créer un programme qui dessine un triangle devient: |
||
< |
<syntaxhighlight lang="python"> |
||
from turtle import * |
from turtle import * |
||
from re import * |
from re import * |
||
Ligne 285 : | Ligne 285 : | ||
programme=sub('m','rt(120); ',programme) |
programme=sub('m','rt(120); ',programme) |
||
exec(programme) |
exec(programme) |
||
</syntaxhighlight> |
|||
</source> |
|||
Le remplacement des lettres mnémotechniques par des instructions en Python est à l'image de ce que fait un [[w:compilateur|compilateur]] comme celui de Python. Avec ça, au moins, la recette pour dessiner un triangle est facile à retenir: ''avancer; tourner; avancer; tourner; avancer; tourner'', étant entendu que chaque fois qu'on avance, c'est de 100 pixels, et chaque fois qu'on tourne, c'est de 120° vers la droite. |
Le remplacement des lettres mnémotechniques par des instructions en Python est à l'image de ce que fait un [[w:compilateur|compilateur]] comme celui de Python. Avec ça, au moins, la recette pour dessiner un triangle est facile à retenir: ''avancer; tourner; avancer; tourner; avancer; tourner'', étant entendu que chaque fois qu'on avance, c'est de 100 pixels, et chaque fois qu'on tourne, c'est de 120° vers la droite. |
||
Ligne 293 : | Ligne 293 : | ||
Pour transformer le triangle en flocon, on doit remplacer chaque instruction ''avancer'' par la séquence ''avancer; gauche; avancer; droite; avancer; gauche; avancer''. Du moment que chaque fois qu'on avance, c'est du même nombre de pixels (par exemple 81) et chaque fois qu'on tourne à gauche, c'est de 60° et chaque fois qu'on tourne à droite, c'est de 120°. Pour obtenir cet effet, il suffit de remplacer chaque ''A'' par ''ApAmApA'': |
Pour transformer le triangle en flocon, on doit remplacer chaque instruction ''avancer'' par la séquence ''avancer; gauche; avancer; droite; avancer; gauche; avancer''. Du moment que chaque fois qu'on avance, c'est du même nombre de pixels (par exemple 81) et chaque fois qu'on tourne à gauche, c'est de 60° et chaque fois qu'on tourne à droite, c'est de 120°. Pour obtenir cet effet, il suffit de remplacer chaque ''A'' par ''ApAmApA'': |
||
< |
<syntaxhighlight lang="python"> |
||
from turtle import * |
from turtle import * |
||
from re import * |
from re import * |
||
Ligne 305 : | Ligne 305 : | ||
programme=sub('p','lt(60); ',programme) |
programme=sub('p','lt(60); ',programme) |
||
exec(programme) |
exec(programme) |
||
</syntaxhighlight> |
|||
</source> |
|||
Ce script dessine bien une étoile: |
Ce script dessine bien une étoile: |
||
Ligne 315 : | Ligne 315 : | ||
Pour finir le dessin du flocon fractal, il suffit d'itérer le remplacement de chaque ''A'' par ''ApAmApA'': |
Pour finir le dessin du flocon fractal, il suffit d'itérer le remplacement de chaque ''A'' par ''ApAmApA'': |
||
< |
<syntaxhighlight lang="python"> |
||
from turtle import * |
from turtle import * |
||
from re import * |
from re import * |
||
Ligne 328 : | Ligne 328 : | ||
programme=sub('p','lt(60); ',programme) |
programme=sub('p','lt(60); ',programme) |
||
exec(programme) |
exec(programme) |
||
</syntaxhighlight> |
|||
</source> |
|||
Ce script dessine ceci en 9 lignes de Python (la tortue donne une idée de l'échelle): |
Ce script dessine ceci en 9 lignes de Python (la tortue donne une idée de l'échelle): |
Version actuelle du 16 avril 2020 à 09:28
Depuis la version 2.6, Python possède un module appelé turtle et qui lui permet de faire du graphisme à la LOGO. Outre l'intérêt que peut présenter la consultation de son code source (on y trouve pratiquement tout ce qui est décrit dans les chapitres précédents sur la géométrie), ce module turtle permet de simplifier la résolution de certains problèmes et même d'introduire graphiquement certaines notions mathématiques. Le fil conducteur de ce chapitre est que la tortue LOGO peut mémoriser certaines données de position et se comporte comme une mémoire à la fois plus puissante et moins abstraite que les habituelles variables numériques.
Avant d'utiliser la tortue de Python, on doit l'importer, en faisant
from turtle import *
Ensuite, une connaissance du vocabulaire de situation et de déplacement en anglais peut aider; en voici un échantillon:
- forward ou fd: Pour avancer (l'unité de distance est le pixel)
- backward ou bk: Pour reculer
- left ou lt: Pour tourner à gauche (l'unité d'angle est le degré)
- right ou rt: Pour tourner à droite
- goto pour téléporter la tortue (donner l'abscisse puis l'ordonnée)
- penup() ou pu() pour que les déplacements de la tortue cessent de laisser des traces à l'écran
- pendown() ou pd() pour que les déplacements de la tortue recommencent à laisser des traces
- position() renvoie les coordonnées de la tortue
- home() renvoie la tortue au centre de l'écran (sa position initiale)
- reset() fait pareil mais en effaçant l'écran
- circle dessine un cercle (le rayon est en pixels)
- stamp() donne un coup de tampon sur l'écran, en laissant une empreinte de la tortue
L'écran n'apparaît que lors de l'exécution de la première instruction graphique (un forward par exemple). Sous Windows, il est déconseillé de laisser traîner la souris sur cet écran graphique. Dans les exemples qui suivent, l'export vectoriel au format eps du module TkInter (dont le module turtle hérite) a été utilisé pour produire des figures de meilleure qualité que celles qu'on voit sur l'écran de turtle.
Nombres relatifs[modifier | modifier le wikicode]
Les nombres (réels) peuvent être représentés par des graduations sur une droite, et donc par les emplacements de la tortue à l'écran.
Nombres positifs[modifier | modifier le wikicode]
Addition[modifier | modifier le wikicode]
Pour représenter l'addition de 21 et 34, on peut tout simplement entrer
from turtle import *
forward(21)
forward(34)
print(position())
Ce qui oblige à ignorer une information superflue (l'ordonnée de la tortue). La variante suivante permet d'éviter cela:
reset()
forward(21)
forward(34)
print(distance(0,0))
Soustraction[modifier | modifier le wikicode]
Pour soustraire 21 à 34, il suffit de faire reculer la tortue au lieu de la faire avancer:
reset()
forward(34)
backward(21)
print(position())
Si on intervertit l'amplitude des mouvements, on découvre que Python choisit d'afficher négativement une position à gauche de l'origine:
reset()
forward(21)
backward(34)
print(position())
Assez naturellement, on est amené à poser 21-34=-13: Découverte expérimentale des nombres négatifs...
Nombres négatifs[modifier | modifier le wikicode]
Une fois qu'on a vu des nombres négatifs, on peut chercher comment réaliser des opérations dessus:
Addition[modifier | modifier le wikicode]
Pour additionner deux nombres négatifs, on peut faire
reset()
backward(34)
backward(21)
position()
Tout ceci permet assez rapidement d'explorer les différents autres cas de figure (deux cas différents pour la somme de deux nombres de signes différents). Puis la découverte spontanée du fait que les deux instructions suivantes ont le même effet:
forward(-34)
backward(34)
Ce qui facilite grandement l'exploration de la soustraction de deux nombres relatifs:
Soustraction[modifier | modifier le wikicode]
Pour calculer 34-(-21), on peut faire
reset()
forward(34)
backward(-21)
position()
Pour l'apprentissage des opérations sur les nombres négatifs, turtle constitue un outil expérimental intéressant à explorer.
Angles orientés[modifier | modifier le wikicode]
De même, les deux instructions suivantes ont le même effet (rotation de 60° vers la gauche):
left(60)
right(-60)
mais ce n'est nullement évident pour des lycéens qui n'ont jamais fait ce genre de manipulation, surtout depuis que la notion de rotation a totalement disparu de l'enseignement des mathématiques. Pourtant le module turtle permet de visualiser l'addition des angles et d'introduire des notions comme celle d'angles complémentaires ou supplémentaires avec
left(30)
left(60)
Fonctions[modifier | modifier le wikicode]
On a vu dans un chapitre précédent comment la module turtle permet de représenter graphiquement une fonction.
Statistique[modifier | modifier le wikicode]
Chute d'une bille sur la planche de Galton[modifier | modifier le wikicode]
La planche de Galton réalise une marche aléatoire de dimension 1 (le mouvement vertical de la bille n'ayant aucune influence sur le numéro de la case où elle aboutit). On peut donc simuler le mouvement d'une bille avec ce script:
from turtle import *
from random import *
for n in range(24):
if random()<0.5:
forward(1)
else:
backward(1)
print(position())
On peut améliorer ce script en utilisant randrange qui va de -1 à 1 (donc 2 exclu) par pas de 2, ce qui économise un test:
from turtle import *
from random import *
for h in range(24):
forward(randrange(-1,2,2))
print(position())
Statistiques sur 100 billes[modifier | modifier le wikicode]
Pour effectuer des statistiques sur 100 billes, on a intérêt à accélérer la tortue, avec
from turtle import *
from random import *
speed=1000
hideturtle()
penup()
Ensuite on crée un tableau d'effectifs pour simuler le bas de la planche de Galton:
effectifs=[0 for x in range(-24,25)]
Après ça il n'y a plus qu'à remplir le tableau en recommençant 100 fois l'expérience précédente (lancer d'une bille):
from turtle import *
from random import *
speed=0
hideturtle()
penup()
for n in range(100):
home()
for h in range(24):
forward(randrange(-1,2,2))
effectifs[int(xcor()]+=1
Ce script, bien qu'assez court, met du temps à s'exécuter (de l'ordre d'une minute). Pour l'accélérer, on peut ajouter un degré d'abstraction en n'utilisant pas la tortue. En effet, chaque pas est égal à -1 ou 1 au hasard, donc d'après ce qu'on a vu au début de ce chapitre (opérations sur les nombres relatifs), on ne fait qu'additionner 24 nombres égaux à 1 ou -1, ce qui donne ce script:
from random import *
effectifs=[0 for x in range(-24,25)]
for n in range(100):
effectifs[sum(randrange(-1,2,2) for h in range(24))]+=1
Cette fois-ci, l'effet est presque instantané.
Dessin de l'histogramme[modifier | modifier le wikicode]
Une fois le tableau d'effectifs rempli, le module turtle peut le représenter graphiquement sous forme d'un polygone des effectifs. Comme la méthode précédente est très rapide et que les effectifs des nombres impairs sont nuls, on va plutôt utiliser la variante suivante, avec 256 cases et 1000 essais:
from turtle import *
from random import *
effectifs=[0 for x in range(256)]
for n in range(1000):
effectifs[sum(randrange(2) for h in range(256))]+=1
reset()
for x in range(256):
goto(x,effectifs[x])
On obtient alors un histogramme de ce genre (la tortue est encore visible à droite):
Fractales[modifier | modifier le wikicode]
La courbe de Von Koch est classiquement définie par la récursivité. Mais elle n'est pas nécessaire si on utilise une expression régulière. En fait, on peut écrire un script Python qui produit un script Python, puis exécuter celui-ci!
Triangle de départ[modifier | modifier le wikicode]
Comme le script qui va dessiner le triangle fractal sera assez long, on va utiliser des abréviations: fd au lieu de forward, lt au lieu de left et rt au lieu de right. Alors pour dessiner un triangle on peut faire ceci:
from turtle import *
fd(100); rt(120); fd(100); rt(120); fd(100); rt(120)
Ou mieux, en stockant ce programme en Python dans une variable programme:
from turtle import *
programme='fd(100); rt(120); fd(100); rt(120); fd(100); rt(120)'
exec(programme)
Dans un premier temps, on va abréger encore plus, en notant chaque instruction de ce programme par une seule lettre:
- A (comme avance) pour fd(100);
- p (comme plus) pour lt(60);
- m (comme moins) pour rt(120).
La traduction se fait par une RegExp, qui, tel un chien de douane, cherche toutes les occurences d'une lettre, et les remplace par le texte correspondant.
Alors le programme pour créer un programme qui dessine un triangle devient:
from turtle import *
from re import *
programme='AmAmAm'
programme=sub('A','fd(100); ',programme)
programme=sub('m','rt(120); ',programme)
exec(programme)
Le remplacement des lettres mnémotechniques par des instructions en Python est à l'image de ce que fait un compilateur comme celui de Python. Avec ça, au moins, la recette pour dessiner un triangle est facile à retenir: avancer; tourner; avancer; tourner; avancer; tourner, étant entendu que chaque fois qu'on avance, c'est de 100 pixels, et chaque fois qu'on tourne, c'est de 120° vers la droite.
Modification du script[modifier | modifier le wikicode]
Pour transformer le triangle en flocon, on doit remplacer chaque instruction avancer par la séquence avancer; gauche; avancer; droite; avancer; gauche; avancer. Du moment que chaque fois qu'on avance, c'est du même nombre de pixels (par exemple 81) et chaque fois qu'on tourne à gauche, c'est de 60° et chaque fois qu'on tourne à droite, c'est de 120°. Pour obtenir cet effet, il suffit de remplacer chaque A par ApAmApA:
from turtle import *
from re import *
programme='AmAmAm'
programme=sub('A','ApAmApA',programme)
programme=sub('A','fd(81); ',programme)
programme=sub('m','rt(120); ',programme)
programme=sub('p','lt(60); ',programme)
exec(programme)
Ce script dessine bien une étoile:
Dessin du triangle de Von Koch[modifier | modifier le wikicode]
Pour finir le dessin du flocon fractal, il suffit d'itérer le remplacement de chaque A par ApAmApA:
from turtle import *
from re import *
programme='AmAmAm'
for n in range(4):
programme=sub('A','ApAmApA',programme)
programme=sub('A','fd(2); ',programme)
programme=sub('m','rt(120); ',programme)
programme=sub('p','lt(60); ',programme)
exec(programme)
Ce script dessine ceci en 9 lignes de Python (la tortue donne une idée de l'échelle):
Voir aussi[modifier | modifier le wikicode]
Sur ce site, il y a un wikibook sur LOGO dont beaucoup d'idées sont transposables ici.