Le contenu de cette page peut être travaillé en seconde lecture.
Vous trouverez la documentation du module turtle
ici.
Le petit résumé au format .pdf
est disponible en
cliquant ici.
La tortue : deuxième série d'exercices
Le contenu de cette page peut être travaillé en seconde lecture.
Vous trouverez la documentation du module turtle
ici.
Le petit résumé au format .pdf
est disponible en
cliquant ici.
Un enseignant veut présenter les notes de la classe à l'aide d'un histogramme (les classes étant toutes de même largeur).
Ces notes sont regroupées dans une liste. Par exemple :
notes = [4.5, 4.5, 4.5, 4.5, 9, 9, 9, 10, 10, 10, 15.5, 15.5, 15.5, 15.5]
Écrire un programme Python réalisant cette représentation.
from turtle import *
from math import floor
def repartit_en_classes( liste_notes, nombre_classes) :
amplitude_classe = 20/nombre_classes
effectifs_classes = [0] * nombre_classes
for note in liste_notes :
if note == 20 :
effectifs_classes[-1] += 1
else :
effectifs_classes[ floor(note/amplitude_classe) ] += 1
return effectifs_classes
def aller_a_sans_tracer(x, y) :
""" On place la tortue en (x,y) sans tracer."""
penup()
goto(x, y)
pendown()
def tracer_segment(x1,y1, x2, y2, couleur = "black", epaisseur = 1):
""" tracer le segment d'extrémités (x1,y1) et (x2,y2) """
pencolor(couleur)
pensize(epaisseur)
aller_a_sans_tracer(x1,y1)
pendown()
goto(x2,y2)
penup()
def dessiner_rectangle(xbg, ybg, largeur, hauteur, contour = "violet", remplissage = "pink", epaisseur = 1) :
aller_a_sans_tracer(xbg, ybg)
fillcolor(remplissage)
pencolor(contour)
pensize(epaisseur)
pendown()
begin_fill()
goto(xbg, ybg + hauteur)
goto(xbg + largeur, ybg + hauteur)
goto(xbg + largeur, ybg)
goto(xbg, ybg)
end_fill()
penup()
def dessiner_classes( liste_notes, nombre_classes ) :
nombre_notes = len(liste_notes)
effectifs_classes = repartit_en_classes( liste_notes, nombre_classes)
effectif_max = max(effectifs_classes)
Xmin, Ymin, Xmax, Ymax = -1, -1, 21, effectif_max + 1
setworldcoordinates(Xmin,Ymin, Xmax, Ymax)
delay(0)
hideturtle()
def dessiner_axes(xmin, xmax, ymin, ymax, gradueX, gradueY) :
tracer_segment(Xmin, 0, Xmax, 0)
tracer_segment(0, Ymin, 0, Ymax)
for k in range(floor(xmin), floor(xmax)+1) :
tracer_segment(k, -gradueX, k, gradueX)
aller_a_sans_tracer(k, -5*gradueX)
write(str(k), align="center")
for k in range(floor(ymin), floor(ymax)+1) :
tracer_segment(-gradueY, k, gradueY, k)
aller_a_sans_tracer(-5*gradueY, k)
write(str(k), align="center")
def dessiner_barre(xdepart, largeur, hauteur) :
dessiner_rectangle( xdepart, 0, largeur, hauteur)
dessiner_axes(xmin = 1, xmax = 20, ymin = 1, ymax = effectif_max+1, gradueX = 0.1, gradueY = 0.1)
amplitude_classe = 20 / nombre_classes
for x in range(0, nombre_classes) :
xdepart = x * amplitude_classe
dessiner_barre(xdepart , amplitude_classe, effectifs_classes[x])
exitonclick()
notes = [4.5, 4.5, 4.5, 4.5, 9, 9, 9, 10, 10, 10, 15.5, 15.5, 15.5, 15.5]
TurtleScreen._RUNNING = True # Permet d'exécuter plusieurs instances successives sans erreurs
dessiner_classes(notes, 6)
L'exercice est l'occasion de montrer qu'une représentation peut influencer le jugement.
Avec la série de notes proposées dans le corrigé :
notes = [4.5, 4.5, 4.5, 4.5, 9, 9, 9, 10, 10, 10, 15.5, 15.5, 15.5, 15.5]
,
lancer dessiner_classes(notes, 4)
puis dessiner_classes(notes, 5)
...
et commenter.
Dans le programme suivant, la fonction replace()
place la tortue
au pixel de coordonnées $(0, 160)$ :
Tant que l'ordonnée de la tortue est supérieure à -160:
Avec une probabilité de 50%:
Ajouter 20 à l'abscisse
Sinon:
Enlever 20 à l'abscisse
Enlever 40 à l'ordonnée
Aller au point correspondant
speed(0)
en début
de programme pour que le tracé soit plus rapide.-160
et 160
que ce soit en abscisses ou en ordonnées. Le pixel de coordonnées
(0 ; 160)
contiendra toujours le premier clou.
Il faut penser à stocker abscisse et ordonnée de la tortue
dans des variables. De plus, on fait appel à la fonction
randint()
du module random
afin
de simuler un entier aléatoire.
On définit une nouvelle fonction qui implémente l'algorithme de la question précédente.
Une liste de neuf éléments va contenir le nombre de fois où le pixel de coordonnées $(40 a -160, 160)$ a été atteint par la tortue, avec $a$ entier entre $0$ et $8$. On en déduit le programme ci-dessous :
Dans cette solution, on définit une nouvelle fonction qui permet de déterminer le pas du déplacement horizontal et vertical d'un clou au suivant. A nouveau, pour les mathématiques sous-jacentes, nous vous laissons calculer...
Il est possible de généraliser davantage en ajoutant comme paramètre la
probabilité de prendre le chemin de gauche à chaque clou dans la fonction
tracer_1()
Une balle tombe et rebondit. A chaque rebond, elle remonte à 90 % de la hauteur précédente. Elle s'arrête de rebondir lorsque la hauteur de chute est d'au plus une unité de longueur.
On peut proposer le script initial aux élèves et leur demander seulement la transformation. Le premier travail, déjà important, serait ainsi un travail de compréhension du script proposé.
import turtle
##----- Constantes et Variables -----##
hauteur_max = 100
turtle.setworldcoordinates(-10,0,10,hauteur_max)
turtle.delay(5)
turtle.colormode(255)
morla = turtle.Turtle() # une tortue
morla.shape("circle")
morla.pencolor(200,200,200)
morla.pensize(20)
##----- Définition des fonctions -----##
def aller_a_sans_tracer(tortue, x, y) :
""" On place la tortue en (x,y) sans tracer."""
tortue.penup()
tortue.goto(x, y)
tortue.pendown()
def monter(tortue,hauteur):
tortue.clear()
aller_a_sans_tracer(tortue, 0 , 0 )
tortue.setheading(90)
tortue.forward(hauteur)
def descendre(tortue,hauteur):
tortue.clear()
aller_a_sans_tracer(tortue, 0 , hauteur )
tortue.setheading(-90)
tortue.forward(hauteur)
##----- Programme principal -----##
TurtleScreen._RUNNING = True # Permet d'exécuter plusieurs instances successives sans erreurs
aller_a_sans_tracer(morla, 0, hauteur_max)
hauteur = hauteur_max
while hauteur > 1 :
descendre(morla, hauteur)
hauteur = 0.9 * hauteur
monter(morla, hauteur)
descendre(morla, hauteur)
morla.clear()
turtle.exitonclick()
import turtle
##----- Constantes et Variables -----##
hauteur_max = 100
turtle.setworldcoordinates(-10,0,10,hauteur_max)
turtle.delay(5)
turtle.colormode(255)
morla = turtle.Turtle() # une tortue
morla.shape("circle")
caroline = turtle.Turtle() # une tortue qui écrira les distances parcourues
caroline.hideturtle() # tortue invisible
morla.pencolor(200,200,200)
morla.pensize(20)
##----- Définition des fonctions -----##
def aller_a_sans_tracer(tortue, x, y) :
""" On place la tortue en (x,y) sans tracer."""
tortue.penup()
tortue.goto(x, y)
tortue.pendown()
def monter(tortue,hauteur):
tortue.clear()
aller_a_sans_tracer(tortue, 0 , 0 )
tortue.setheading(90)
tortue.forward(hauteur)
def descendre(tortue,hauteur):
tortue.clear()
aller_a_sans_tracer(tortue, 0 , hauteur )
tortue.setheading(-90)
tortue.forward(hauteur)
##----- Programme principal -----##
TurtleScreen._RUNNING = True # Permet d'exécuter plusieurs instances successives sans erreurs
aller_a_sans_tracer(morla, 0, hauteur_max)
aller_a_sans_tracer(caroline, 6, hauteur_max/2)
hauteur = hauteur_max
parcours = 0
while hauteur > 1 :
descendre(morla, hauteur)
parcours += hauteur
caroline.clear()
hauteur = 0.9 * hauteur
monter(morla, hauteur)
parcours += hauteur
caroline.write(parcours)
descendre(morla, hauteur)
morla.clear()
parcours += hauteur
caroline.clear()
caroline.write(parcours)
turtle.exitonclick()
Avec le nombre de rebonds :
import turtle
##----- Constantes et Variables -----##
hauteur_max = 100
turtle.setworldcoordinates(-10,0,10,hauteur_max)
turtle.delay(5)
turtle.colormode(255)
morla = turtle.Turtle() # une tortue
morla.shape("circle")
caroline = turtle.Turtle() # une tortue qui écrira les distances parcourues
caroline.hideturtle() # tortue invisible
morla.pencolor(200,200,200)
morla.pensize(20)
##----- Définition des fonctions -----##
def aller_a_sans_tracer(tortue, x, y) :
""" On place la tortue en (x,y) sans tracer."""
tortue.penup()
tortue.goto(x, y)
tortue.pendown()
def monter(tortue,hauteur):
tortue.clear()
aller_a_sans_tracer(tortue, 0 , 0 )
tortue.setheading(90)
tortue.forward(hauteur)
def descendre(tortue,hauteur):
tortue.clear()
aller_a_sans_tracer(tortue, 0 , hauteur )
tortue.setheading(-90)
tortue.forward(hauteur)
##----- Programme principal -----##
TurtleScreen._RUNNING = True # Permet d'exécuter plusieurs instances successives sans erreurs
aller_a_sans_tracer(morla, 0, hauteur_max)
aller_a_sans_tracer(caroline, 6, hauteur_max/2)
hauteur = hauteur_max
parcours = 0
nb_rebond = 0
while hauteur > 1 :
descendre(morla, hauteur)
nb_rebond += 1
parcours += hauteur
caroline.clear()
hauteur = 0.9 * hauteur
monter(morla, hauteur)
parcours += hauteur
caroline.write(parcours)
descendre(morla, hauteur)
morla.clear()
parcours += hauteur
caroline.clear()
caroline.write(parcours)
aller_a_sans_tracer(caroline, 6, hauteur_max/3)
caroline.write(nb_rebond)
turtle.exitonclick()
Avec 44 rebonds, la distance parcourue est :
$$ d = 100 + 2\times 100 \times \left( 0,9^1 + 0,9^2 + \dots + 0,9^{44} \right) $$
soit $ d = 100 + 200 \times 0,9 \times \frac{1-0,9^{44}}{1-0,9} \approx 1882,544 $
import turtle
from random import randint
##----- Constantes et variables -----##
unite = 40 # longueur du côté d'un carré
turtle.delay(1)
demilargeur = 50
turtle.setworldcoordinates( -demilargeur, -demilargeur, demilargeur, demilargeur)
tortue = turtle.Turtle()
tortue.hideturtle()
##----- Définition des fonctions -----##
def aller_a_sans_tracer(x, y) :
""" On place la tortue en (x,y) sans tracer."""
tortue.penup()
tortue.goto(x, y)
tortue.pendown()
def carre(x, y, couleur) :
"""
Dessine un carré de sommet inférieur gauche (x,y),
de côté de longueur unite,
côtés parallèles aux bords de l'écran.
Couleur de remplissage : couleur.
"""
aller_a_sans_tracer(x, y)
tortue.fillcolor(couleur)
tortue.begin_fill()
for i in range(4):
tortue.forward(unite)
tortue.left(90)
tortue.end_fill()
def rectangle_diagonale(x1,y1,x2,y2, couleur) :
"""
Dessine un rectangle de diagonale d'extrémités (x1,y1) et (x2,y2).
"""
aller_a_sans_tracer(x1, y1)
tortue.fillcolor(couleur)
tortue.begin_fill()
tortue.setheading(0)
tortue.forward(x2-x1)
tortue.left(90)
tortue.forward(y2-y1)
tortue.left(90)
tortue.forward(x2-x1)
tortue.left(90)
tortue.forward(y2-y1)
tortue.end_fill()
def carreHasard(couleur) :
"""
choisit au hasard abscisse x et ordonnée y
du coin inférieur gauche d'un carré.
Trace ce carré.
Renvoie le tuple (x,y)
"""
x = randint(-demilargeur, demilargeur-unite)
y = randint(-demilargeur, demilargeur-unite)
carre(x,y, couleur)
return (x,y)
def est_dans_carre(xA,yA,x,y) :
"""
Le point A(xA,yA) est il à l'intérieur (au sens large)
du carré de coin inférieur gauche (x,y) ?
"""
return x <= xA <= x+unite and y <= yA <= y+unite
def carres_se_coupent(x1,y1,x2,y2):
"""
On teste les coins du coin de sommet inférieur gauche (x2,y2).
Pour le premier coin trouvé dans le carré de sommet inférieur gauche (x1,y1),
on retourne sa "position"
"""
if est_dans_carre(x2,y2,x1,y1) : return "ig" #coin inférieur gauche
elif est_dans_carre(x2+unite,y2,x1,y1) : return "id" #coin inférieur droit
elif est_dans_carre(x2,y2+unite,x1,y1) : return "sg" #coin supérieur gauche
elif est_dans_carre(x2+unite,y2+unite,x1,y1) : return "sd" #coin supérieur droit
##----- Programme principal -----##
TurtleScreen._RUNNING = True # Permet d'exécuter plusieurs instances successives sans erreurs
C1 = carreHasard('green')
C2 = carreHasard('yellow')
Inter = carres_se_coupent(C1[0],C1[1], C2[0], C2[1])
if Inter == "ig" :
rectangle_diagonale(C2[0], C2[1],C1[0]+unite,C1[1]+unite, 'red')
elif Inter == "id" :
rectangle_diagonale(C1[0],C1[1]+unite, C2[0]+unite, C2[1] , 'red')
elif Inter == "sg" :
rectangle_diagonale(C2[0],C2[1]+unite, C1[0]+unite, C1[1] , 'red')
elif Inter == "sd" :
rectangle_diagonale(C1[0],C1[1], C2[0]+unite, C2[1]+unite , 'red')
turtle.exitonclick()
Réaliser une horloge avec la tortue Python.
Les notions mathématiques en jeu : angle, trigonométrie, proportionnalité, temps.
from math import cos, sin, pi
import turtle
##----- règlage taille fenêtre -----##
demilargeur = 100
turtle.setworldcoordinates( -demilargeur , -demilargeur, demilargeur, demilargeur)
##----- Définition des fonctions -----##
def cosinus(x):
""" x en degrés"""
return cos(x * pi/180)
def sinus(x):
""" x en degrés"""
return sin(x * pi/180)
def aller_a_sans_tracer(tortue, x, y) :
""" On place la tortue en (x,y) sans tracer."""
tortue.penup()
tortue.goto(x, y)
tortue.pendown()
def dessine():
"""
on dessine les traits des heures de la pendule.
"""
crayon = turtle.Turtle()
crayon.hideturtle()
crayon.pensize(3)
dimension = demilargeur*0.7
for k in range(12) :
aller_a_sans_tracer(crayon, dimension * cosinus(k*30) , dimension * sinus(k*30))
crayon.setheading(k*30)
crayon.forward(10)
##----- Les tortues -----##
grandeAiguille = turtle.Turtle()
petiteAiguille = turtle.Turtle()
trotteuse = turtle.Turtle()
def initialise(trotte = 90, petite = 0, grande = 90):
"""
Au lancement, la pendule marque 3h00.
"""
grandeAiguille.shape('arrow')
grandeAiguille.shapesize(0.5,10)
grandeAiguille.pencolor('green')
grandeAiguille.fillcolor('green')
petiteAiguille.shape('arrow')
petiteAiguille.shapesize(0.2,5)
petiteAiguille.pencolor('green')
petiteAiguille.fillcolor('green')
trotteuse.shape('arrow')
trotteuse.shapesize(0.1,7)
trotteuse.pencolor('red')
trotteuse.fillcolor('red')
grandeAiguille.tilt(grande)
petiteAiguille.tilt(petite)
trotteuse.tilt(trotte)
aller_a_sans_tracer(grandeAiguille, 0, 0)
aller_a_sans_tracer(petiteAiguille, 0, 0)
aller_a_sans_tracer(trotteuse, 0, 0)
turtle.ontimer(tourne, 1000)
def tourne() :
"""
Fonction faisant tourner les aiguilles.
"""
trotteuse.tilt(-6)
grandeAiguille.tilt(-0.1)
petiteAiguille.tilt(-(1/240))
turtle.ontimer(tourne, 1000)
##----- Programme principal -----##
TurtleScreen._RUNNING = True # Permet d'exécuter plusieurs instances successives sans erreurs
dessine()
initialise()
turtle.exitonclick()
On range des caramels carrés de côté 1 cm dans une boîte en forme de parallélépipède rectangle. La base rectangulaire de la boîte a un périmètre de 14 cm, une largeur $ \ell $ et une longueur L (avec $ \ell \leqslant L $ ). On note $ N(\ell ) $ le nombre de caramels que l’on peut poser dans une couche au fond de la boîte en fonction de $ \ell $.
Représenter graphiquement la fonction $N$ à l'aide de la tortue Python.
$ N(\ell) = \lfloor l \rfloor \times \lfloor 7-l \rfloor $ (où $ \lfloor \ \rfloor $ est la fonction partie entière).
On obtient le graphique suivant
import turtle as tl
from math import floor
##----- Constantes et variables -----##
Xmin = -1
Xmax = 4
Ymin = -1
Ymax = 15
tl.setworldcoordinates(Xmin,Ymin, Xmax, Ymax)
##----- Définition des fonctions -----##
def aller_a_sans_tracer(tortue, x, y) :
""" On place la tortue en (x,y) sans tracer."""
tortue.penup()
tortue.goto(x, y)
tortue.pendown()
def tracer_segment(tortue, x1,y1, x2, y2, couleur = "black", epaisseur = 1):
""" tracer le segment d'extrémités (x1,y1) et (x2,y2) """
tortue.pencolor(couleur)
tortue.pensize(epaisseur)
aller_a_sans_tracer(tortue, x1,y1)
tortue.pendown()
tortue.goto(x2,y2)
tortue.penup()
def axes(tortue, gradueX, gradueY) :
tracer_segment(tortue, Xmin,0, Xmax, 0)
tracer_segment(tortue, 0, Ymin, 0, Ymax)
for k in range(floor(Xmin), floor(Xmax)+1) :
tracer_segment(tortue, k, -gradueX, k, gradueX)
aller_a_sans_tracer(tortue, k, -5*gradueX)
tortue.write(str(k), align="center")
for k in range(floor(Ymin), floor(Ymax)+1) :
tracer_segment(tortue, -gradueY, k, gradueY, k)
aller_a_sans_tracer(tortue, -5*gradueY, k)
tortue.write(str(k), align="center")
def grille(tortue) :
for y in range(Ymin, Ymax+1) :
for x in range(Xmin, Xmax+1) :
dessine_point(tortue, x, y, 'gray', 0.2)
def dessine_point(tortue, x, y, couleur, epaisseur = 5) :
# la tortue se place en (x,y) sans tracer :
aller_a_sans_tracer(tortue, x, y)
# la tortue dessine un disque noir :
tortue.pensize(epaisseur)
tortue.pencolor(couleur)
tortue.dot()
def demicerclegauche(tortue, x, y, rayon = 0.06, couleur = "blue", epaisseur = 2) :
tortue.setheading(0)
tortue.pencolor(couleur)
tortue.pensize(epaisseur)
aller_a_sans_tracer(tortue, x-rayon, y-rayon)
tortue.circle(rayon, 180, 30)
def demicercledroit(tortue, x, y, rayon = 0.06, couleur = "blue", epaisseur = 2) :
tortue.setheading(180)
tortue.pencolor(couleur)
tortue.pensize(epaisseur)
aller_a_sans_tracer(tortue, x+rayon, y-rayon)
tortue.circle(-rayon, 180, 10)
##----- Programme principal -----##
TurtleScreen._RUNNING = True # Permet d'exécuter plusieurs instances successives sans erreurs
caroline = tl.Turtle()
caroline.hideturtle()
caroline.speed(0)
axes(caroline, 0.1,0.02)
grille(caroline)
# ]0;1[
tracer_segment(caroline, 0,0, 1,0, "red", 3 )
demicerclegauche(caroline, 0, 0 )
demicercledroit(caroline, 1, 0 )
# [1;2[
dessine_point(caroline, 1, 6, 'red')
tracer_segment(caroline, 1,5, 2,5, "red", 3 )
demicerclegauche(caroline, 1, 5 )
demicercledroit(caroline, 2, 5 )
# [2;3[
dessine_point(caroline, 2, 10, 'red')
tracer_segment(caroline, 2,8, 3,8, "red", 3 )
demicerclegauche(caroline, 2, 8 )
demicercledroit(caroline, 3, 8 )
# [3;3.5]
dessine_point(caroline, 3, 12, 'red')
tracer_segment(caroline, 3,9, 3.5,9, "red", 3 )
demicerclegauche(caroline, 3, 9 )
tl.exitonclick()