Toute la structure html/css/js et une partie du contenu ont été réalisés par Nicolas Buyle-Bodin professeur au lycée Lacassagne, avec l'aide de Jean-Manuel Mény, professeur au lycée de la plaine de l'Ain. Ils ont travaillé pendant plusieurs centaines d'heures pour créer un site de formation à destination des enseignants du secondaire de l'académie de Lyon d'une grande qualité visible sur le portail Mathématiques du site académique. Ils ont eu la gentillesse de placer leur code source sous licence Creative Commons BY-NC-SA Respect de la Paternité - Pas d'utilisation commerciale - Partage des conditions initiales à l'identique..

Nous les en remercions chaleureusement.

La liste complète des fonctions disponibles grâce au module turtle est disponible sur la documentation officielle.
On pourra aussi télécharger un petit résumé au format .pdf en cliquant ici.

1. Compléter le script ci-dessous pour qu'il' trace une marche d'escalier comme ci-dessus, à partir du point de coordonnées (-150,-150), avec une hauteur et une largeur 50 pixels.
2. Compléter le script avec une fonction marche(h) qui trace une marche d'escalier avec une hauteur et une largeur de h pixels, à partir de la position courante et d'une orientation de la tortue de 0 degrés (tortue orientée vers l'Est).
3. Compléter le script avec une fonction escalier(n, h) qui trace un escalier comme ci-dessus avec une hauteur et une largeur h pixels, à partir de la position courante.

from turtle import * 

speed(5)            #parametrage de la vitesse de 1 lent à 10 rapide, 0 étant la vitesse la plus rapide
shape("turtle")     #choix de la forme de la tortue
pencolor("red")     #choix de la couleur du crayon
pensize(4)          #épaisseur du crayon
up()                #lever le crayon     
goto(-150,-150)     # aller à la position (-200,-200)
setheading(0)       #orientation de la tortue vers l'Est / 90  Nord / 180 Ouest / 270 Sud
down()              #poser le crayon


left(90)
forward(50)
right(90)
forward(50)
exitonclick()       #indispensable en cas d'exécution dans un IDE comme Pyzo
        

from turtle import *     


def marche(h):
    left(90)
    forward(h)
    right(90)
    forward(h)

speed(5)            #parametrage de la vitesse de 1 lent à 10 rapide, 0 étant la vitesse la plus rapide
shape("turtle")     #choix de la forme de la tortue
pencolor("red")     #choix de la couleur du crayon
pensize(4)          #épaisseur du crayon
up()                #lever le crayon     
goto(-150,-150)     # aller à la position (-200,-200)
setheading(0)      #orientation de la tortue vers l'Est / 90  Nord / 180 Ouest / 270 Sud
down()              #poser le crayon

marche(50)     
exitonclick()       #indispensable en cas d'exécution dans un IDE comme Pyzo			

from turtle import * 

def marche(h):
    left(90)
    forward(h)
    right(90)
    forward(h)

def escalier(n, h):
    for k in range(n):
        marche(h)

speed(5)            #parametrage de la vitesse de 1 lent à 10 rapide, 0 étant la vitesse la plus rapide
shape("turtle")     #choix de la forme de la tortue
pencolor("red")     #choix de la couleur du crayon
pensize(4)          #épaisseur du crayon
up()                #lever le crayon     
goto(-150,-150)     # aller à la position (-200,-200)
setheading( 0)      #orientation de la tortue vers l'Est / 90  Nord / 180 Ouest / 270 Sud
down()              #poser le crayon
escalier(5, 50)    
exitonclick()       #indispensable en cas d'exécution dans un IDE comme Pyzo			
        

1. Tracer un triangle équilatéral de côté 100 pixels et dont un sommet a pour coordonnées (0,0).
2. Généraliser le script en une fonction polygone_regulier(n, cote) qui trace un polygone régulier de n côtés de longueur cote pixels, à partir du point de coordonnées (0,0), en tournant dans le sens trigonométrique.

        from turtle import * 

        cote = 100          #longueur du coté
        speed(5)            #parametrage de la vitesse de 1 lent à 10 rapide, 0 étant la vitesse la plus rapide
        shape("turtle")     #choix de la forme de la tortue
        pencolor("red")     #choix de la couleur du crayon
        pensize(4)          #épaisseur du crayon
        up()                #lever le crayon     
        goto(0,0)           # aller à la position (0,0)
        setheading(0)       #orientation de la tortue vers l'Est / 90  Nord / 180 Ouest / 270 Sud
        down()              #poser le crayon
        for k in range(3):
            forward(cote)
            left(120)
        exitonclick()       #indispensable en cas d'exécution dans un IDE comme Pyzo
        

        from turtle import * 

        def polygone(n, cote):
            speed(5)            #parametrage de la vitesse de 1 lent à 10 rapide, 0 étant la vitesse la plus rapide
            shape("turtle")     #choix de la forme de la tortue
            pencolor("red")     #choix de la couleur du crayon
            pensize(4)          #épaisseur du crayon
            up()                #lever le crayon     
            goto(0,0)           # aller à la position (0,0)
            setheading(0)       #orientation de la tortue vers l'Est / 90  Nord / 180 Ouest / 270 Sud
            down()              #poser le crayon
            angle  = 360 / n    #angle de rotation
            for k in range(n):
                forward(cote)    #avancer de cote pixels
                left(angle)        #tourner de angle degrés

        polygone(6, 100)    #appel de la fonction pour tracer un hexagone régulier
        exitonclick()       #indispensable en cas d'exécution dans un IDE comme Pyzo
					
        

1. Compléter le canevas de la fonction spirale_carre(n, increment) pour qu'elle puisse tracer des spirales "carrées" comme celle ci-dessus.

                   
                   from turtle import *
   
                   def  spirale_carre(n, increment):
                       speed(5)            #parametrage de la vitesse de 1 lent à 10 rapide, 0 étant la vitesse la plus rapide
                       shape("turtle")     #choix de la forme de la tortue
                       pencolor("red")     #choix de la couleur du crayon
                       pensize(4)          #épaisseur du crayon
                       up()                #lever le crayon
                       goto(0,0)           # aller à la position (0,0)
                       setheading(0)       #orientation de la tortue vers l'Est / 90  Nord / 180 Ouest / 270 Sud
                       down()              #poser le crayon
                       angle = 90          #angle de rotation
                       cote = 0            #longueur du coté tracé
                       #à compléter
                   

2. Écrire une fonction spirale_triangle(n, increment) qui tracer des spirales "triangulaires" comme celle ci-dessus.
3. Écrire une fonction spirale_polygone(n, m, increment) qui généralise les deux précédentes avec des polygones à m côtés.

        from turtle import *

        def  spirale_carre(n, increment):
            speed(5)            #parametrage de la vitesse de 1 lent à 10 rapide, 0 étant la vitesse la plus rapide
            shape("turtle")     #choix de la forme de la tortue
            pencolor("red")     #choix de la couleur du crayon
            pensize(4)          #épaisseur du crayon
            up()                #lever le crayon
            goto(0,0)           # aller à la position (0,0)
            setheading(0)       #orientation de la tortue vers l'Est / 90  Nord / 180 Ouest / 270 Sud
            down()              #poser le crayon
            angle = 90          #angle de rotation
            cote = 0            #longueur du coté tracé
            for k in range(4 * n):
                cote = cote + increment
                forward(cote)    #avancer de cote pixels
                left(angle)      #tourner de angle degrés               

        spirale_carre(6, 5)    #appel de la fonction pour tracer une spirale carrée
        exitonclick()       #indispensable en cas d'exécution dans un IDE comme Pyzo
                

        from turtle import *

        def  spirale_triangle(n, increment):
            speed(5)            #parametrage de la vitesse de 1 lent à 10 rapide, 0 étant la vitesse la plus rapide
            shape("turtle")     #choix de la forme de la tortue
            pencolor("red")     #choix de la couleur du crayon
            pensize(2)          #épaisseur du crayon
            up()                #lever le crayon
            goto(0,0)           # aller à la position (0,0)
            setheading(0)       #orientation de la tortue vers l'Est / 90  Nord / 180 Ouest / 270 Sud
            down()              #poser le crayon
            angle = 120          #angle de rotation
            cote = 0            #longueur du coté tracé
            for k in range(3 * n):
                cote = cote + increment
                forward(cote)    #avancer de cote pixels
                left(angle)      #tourner de angle degrés
                

        spirale_triangle(6, 10)    #appel de la fonction pour tracer une spirale carrée
        exitonclick()       #indispensable en cas d'exécution dans un IDE comme Pyzo	
					
        

        from turtle import *

        def  spirale_polygone(n, m, increment):
            speed(5)            #parametrage de la vitesse de 1 lent à 10 rapide, 0 étant la vitesse la plus rapide
            shape("turtle")     #choix de la forme de la tortue
            pencolor("red")     #choix de la couleur du crayon
            pensize(2)          #épaisseur du crayon
            up()                #lever le crayon
            goto(0,0)           # aller à la position (0,0)
            setheading(0)       #orientation de la tortue vers l'Est / 90  Nord / 180 Ouest / 270 Sud
            down()              #poser le crayon
            angle = 360 / m     #angle de rotation
            cote = 0            #longueur du coté tracé
            for k in range(n * m):
                cote = cote + increment
                forward(cote)    #avancer de cote pixels
                left(angle)      #tourner de angle degrés


        spirale_polygone(5, 6, 4)    #appel de la fonction pour tracer une spirale carrée
        exitonclick()       #indispensable en cas d'exécution dans un IDE comme Pyzo	
					
        

L'unité du système de coordonnées du module turtle dépend de la taille de la fenêtre d'affichage. Par exemple, dans les exercices interactifs de ce site, les axes sont gradués des valeurs -200 à 200 :

Modifier les unités des axes du repère

Il n'est pas possible d'agrandir indéfiniment les dimensions de la fenêtre d'affichage, mais il est heureusement possible de modifier les unités des axes grâce à la méthode .setworldcoordinates() appliquée à une instance de l'écran d'affichage ci-après affectée à la variable fenetre (fenetre = Screen()).

Par exemple :

• Avec un repère orthonormé usuel gradué de -10 à 10 :
  from turtle import * ##----- Fenêtre d'affichage et options -----## fenetre = Screen() # Instance de la fenêtre fenetre.setworldcoordinates(-10, -10, 10, 10) speed(0) # Vitesse la plus rapide ##----- Axe des abscisses -----## up() goto(-10, 0) down() goto(10,0) for i in range(21): up() goto(-10+i, -0.3) down() goto(-10+i, 0.3) ##----- Axe des ordonnées -----## up() goto(0, -10) down() goto(0, 10) for i in range(21): up() goto(-0.3, -10+i) down() goto(0.3, -10+i) Exécuter le programme

La fonction repere(xmin, xmax, xgrad, ymin, ymax, ygrad) donnée ci-dessous permet de tracer les axes d'un repère orthogonal dans la fenêtre rectangulaire dont le coin inférieur gauche a pour coordonnées (xmin, ymin) et le coin supérieur droit d'abscisses a pour coordonnées (xmax, ymax).

from turtle import *

def repere(xmin, xmax, xgrad, ymin, ymax, ygrad):
    ##----- Fenêtre d'affichage et options -----##
    fenetre = Screen()								# Instance de la fenêtre
    fenetre.setworldcoordinates(xmin, ymin, xmax, ymax)
    speed(0)										# Vitesse la plus rapide
    ##----- Axe des abscisses -----##
    up()
    goto(xmin, 0)
    down()
    goto(xmax, 0)
    nbxgrad = int((xmax - xmin)/xgrad  + 1)
    long_xgrad = (ymax - ymin)/400.0 * 5
    for i in range(nbxgrad):
        x = xmin + i * xgrad
        up()
        goto(x, -long_xgrad)
        down()
        goto(x, long_xgrad)
    ##----- Axe des ordonnées -----##
    up()
    goto(0, ymin)
    down()
    goto(0, ymax)
    nbygrad = int((ymax - ymin)/ygrad  + 1)
    long_ygrad = (xmax - xmin)/400.0 * 5
    for i in range(nbygrad):
        y = ymin + i * ygrad
        up()
        goto(-long_ygrad, y)
        down()
        goto(long_ygrad, y)    				
        

1. Écrire une fonction aller_sans_tracer(x, y) qui déplace la tortue jusqu'au point de coordonnées (x, y) sans effectuer de tracé.
   from turtle import * Exécuter le programme
   • Solution

   
           from turtle import *
   
           def aller_sans_tracer(x, y):
               up()
               goto(x, y)
               down()
           

2. On veut représenter graphiquement une fonction réelle $f: x \mapsto f(x)$ dans une fenêtre [xmin, xmax, ymin, ymax] avec un pas , xmin et xmax qui sont des variables.
   1. Déterminer le nombre de points qu'il faut construire.
   2. Rechercher dans le petit résumé la fonction de turtle qui permet de tracer un point et celle qui permet de régler l'épaisseur du trait.
   3. Écrire un script réalisant la tracé de la fonction $f: x \mapsto x^2$ sur l'intervalle $[-10;10]$ avec un pas de $1$.
   4. Écrire une fonction graphique(xmin, xmax, xgrad, ymin, ymax, ygrad, fonction, pas) qui généralise le script précédent en représentant une fonction dans une fenêtre paramétrable avec un pas régulier.
   
   
   from turtle import * Exécuter le programme
   • Solution question 1
   • Solution question 2
   • Solution question 3
   • Solution question 4

   Il faut construire $\frac{\text{x}_{max}-\text{x}_{min}}{\text{pas}} + 1$ points.

   C'est la fonction dot(rayon).

   
   from turtle import *
   
   def repere(xmin, xmax, xgrad, ymin, ymax, ygrad):
       ##----- Fenêtre d'affichage et options -----##
       fenetre = Screen()								# Instance de la fenêtre
       fenetre.setworldcoordinates(xmin, ymin, xmax, ymax)
       speed(0)										# Vitesse la plus rapide
       ##----- Axe des abscisses -----##
       up()
       goto(xmin, 0)
       down()
       goto(xmax, 0)
       nbxgrad = int((xmax - xmin)/xgrad  + 1)
       long_xgrad = (ymax - ymin)/400.0 * 5
       for i in range(nbxgrad):
           x = xmin + i * xgrad
           up()
           goto(x, -long_xgrad)
           down()
           goto(x, long_xgrad)
       ##----- Axe des ordonnées -----##
       up()
       goto(0, ymin)
       down()
       goto(0, ymax)
       nbygrad = int((ymax - ymin)/ygrad  + 1)
       long_ygrad = (xmax - xmin)/400.0 * 5
       for i in range(nbygrad):
           y = ymin + i * ygrad
           up()
           goto(-long_ygrad, y)
           down()
           goto(long_ygrad, y)
           
   def aller_sans_tracer(x, y):
       up()
       goto(x, y)
       down()
       
   def carre(x):
       return x ** 2
       
   #tracé des axes
   xmin, xmax, xgrad = -10, 10, 1
   ymin, ymax, ygrad = -10, 100, 10
   repere(xmin, xmax, xgrad, ymin, ymax, ygrad)
   
   #choix du pas
   pas = 1
   
   #nombre de points
   nbpoints = int((xmax - xmin)/pas) + 1
   
   #tracé des points
   x = xmin
   for k in range(nbpoints):
       aller_sans_tracer(x, carre(x))
       dot(2)
       x = x + pas
           

   
   from turtle import *
   
   def repere(xmin, xmax, xgrad, ymin, ymax, ygrad):
       ##----- Fenêtre d'affichage et options -----##
       fenetre = Screen()								# Instance de la fenêtre
       fenetre.setworldcoordinates(xmin, ymin, xmax, ymax)
       speed(0)										# Vitesse la plus rapide
       ##----- Axe des abscisses -----##
       up()
       goto(xmin, 0)
       down()
       goto(xmax, 0)
       nbxgrad = int((xmax - xmin)/xgrad  + 1)
       long_xgrad = (ymax - ymin)/400.0 * 5
       for i in range(nbxgrad):
           x = xmin + i * xgrad
           up()
           goto(x, -long_xgrad)
           down()
           goto(x, long_xgrad)
       ##----- Axe des ordonnées -----##
       up()
       goto(0, ymin)
       down()
       goto(0, ymax)
       nbygrad = int((ymax - ymin)/ygrad  + 1)
       long_ygrad = (xmax - xmin)/400.0 * 5
       for i in range(nbygrad):
           y = ymin + i * ygrad
           up()
           goto(-long_ygrad, y)
           down()
           goto(long_ygrad, y)
   
   def aller_sans_tracer(x, y):
       up()
       goto(x, y)
       down()
   
   def carre(x):
       return x ** 2
   
   def graphique(xmin, xmax, xgrad, ymin, ymax, ygrad, fonction, pas):
       #tracé des axes
       xmin, xmax, xgra = -10, 10, 1
       ymin, ymax, ygrad = -10, 100, 10
       repere(xmin, xmax, xgrad, ymin, ymax, ygrad)
       #nombre de points
       nbpoints = int((xmax - xmin)/pas) + 1
       #tracé des points
       x = xmin
       for k in range(nbpoints):
           aller_sans_tracer(x, fonction(x))
           dot(2)
           x = x + pas
   
   #exemple d'appel de fonction
   graphique(-10, 10, 1, -10, 100, 10, carre, 1)
           

1. Importer la fonction random() du module random, puis écrire une fonction point_aleatoire() sans argument, qui retourne le couple de coordonnées $(x,y)$ d'un point aléatoire avec $-1 \leqslant x<1$ et $-1 \leqslant y < 1$.

   
   print(point_aleatoire())
           

   (0.263405545797, 0.0720779871685)
   

2. Écrire une fonction carre_distance(x, y) qui retourne le carré de la distance du point de coordonnées (x, y) à l'origine du repère.
3. Importer le module turtle, recopier le code de la fonction repere(xmin, xmax, xgrad, ymin, ymax, ygrad) définie dans l'exercice précédent puis munir la fenêtre d'un repère orthonormal avec l'appel repere(-1, 1, 0.1, -1, 1, 0.1).
4. Écrire une fonction crible(n) qui :
   • crible la fenêtre avec n points aléatoires en coloriant le point en rouge s'il est dans le disque unité et en vert sinon ;
   • puis affiche la fréquence de points rouges.
5. Quelle conjecture peut-on faire sur la fréquence de points rouges lorsque la taille n de l'échantillon devient de plus en plus grande ?

from random import random

def point_aleatoire():
    return (2* random() - 1, 2 * random() - 1)

print(point_aleatoire())
        

def carre_distance(x, y):
    return x ** 2 + y ** 2
        

from turtle import *
from random import random

def point_aleatoire():
    return (2* random() - 1, 2 * random() - 1)

def carre_distance(x, y):
    return x ** 2 + y ** 2

def repere(xmin, xmax, xgrad, ymin, ymax, ygrad):
    ##----- Fenêtre d'affichage et options -----##
    fenetre = Screen()								# Instance de la fenêtre
    fenetre.setworldcoordinates(xmin, ymin, xmax, ymax)
    speed(0)										# Vitesse la plus rapide
    ##----- Axe des abscisses -----##
    up()
    goto(xmin, 0)
    down()
    goto(xmax, 0)
    nbxgrad = int((xmax - xmin)/xgrad  + 1)
    long_xgrad = (ymax - ymin)/400.0 * 5
    for i in range(nbxgrad):
        x = xmin + i * xgrad
        up()
        goto(x, -long_xgrad)
        down()
        goto(x, long_xgrad)
    ##----- Axe des ordonnées -----##
    up()
    goto(0, ymin)
    down()
    goto(0, ymax)
    nbygrad = int((ymax - ymin)/ygrad  + 1)
    long_ygrad = (xmax - xmin)/400.0 * 5
    for i in range(nbygrad):
        y = ymin + i * ygrad
        up()
        goto(-long_ygrad, y)
        down()
        goto(long_ygrad, y)

def crible(n):
    compteur = 0
    for k in range(1000):
        (x, y) = point_aleatoire()
        up()
        goto(x, y)
        down()
        if x ** 2 + y ** 2 <= 1:
            dot(2, "red")
            compteur = compteur + 1
        else:
            dot(2, "green")
    print("Frequence de points dans le disque unite : " + str(compteur/float(1000)))

#programme principal
repere(-1, 1,0.1, -1, 1, 0.1)
crible(1000)

1. Importer la fonction random() du module random, puis écrire une fonction point_aleatoire_carre(cote), qui retourne le couple de coordonnées $(x,y)$ d'un point choisi aléatoirement dans un carré de côté cote avec $0 \leqslant x < \text{cote}$ et $0\leqslant y< \text{cote}$.

   
   from random import random
   
   def point_aleatoire_carre(cote):
       #à compléter
   
   print(point_aleatoire_carre(20))
           

   (0.263405545797, 0.0720779871685)
   

2. Écrire une fonction distance(xA, yA, xB, yB) qui retourne la distance entre le point de coordonnées (xA, yA) et celui de coordonnées (xB, yB). On importera la fonction sqrt du module math.

   
   from math import sqrt
   
   def distance(xA, yA, xB, yB):
       #à compléter
   
   print(distance(1, 2, 3, 4))
           

   2.2360679775
   

3. On veut mesurer la distance moyenne sur un échantillon de n couples de points choisis aléatoirement dans un carré de côté cote avec l'algorithme ci-dessous :

   somme←0
   Pour k de 1 à n :
       xA ← réel au hasard de 0 à cote
       yA ← réel au hasard de 0 à cote
       Lever le crayon
       Déplacer la tortue en (xA, yA)
       Baisser le crayon
       Choisir une couleur aléatoire de trait
       xB ← réel au hasard de 0 à cote
       yB ← réel au hasard de 0 à cote
       Déplacer la tortue en (xB, yB)    
   somme ← somme + distance de A à B
   moyenne ← somme/n            
               

   • Pour faire correspondre la fenêtre de turtle à un carré de cote fixé, on capture une instance de la fenêtre avec fenetre = Screen() puis on règle xmin, ymin, xmax et ymax avec fenetre.setworldcoordinates(xmi, ymin, xmax, ymax). Le code ci-dessous est un exemple pour cote = 20.

     
     from turtle import *
     
     cote = 20
     fenetre = Screen()								# Instance de la fenêtre
     fenetre.setworldcoordinates(0, 0, cote, cote)   # Paramétrage du repère
     speed("fastest")                                # Vitesse la plus rapide pour la tortue 
     shape("turtle")                                 # Forme de la tortue
     
             

   • Écrire une fonction distance_moyenne_carre(n, cote) qui implémente l'algorithme précédent, affiche la distance moyenne entre deux points sur un échantillon de n points choisis aléatoirement dans un carré de côté cote et dessine avec la tortue tous les segments reliant les couples de points.

     
     from random import random
     from turtle import *
     from math import sqrt
     
     
     def point_aleatoire_carre(cote):
         #à compléter
         
     def distance(xA, yA, xB, yB):
         #à compléter                                  
                                        
     def distance_moyenne_carre(n, cote):
         fenetre = Screen()								# Instance de la fenêtre
         fenetre.setworldcoordinates(0, 0, cote, cote)   # Paramétrage du repère
         speed("fastest")                                # Vitesse la plus rapide pour la tortue
         shape("turtle")     
         somme = 0
         # à compléter
         exitonclick()                                    #Pour fermer la fenêtre de la tortue avec un click lors d'une exécution sous Pyzo
     
     
     
     distance_moyenne_carre(100, 20)
             

   
   • Comment peut-on stabiliser la valeur retournée par distance_moyenne_carre(n) ?
4. On choisit désormais un échantillon de n couples de points choisis aléatoirement dans un disque de rayon fixé.
   • Écrire une fonction point_aleatoire_disque(r), qui retourne le couple de coordonnées $(x,y)$ d'un point choisi aléatoirement dans un disque de rayon r dont le centre est l'origine du repère. On pourra implémenter l'algorithme ci-dessous.

     xA ← réel au hasard de -r à r
     yA ← réel au hasard de -r à r
     Tant que xA * xA + yA * yA > r * r :
         xA ← réel au hasard de -r à r
         yA ← réel au hasard de -r à r           
                 

   • La fenêtre de turtle étant carrée et non circulaire, pour qu'elle contienne un disque centré en l'origine et de rayon fixé, on la fait correspondre au carré circonscrit au disque. On importe d'abord le module turtle puis on munit la fenêtre d'un repère orthonormal tel que xmin = -rayon , xmax = rayon, ymin = -rayon et ymax =rayon. Ci-dessous un exemple pour rayon = 5.

     Rechercher dans la documentation de turtle, la fonction circle et l'utiliser pour tracer le cercle rouge délimitant le disque choisi.

     
     from turtle import *
     
     rayon = 5
     fenetre = Screen()								            # Instance de la fenêtre
     fenetre.setworldcoordinates(-rayon, -rayon ,rayon, rayon)   # Paramétrage du repère
     speed("fastest")                                            # Vitesse la plus rapide pour la tortue 
     shape("turtle")                                             # Forme de la tortue
     
             

   • Écrire une fonction distance_moyenne_disque(n) sur le modèle de distance_moyenne_carre(n), qui choisit un échantillon de n couples de points aléatoires dans un disque de rayon r, dessine tous les segments reliant ces couples de points avec la tortue et affiche la distance moyenne entre deux points.

from random import random

def point_aleatoire_carre(cote):
    return (cote * random(), cote * random())

print(point_aleatoire(20))
        

from math import sqrt

def distance(xA, yA, xB, yB):
    return sqrt((xB - xA) ** 2 + (yB - yA) ** 2) 
        

from random import random
from turtle import *
from math import sqrt


def point_aleatoire_carre(cote):
    return (cote * random(), cote * random())

def distance(xA, yA, xB, yB):
    return sqrt((xB - xA) ** 2 + (yB - yA) ** 2)                                   
                                   
def distance_moyenne_carre(n, cote):
    fenetre = Screen()								# Instance de la fenêtre
    fenetre.setworldcoordinates(0, 0, cote, cote)   # Paramétrage du repère
    speed("fastest")                                # Vitesse la plus rapide pour la tortue
    shape("turtle")     
    somme = 0
    for i in range(0,n) :
        #premier point aléatoire
        (xA, yA) = point_aleatoire_carre(cote)        
        up()
        goto(xA, yA)
        down()
        #deuxieme point aléatoire
        (xB, yB) = point_aleatoire_carre(cote)
        goto(xB, yB)        
        somme = somme + distance(xA, yA, xB, yB)
    print(somme/n)
    exitonclick()                                    #Pour fermer la fenêtre de la tortue avec un click lors d'une exécution sous Pyzo



distance_moyenne_carre(100, 20)

from random import random, randint
from turtle import *
from math import sqrt

def point_aleatoire_disque(rayon):
    xA = random() * 2 * rayon - rayon
    yA = random() * 2 * rayon - rayon
    while xA ** 2 + yA ** 2 > rayon ** 2:
        xA = random() * 2 * rayon - rayon
        yA = random() * 2 * rayon - rayon
    return (xA, yA)

def distance(xA, yA, xB, yB):
    return sqrt((xB - xA) ** 2 + (yB - yA) ** 2)                                   
                                   
def distance_moyenne_disque(n, rayon):
    fenetre = Screen()								# Instance de la fenêtre
    fenetre.setworldcoordinates(-rayon, -rayon, rayon, rayon)   # Paramétrage du repère
    speed("fastest")                                # Vitesse la plus rapide pour la tortue
    shape("turtle")
    #Tracé du disque de rayon r
    goto(rayon, 0)
    setheading(90)
    color("red")
    circle(rayon)
    color("black")
    somme = 0
    for i in range(0,n) :
        #premier point aléatoire
        (xA, yA) = point_aleatoire_disque(rayon)        
        up()
        goto(xA, yA)
        down()
        #deuxieme point aléatoire
        (xB, yB) = point_aleatoire_disque(rayon)
        goto(xB, yB)        
        somme = somme + distance(xA, yA, xB, yB)
    print(somme/n)
    exitonclick()                                    #Pour fermer la fenêtre de la tortue avec un click lors d'une exécution sous Pyzo


distance_moyenne_disque(100, 5)