Écrire une fonction prenant en argument un tuple de nombres 'centre', et un nombre 'rayon' et dessinant un cercle de centre de coordonnées (centre[0],centre[1]) et de rayon 'rayon'.
On utilisera la fonction circle du module (voir le site de documentation python).
La fonction devra également dessiner le point centre (utiliser la fonction dot, voir le site de documentation).
from turtle import *
def cercle(centre, rayon ) :
"""centre = (x,y) centre du cercle.
rayon : rayon du cercle.
"""
setheading(0)
penup()
setposition(centre[0],centre[1]-rayon)
pendown()
circle(rayon,steps=200)
penup()
setposition(centre[0], centre[1])
dot(5,"red")
############ main ################################
setworldcoordinates(-2,-2,2,2) # fenêtre du graphique
shape("turtle") # une tortue qui ressemble à une tortue
cercle( (0,0), 1)
hideturtle() # on cache la tortue
mainloop() # pour maintenir fenêtre ouverte
Écrire une fonction python avec le module turtle permettant de former des figures comme celles ci-dessous :
Le nombre de cercles sera un paramètre de la fonction, ainsi que le rayon commun des cercles.
from turtle import *
def multicercle(point, rayon, tete) :
penup()
setposition(point[0],point[1])
setheading(tete)
pendown()
circle(rayon,steps=200)
############ main ################################
setworldcoordinates(-2,-2,2,2) # fenêtre du graphique
speed(0) # tortue rapide
n=6
point=(0,0)
rayon=1
for i in range(n) :
multicercle(point, rayon, i*360/n)
hideturtle() # on cache la tortue
mainloop() # pour maintenir fenêtre ouverte
On dispose d'une chaîne de caractères et on la transforme ainsi : chaque lettre F est remplacée par F+F--F+F.
Si ch='FA+-FB', la chaîne obtenue après transformation est donc la chaîne 'F+F--F+FA+-F+F--F+FB'.
On part de la chaîne ch='F--F--F', on transforme cette chaîne un certain nombre de fois suivant le processus de transformation vu plus haut. Puis on interprète la chaîne finale suivant le principe précédent.
Programmez...
La seule difficulté est l'échelle d'ouverture de la fenêtre : une mauvaise ouverture peut conduire à ne rien voir de la figure obtenue (soit parce que la figure se trouve trop petite vis à vis de cette fenêtre, soit parce qu'elle se trouve trop grande ou parce qu'elle est décentrée...)
Nous réglons ce problème ici en recalculant l'ouverture de la fenêtre au fur et à mesure de l'avancée de la tortue. Nous sommes certain ainsi de voir la figure intégrale et dans une échelle raisonnable, toutefois cela peut amener quelques distorsions (repère non orthonormé), d'où la fonction de "centrage normalisé".
from turtle import *
def regle(ch) :
""" règle de substitution
de F par F+F--F+F
dans la chaîne."""
ch=ch.replace('F','F+F--F+F')
return ch
def miseAJour(xmin,ymin,xmax, ymax) :
""" met à jour min, max tortue."""
xmin=min(xmin,position()[0])
ymin=min(ymin,position()[1])
xmax=max(xmax,position()[0])
ymax=max(ymax,position()[1])
return (xmin, ymin, xmax, ymax)
def centrageNormalise(xmin,ymin,xmax, ymax) :
xc = (xmin+xmax) * 0.5
yc = (ymin+ymax) * 0.5
delta = max(xmax-xmin, ymax-ymin)
delta = delta *0.5
xmin = xc -delta
ymin = yc -delta
xmax = xc + delta
ymax = yc + delta
setworldcoordinates(xmin,ymin,xmax,ymax)
def dessine(ch) :
""" interprétation de la chaîne
par la tortue."""
penup()
setposition(0,0)
setheading(0)
xmin, ymin, xmax, ymax =0,0,0,0
for x in ch :
if x=='F' :
pendown()
forward(1)
penup()
xmin, ymin, xmax, ymax=miseAJour(xmin,ymin,xmax, ymax)
centrageNormalise(xmin, ymin, xmax, ymax)
elif x=='+' :
left(60)
elif x=='-' :
right(60)
setworldcoordinates(0,0,1,1)
speed(0) # tortue rapide
ch='F--F--F'
nombre_de_transfo=3
for _ in range(nombre_de_transfo) :
ch=regle(ch)
dessine(ch)
hideturtle() # on masque la tortue
mainloop() # maintenir fenêtre ouverte
Les figures obtenues constituent les premières étapes de la construction du flocon de Von Koch, fractale pour laquelle vous trouverez sur le web de nombreuses références.
Vous trouverez sur le principe utilisé ici (L-system) des renseignements et notamment son utilisation pour la représentation de végétaux sur cette page et particulièrement dans ce pdf.
Cet exercice est très semblable au précédent. Mais on change la règle de transformation de la chaîne et l'interprétation par la tortue.
On dispose d'une chaîne de caractères et on la transforme ainsi : chaque lettre F est remplacée par FF+F+F+F+F+FF.
On interprète maintenant une chaîne de caractères, en parcourant ses caractères dans l'ordre, à l'aide d'une tortue de la façon suivante :On part de la chaîne ch='F+F+F+F+F', on transforme cette chaîne un certain nombre de fois suivant le processus de transformation vu plus haut. Puis on interprète la chaîne finale suivant le principe précédent.
Programmez...
Il suffit d'apporter quelques modifications mineures au programme précédent.
from turtle import *
def regle(ch) :
""" règle de substitution
de F par FF+F+F+F+F+FF
dans la chaîne."""
ch=ch.replace('F','FF+F+F+F+F+FF')
return ch
def miseAJour(xmin,ymin,xmax, ymax) :
""" met à jour min, max tortue."""
xmin=min(xmin,position()[0])
ymin=min(ymin,position()[1])
xmax=max(xmax,position()[0])
ymax=max(ymax,position()[1])
return (xmin, ymin, xmax, ymax)
def centrageNormalise(xmin,ymin,xmax, ymax) :
xc = (xmin+xmax) * 0.5
yc = (ymin+ymax) * 0.5
delta = max(xmax-xmin, ymax-ymin)
delta = delta *0.5
xmin = xc -delta
ymin = yc -delta
xmax = xc + delta
ymax = yc + delta
setworldcoordinates(xmin,ymin,xmax,ymax)
def dessine(ch) :
""" interprétation de la chaîne
par la tortue."""
penup()
setposition(0,0)
setheading(0)
xmin, ymin, xmax, ymax =0,0,0,0
for x in ch :
if x=='F' :
pendown()
forward(1)
penup()
xmin, ymin, xmax, ymax=miseAJour(xmin,ymin,xmax, ymax)
centrageNormalise(xmin,ymin,xmax, ymax)
elif x=='+' :
left(72)
elif x=='-' :
right(72)
setworldcoordinates(0,0,1,1)
speed(0) # tortue rapide
ch='F+F+F+F+F'
nombre_de_transfo=3
for _ in range(nombre_de_transfo) :
ch=regle(ch)
dessine(ch)
hideturtle() # on masque la tortue
mainloop() # maintenir fenêtre ouverte
On reprend le principe des L-system expliqué dans les exercices précédents.
On dispose d'une chaîne de caractères et on la transforme ainsi : chaque lettre F est remplacée par F[+F]F[-F]F.
On interprète maintenant une chaîne de caractères, en parcourant ses caractères dans l'ordre, à l'aide d'une tortue de la façon suivante :On révisera, si nécessaire, la notion de pile.
On part de la chaîne ch='F', on transforme cette chaîne un certain nombre de fois suivant le processus de transformation exposé. Puis on interprète la chaîne finale suivant le principe précédent.
Programmez...
On apporte quelques modifications mineures au programme précédent et on ajoute les fonctions permettant d'empiler et de dépiler la position de la tortue.
from turtle import *
def regle(ch) :
""" règle de substitution
de F par F[+F]F[-F]F
dans la chaîne."""
ch=ch.replace('F','F[+F]F[-F]F')
return ch
def miseAJour(xmin,ymin,xmax, ymax) :
""" met à jour min, max tortue."""
xmin=min(xmin,position()[0])
ymin=min(ymin,position()[1])
xmax=max(xmax,position()[0])
ymax=max(ymax,position()[1])
return (xmin, ymin, xmax, ymax)
def centrageNormalise(xmin,ymin,xmax, ymax) :
xc = (xmin+xmax) * 0.5
yc = (ymin+ymax) * 0.5
delta = max(xmax-xmin, ymax-ymin)
delta = delta *0.5
xmin = xc -delta
ymin = yc -delta
xmax = xc + delta
ymax = yc + delta
setworldcoordinates(xmin,ymin,xmax,ymax)
def empile(a) :
a.append(position())
a.append(heading())
def depile(a) :
penup()
setheading(a.pop())
setposition(a.pop())
pendown()
def dessine(ch) :
""" interprétation de la chaîne
par la tortue."""
pile=[] # pile pour les positions de la tortue
penup()
setposition(0,0)
setheading(90)
xmin, ymin, xmax, ymax =0,0,0,0
speed(0) # tortue rapide
for x in ch :
if x=='F' :
pendown()
forward(1)
penup()
xmin, ymin, xmax, ymax=miseAJour(xmin,ymin,xmax, ymax)
centrageNormalise(xmin,ymin,xmax, ymax)
elif x=='+' :
left(30)
elif x=='-' :
right(30)
elif x=='[' :
empile(pile)
elif x==']' :
depile(pile)
setworldcoordinates(0,0,1,1)
ch='F'
nombre_de_transfo=5
for _ in range(nombre_de_transfo) :
ch=regle(ch)
dessine(ch)
hideturtle() # on masque la tortue
mainloop() # maintenir fenêtre ouverte
On reprend le principe expliqué dans l' exercice précédent.
La règle de substitution est maintenant : chaque lettre F est remplacée par F-[-F+F+F]+[+F-F-F]F.
On interprète maintenant une chaîne de caractères, en parcourant ses caractères dans l'ordre, à l'aide d'une tortue de la façon suivante :On part de la chaîne ch='F', on transforme cette chaîne un certain nombre de fois suivant le processus de transformation exposé. Puis on interprète la chaîne finale suivant le principe précédent.
Programmez...
On apporte quelques modifications mineures au programme précédent.
from turtle import *
def regle(ch) :
""" règle de substitution
de F par F-[-F+F+F]+[+F-F-F]F
dans la chaîne."""
ch=ch.replace('F','F-[-F+F+F]+[+F-F-F]F')
return ch
def miseAJour(xmin,ymin,xmax, ymax) :
""" met à jour min, max tortue."""
xmin=min(xmin,position()[0])
ymin=min(ymin,position()[1])
xmax=max(xmax,position()[0])
ymax=max(ymax,position()[1])
return (xmin, ymin, xmax, ymax)
def centrageNormalise(xmin,ymin,xmax, ymax) :
xc = (xmin+xmax) * 0.5
yc = (ymin+ymax) * 0.5
delta = max(xmax-xmin, ymax-ymin)
delta = delta *0.5
xmin = xc -delta
ymin = yc -delta
xmax = xc + delta
ymax = yc + delta
setworldcoordinates(xmin,ymin,xmax,ymax)
def empile(a) :
a.append(position())
a.append(heading())
def depile(a) :
penup()
setheading(a.pop())
setposition(a.pop())
pendown()
def dessine(ch) :
""" interprétation de la chaîne
par la tortue."""
pile=[] # pile pour les positions de la tortue
penup()
setposition(0,0)
setheading(90)
xmin, ymin, xmax, ymax =0,0,0,0
for x in ch :
speed(0) # tortue rapide
if x=='F' :
pendown()
forward(1)
penup()
xmin, ymin, xmax, ymax=miseAJour(xmin,ymin,xmax, ymax)
centrageNormalise(xmin,ymin,xmax, ymax)
elif x=='+' :
left(20)
elif x=='-' :
right(20)
elif x=='[' :
empile(pile)
elif x==']' :
depile(pile)
setworldcoordinates(0,0,1,1)
ch='F'
nombre_de_transfo=5
for _ in range(nombre_de_transfo) :
ch=regle(ch)
dessine(ch)
hideturtle() # on masque la tortue
mainloop() # maintenir fenêtre ouverte
