Python en Mathématiques - Niveau 2

La tortue : deuxième série d'exercices

Plus tard ! 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.

Répartition en classes

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.

  • Un script possible
  • Commentaire


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.

Planche de Galton

Dans le programme suivant, la fonction replace() place la tortue au pixel de coordonnées $(0, 160)$ :


		
		
  1. Programmer l'algorithme suivant :
    
    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
    			
  2. Améliorer le programme pour que la tortue répète 100 fois ces instructions (le replacement suivi de l'algorithme précédent). On pourra utiliser l'instruction speed(0) en début de programme pour que le tracé soit plus rapide.
  3. Théoriquement, combien de pixels peuvent être atteints par la tortue à la fin de l'exécution l'algorithme de la question 1°/ ?
    Quelle est la plus petite abscisse possiblement atteinte ? Et la plus grande ?
  4. On considère la liste des coordonnées des pixels potentiellement atteints, de la plus petite à la plus grande abscisse. Modifier le programme pour qu'il renvoie une liste de même longueur qui contient le nombre de fois où la tortue s'est arrêtée sur le pixel correspondant.
  5. En augmentant le nombre de répétitions, ces valeurs se rapprochent-elles du modèle théorique ? Justifier...
  6. Généralisation :
    Améliorer le programme précédent pour qu'il simule n'importe quelle planche de Galton de 1 jusqu'à 20 clous. Cette planche devra toujours être tracée entre les coordonnées -160 et 160 que ce soit en abscisses ou en ordonnées. Le pixel de coordonnées (0 ; 160) contiendra toujours le premier clou.
  • Question 1°/
  • Question 2°/
  • Question 3°/
  • Question 4°/
  • Question 5°/
  • Question 6°/

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.


				
				
Neuf pixels sont potentiellement atteints par la tortue. Ces pixels ont tous pour ordonnée $160$ et leurs abscisses vont de $-160$ à $160$.

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 :


				
				
Un peu de loi binomiale... Pour l'illustrer davantage, il est possible d'augmenter le nombre de répétitions.

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

Balle rebondissante

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.

  1. Écrire un script avec la tortue Python pour simuler cela.
  2. Modifier le script proposé (premier onglet ci-dessous) pour qu'il affiche également la distance totale parcourue par la balle lorsqu'elle stoppe.
  3. Modifier le script pour qu'il affiche également le nombre de rebonds.
  4. (classe de première) Retrouver la distance totale parcourue en utilisant le nombre de rebonds.
  • Commentaire
  • Le script du rebond
  • Distance parcourue
  • Nombre de rebonds
  • Somme de termes en progression géométrique

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 $

Intersection

  • La tortue trace deux carrés unité au hasard dans le canevas.
  • Si les deux carrés ont une intersection non vide, elle remplit cette intersection en rouge.
  • Un code possible

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

Une horloge

Réaliser une horloge avec la tortue Python.

  • Notions travaillées
  • Un code possible

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

Ranger des caramels

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.

  • Représentation graphique
  • Un code possible

$ N(\ell) = \lfloor l \rfloor \times \lfloor 7-l \rfloor $ (où $ \lfloor \ \rfloor $ est la fonction partie entière).

On obtient le graphique suivant
représentation graphique


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