Polygone régulier

Testez le script suivant :


from turtle import *


def carre(cote = 40, sens = 'trigo', couleur = 'black', epaisseur = 2, depart = (0,0) ) :
    penup()						# on lève le crayon pour ne pas tracer
    setposition(depart)			# la tortue se place au point depart
    pencolor(couleur)			# on fixe la couleur du crayon
    pensize(epaisseur)			# on fixe l'épaisseur du crayon
    if sens == 'trigo' : 
        angle = 90 
    else :
        angle = 270				# 3*90
    
    pendown()					# on abaisse le crayon pour tracer
    for _ in range(4) :
        forward(cote)			# on avance de la longueur cote dans l'orientation donnée par la tortue
        left(angle)				# la tortue tourne sur sa gauche de angle degrés.
    penup()
   
   

# on donne à la tortue une forme de tortue (par défaut la forme est celle d'un triangle) :  
shape("turtle")
# premier appel : 
carre(cote = 30, couleur = 'red')
# second appel : 
carre( depart = (0,-5), sens = 'pendule', epaisseur =  5, couleur = 'green')
 
exitonclick()					# ferme la fenêtre d'affichage lorsqu'on clique dessus

Généralisez ce script : la fonction devra maintenant tracer un polygone régulier de n côtés (n étant un paramètre de la fonction).

Commentaire
Paramètres nommés
Une solution

On peut au préalable faire un travail sur la somme des angles dans un polygone et l'angle en un sommet dans un polygone régulier.

On peut donner des valeurs par défaut aux paramètres d'une fonction. On appellera alors la fonction en nommant les paramètres. Cela permet également de les donner dans le désordre.

Exemple :


def nommons( Albert = 2, Gertrude = 3, Barnabe = 5) :
    print("Valeur de Albert : ", Albert)
    print("Valeur de Gertrude : ", Gertrude)
    print("Valeur de  Barnabe : ", Barnabe)
    print("******************************************")
    print()
	
	
nommons(Albert = 100)
nommons(Barnabe = -2, Albert = 0)

On obtient :

Valeur de Albert :  100
Valeur de Gertrude :  3
Valeur de  Barnabe :  5
******************************************

Valeur de Albert :  0
Valeur de Gertrude :  3
Valeur de  Barnabe :  -2
******************************************


from turtle import *


def polygone(nbcote = 3, cote = 40, sens = 'trigo', couleur = 'black', epaisseur = 1, depart = (0,0) ) :
    penup()						# on lève le crayon pour ne pas tracer
    setposition(depart)			# la tortue se place au point depart
    pencolor(couleur)			# on fixe la couleur du crayon
    pensize(epaisseur)			# on fixe l'épaisseur du crayon
    if sens == 'trigo' : 
        def tourne() :
            left(360//nbcote)
    else :
        def tourne() :
            right(360//nbcote) 
    
    pendown()					# on abaisse le crayon pour tracer
    for _ in range(nbcote) :
        forward(cote)			# on avance de la longueur cote dans l'orientation donnée par la tortue
        tourne()				# la tortue tourne de angle degrés.
    penup()  
   
 
 
# premier appel : 
polygone(cote = 30, couleur = 'red')
# second appel : 
polygone( depart = (0,-5), nbcote=6, sens = 'pendule', epaisseur =  5, couleur = 'green')

#on cache la tortue à la fin du tracé :
hideturtle()
 
exitonclick()					# ferme la fenêtre d'affichage lorsqu'on clique dessus

Un peu de géométrie

On donne le programme suivant, en langage Python, qui fait appel au module turtle :

from turtle import *

penup()
goto(40, 100)
pendown()
goto(-80, -60)

circle(50)

On rappelle que, par défaut, le repère dans lequel la tortue dessine est orthonormé.

On nomme $[AB]$ le segment tracé, avec $A(-80 ; -60)$ et $B(40 ; 100)$.
La dernière instruction doit tracer le cercle de diamètre $[AB]$. Est-ce le cas ?
Modifier l'instruction de la ligne 8 afin de tracer le cercle de diamètre $[AB]$.
Écrire les instructions supplémentaires qui permettent de tracer le triangle $ABC$, où $C$ est le point de coordonnées $(-20 ; -80)$.
Le point $C$ appartient-il au cercle de diamètre $[AB]$ ?
Généralisation :
Quelles que soient les coordonnées des points distincts $A$ et $B$, concevoir un programme qui trace le segment $[AB]$ ainsi que le cercle de diamètre $[AB]$. On pourra tester ce programme à l'aide du module random, avec des valeurs de coordonnées comprises entre -150 et 150.

Question 2°/
Question 3°/
Question 4°/
Une piste pour le 5°/
Question 5°/

Deux questions de mathématiques se posent :

Quel est la longueur du segment $[AB]$ ?
Comment orienter la tortue perpendiculairement au segment $[AB]$ pour tracer convenablement le cercle ?

Les réponses à ces questions sont données dans le script-solution ci-dessous :

from turtle import *

up()
goto(40, 100)
down()
goto(-80, -60)

right(36.87)	# Un peu de trigo. Attention, tracé dans le sens direct
circle(100)		# Le segment [AB] mesure 200 pixels

from turtle import *

up()
goto(40, 100)
down()
goto(-80, -60)

right(36.87)	# Un peu de trigo. Attention, tracé dans le sens direct
circle(100)		# Le segment [AB] mesure 200 pixels

goto(-20, -80)
goto(40, 100)

La réciproque du théorème de Pythagore et le cercle circonscrit à un triangle rectangle permettent de répondre à cette question.

Le module math contient les fonctions acos(), asin() et atan() qui sont les fonctions réciproques respectives des fonctions cos(), sin() et tan(). Ces fonctions renvoient la valeur d'un angle en radians.

Ce module contient aussi les fonctions degrees() et radians() dont nous vous laissons deviner l'usage. Elles peuvent être très utiles sachant que les angles déclarés dans les fonctions du module turtle doivent être en degrés...

On utilise un couple de coordonnées pour symboliser chacun des points. En ce qui concerne les mathématiques, nous vous laissons faire...


from turtle import *
from random import randint
from math import atan, degrees, sqrt	# atan renvoie des valeurs d'angle en radians
                                        # degrees permettra de les convertir pour la tortue

def petit(a, b):
    return a <= b


def angle(x1, y1, x2, y2):
    """y1 doit être plus petit que y2"""
    if petit(x1, x2):
        return degrees(atan((x1-x2)/(y1-y2)))
    else:
        return degrees(atan((y2-y1)/(x1-x2)))-90


def longueur(x1, y1, x2, y2):
    d = (x1-x2)**2+(y1-y2)**2
    return sqrt(d)


##---- Coordonnées choisies au hasard ----##
x1, y1 = randint(-150, 150), randint(-150, 150)
x2, y2 = randint(-150, 150), randint(-150, 150)

##---- L'ordonnée y1 doit être la plus petite -----##
if not petit(y1, y2):
    x1, y1, x2, y2 = x2, y2, x1, y1

##----- Tracé du segment et du cercle -----##
up()
goto(x2, y2)
down()
goto(x1, y1)
right(angle(x1, y1, x2, y2))
circle(longueur(x1, y1, x2, y2)/2)

exitonclick()

Travail sur les boucles

Écrire un programme représentant un damier à l'aide de la tortue.

Un code possible
Seconde version du même code


from turtle import *

##----- Constantes du programme -----##
unite = 10						# unité : longueur du côté d'une case du damier
nb_lignes = 5					# nombre de lignes du damier
nb_colonnes = 7					# nombre de colonnes du damier
couleurs = ('red', 'yellow')	# les deux couleurs du damier

##----- Modification du repère d'origine -----##
largeur = (max(nb_lignes, nb_colonnes)+1)*unite
fenetre = Screen()
fenetre.setworldcoordinates( -unite, -unite, largeur, largeur)

fenetre.delay(1)				# Attente avant de démarrer le tracé


##----- Définition des fonctions -----##
def aller_a_sans_tracer(x, y) :
    """ On place la tortue en (x,y) sans tracer."""
    penup()
    goto(x, y)
    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)
    fillcolor(couleur)
    begin_fill()
    for i in range(4):
        forward(unite)
        left(90)
    end_fill()
	
	
def ligne(y, numcouleur):
    """
    Une ligne du damier, la case de gauche porte la couleur  couleurs[numcouleur].
    """
    x = 0
    for k in range(nb_colonnes):
        couleur = couleurs[numcouleur]
        carre(x, y, couleur)
        numcouleur = 1 - numcouleur
        x += unite
		 
		
def damier(numcouleur):
    for l in range(0, nb_lignes) :
        couleur = couleurs[numcouleur]
        ligne(l*unite, numcouleur)
        numcouleur = 1 - numcouleur


##----- Tracé du damier -----##
damier(0)		
exitonclick()

Dans cette version, on affecte la tortue à une variable, ce qui permet de mieux identifier l'objet manipulé plutôt que travailler sur un objet anonyme.


import turtle

##----- Constantes du programme -----##
unite = 10						# unité : longueur du côté d'une case du damier
nb_lignes = 5					# nombre de lignes du damier
nb_colonnes = 7					# nombre de colonnes du damier
couleurs = ('red', 'yellow')	# les deux couleurs du damier

##----- Modification du repère d'origine -----##
largeur = (max(nb_lignes, nb_colonnes)+1)*unite
turtle.setworldcoordinates( -unite, -unite, largeur, largeur)

turtle.delay(1)					# Attente avant de démarrer le tracé
tortue = turtle.Turtle()		# Tortue stockée dans une variable 


##----- 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 ligne(y, numcouleur):
    """
    Une ligne du damier, la case de gauche porte la couleur  couleurs[numcouleur].
    """
    x = 0
    for k in range(nb_colonnes):
        couleur = couleurs[numcouleur]
        carre(x, y, couleur)
        numcouleur = 1 - numcouleur
        x += unite
		 
		
def damier(numcouleur):
    for l in range(0, nb_lignes) :
        couleur = couleurs[numcouleur]
        ligne(l*unite, numcouleur)
        numcouleur = 1 - numcouleur


##----- Tracé du damier -----##
damier(0)		
turtle.exitonclick()