Le module turtle permet programmer des dessins. Il est issu de l'ancien langage LOGO. C'est un module qui permet d'aborder de nombreux thèmes en ISN :

la notion de boucles ;
la définition des couleurs (nommées, au format RGB ou héxadécimal) ;
la création de fonctions ;
l'utilisation conjointe avec d'autres modules (math, random, PIL, etc...).

Les principales fonctions mises à votre disposition dans le module turtle sont les suivantes :

Vous pouvez aussi télécharger un petit résumé au format .pdf en cliquant ici.

Activité

Testez les deux scripts suivants :

from turtle import *
forward(120)
left(90)
color("red")
forward(80)

from turtle import *
a = 0
while a < 12:
	a = a + 1
	forward(150)
	left(150)

Écrire une fonction carre() permettant de tracer un carré rouge de coté 100 à l’appel de carre(100, 'red').
Écrire un script utilisant la fonction carre() et donnant le résultat :
Reprendre les deux questions précédentes en remplaçant le carré par un triangle équilatéral de côté 100 pixels.

Une piste ?
Une solution ?

Question 2

Utiliser une boucle for. Attention à bien calculer le bon angle de rotation selon le sens.


from turtle import *

# Fonction carre
def carre(taille, couleur):
	"""fonction qui dessine un carré de taille et de couleur déterminées"""
	color(couleur)
	for k in range(4):
		forward(taille)
		right(90)
							
# Fonction triangle
def triangle(taille, couleur):
	"""fonction qui dessine un triangle équilatéral de taille et de couleur déterminées"""
	color(couleur)
	for k in range(3):
		forward(taille)
		left(120)

Écrire un script avec Python permettant d'obtenir la figure suivante :

Une piste ?
Une solution ?

Définir une première fonction carre() puis une deuxième fonction ncarre() appelant n fois la fonction carre() en faisant tourner le curseur du bon angle.


from turtle import *

def carre(taille, couleur):
	"fonction qui dessine un carré de taille et de couleur déterminées"
	color(couleur)
	begin_fill()
	c = 0
	while c < 4:
		forward(taille) # en pixels
		right(90) # tourner le curseur à droite de 90 degrés
		c = c + 1
	end_fill()

up() # relever le crayon
goto(-150, -50) # reculer en haut à gauche

def ncarre(n):
	"Choisir le nombre de carré(s) en argument"
	for i in range(n):
		down() # abaisser le crayon
		carre(25, 'red') # tracer un carré
		up() # relever le crayon
		forward(30) # avancer + loin
		left(10)

ncarre(36) # appel de la fonction précédente pour dessiner 36 carrés pour faire une tour complet

-->

Écrire un script avec Python permettant d'obtenir la figure suivante :

Une piste ?
Une solution ?

Même idée que l'exercice précédent en introduisant une fonction triangle().


from turtle import *

def carre(taille, couleur):
	"fonction qui dessine un carré de taille et de couleur déterminées"
	color(couleur)
	begin_fill()
	c = 0
	while c < 4:
		forward(taille) # en pixels
		right(90) # tourner le curseur à droite de 90 degrés
		c = c + 1
	end_fill()

# Fonction triangle
def triangle(taille, couleur):
	"fonction qui dessine un triangle équilatéral de taille et de couleur déterminées"
	color(couleur)
	begin_fill()
	for k in range(3):
		forward(taille)
		left(120)
	end_fill()

up() # relever le crayon
goto(-150, -30) # reculer en haut à gauche

def npolygone(n):
	"Choisir le nombre de carré(s) en argument"
	for i in range(n):
		down() # abaisser le crayon
		carre(25, 'red') # tracer un carré
		up() # relever le crayon
		forward(30) # avancer + loin
		left(10)
		triangle(25, 'blue')
		forward(30) # avancer + loin
		left(10)

npolygone(18) # appel de la fonction précédente pour dessiner 18 séries carré+triangle

Flocons de neige

Écrire un programme permettant de dessiner les flocons de neige ci-dessous :

Une solution ?


##----------Importation des modules---------##
from turtle import *

##----------Définition des Fonctions----------##
def retour(t, x, y):
    t.up()
    t.goto(x, y)
    t.down()

def pointe1(t, dist):
    """Cette fonction trace une pointe de flèche."""
    t.right(135)
    t.forward(dist)
    t.backward(dist)
    t.right(90)
    t.forward(dist)
    t.right(135)                # Retour à l'orientation d'origine

def pointe2(t, dist):
    """Cette fonction trace une pointe de flèche inversée."""
    t.right(180)
    pointe1(t, dist)
    t.right(180)                # Retour à l'orientation d'origine
            
def pointec(t, dist):
    """Cette fonction trace une pointe carrée."""
    t.right(45)
    for i in range(4):
        t.forward(dist)
        t.left(90)
    t.left(45)                  # Retour à l'orientation d'origine


##----------Programme Principal----------##
stylo = Pen()
stylo.width(2)
stylo.speed(0)
rayon = 100
cote = 20

for i in range(3):
    stylo.setheading(-30)
    abscisse = 3*rayon*(i-1)
    retour(stylo, abscisse, 0)
    for j in range(6):
        stylo.left(60)
        stylo.forward(rayon)
        if i%3==0:
            pointe1(stylo, cote)
        elif i%3 == 1:
            pointe2(stylo, cote)
        else:
            pointec(stylo, cote)
        retour(stylo, abscisse, 0)
    
            
stylo.hideturtle()
exitonclick()

Courbes paramétrées

Dessiner en utilisant les mathématiques, c'est joli. Le programme ci-dessous doit :

Demander à l'utilisateur les valeurs de deux nombres entiers \(n\) et \(d\) ;
Afficher à l'écran la valeur simplifiée de la fraction \(k = \frac{n}{d}\)
Tracer la rosace d'équation polaire \(r = \cos(k\theta)\).

Un «rappel» : la forme paramétrique de la courbe est alors donnée par les fonctions \(x = \cos(k\theta)\sin(\theta)\) et \(y = \cos(k\theta)\cos(\theta)\).

Une solution ?


##----- Importation des Modules -----##
from turtle import *
from math import *

##----- Définition des Fonctions -----##
def pgcd(a, b):
    """Déterminer le pgcd entre deux nombres."""
    quotient = a//b
    reste = a%b
    while reste != 0 :
        a = b
        b = reste
        quotient, reste = a//b, a%b
    return b

def simplifier(a, b):
    """Renvoie les valeurs simplifiées du numérateur et du dénominateur d'une fraction."""
    p = pgcd(a, b)
    a = a//p
    b = b//p
    return (a, b)

def ecrire(a, b):
    """Renvoie l'écriture de la forme irréductible de la fraction a/b."""
    a, b = simplifier(a, b)
    if b == 1:
        return str(a)
    else:
        return str(a)+'/'+str(b)

##----- Déclaration des Variables -----##
n = int(numinput('Saisie d\'un nombre', 'Donner la valeur d\'un entier n'))
d = int(numinput('Saisie d\'un autre nombre', 'Donner la valeur d\'un entier d'))
k = n/d
stylo = Pen()

##----- Écriture de la fraction simplifiée -----##
stylo.up()
stylo.goto(-120, 120)
stylo.down()
stylo.write('k = '+ecrire(n, d))

##----- Tracé de la rosace -----##
angle = 0
stylo.up()
stylo.goto(0, 100)
stylo.down()
stylo.width(2)

if k%2 == 1:                                            # Pour gérer au mieux le nombre de répétitions
    tours = 1
else:
    tours = 2*simplifier(n, d)[1]

while angle <= tours*pi:
    angle += pi/72
    x = 100*cos(k*angle)*sin(angle)                     # On multiplie par 100 pour y voir quelque chose...
    y = 100*cos(k*angle)*cos(angle)
    stylo.goto(x, y)

stylo.hideturtle()
exitonclick()

Liste de crayons

La rosace ci-contre a été dessinée en utilisant un liste de crayons. Chaque «pétale» a été dessiné par un crayon différent. Voici quelques pistes pour reproduire cette figure :

Demander à l'utilisateur le nombre de pétales désirés.
Définir une liste vide qui contiendra les futurs crayons.
En utilisant une boucle, créer un nouveau crayon, définir ses caractéristiques (épaisseur, couleur, orientation, etc...) puis ajouter ce crayon à la liste précédente.
Chaque crayon effectue ensuite une succession de déplacements de 15 pixels, entrecoupés d'une rotation dont l'angle va de 0 à 16 degrés puis revient à 0 degrés avec un pas de 1.

Une piste ?
Une autre piste ?
Une solution ?

Pour les couleurs, utiliser colormode(255) afin de générer des couleurs aléatoires au format RGB.

Chaque nouveau crayon inséreé dans la liste doit avoir une orientation différente des crayons précédents. On rappelle qu'un plan est partagé en 360 degrés...


##----- Importation des Modules -----##
from turtle import *

##----- Définition des Fonctions -----##
def deplacer(liste_crayons, longueur, angle):
    for stylo in liste_crayons:
        stylo.forward(longueur)
        stylo.left(angle)

##----- Déclaration des Variables -----##
colormode(255)                                      # Couleurs au format RGB
liste_stylos = []
n = int(numinput('Saisie d\'un nombre', 'Donner le nombre de crayons à manipuler'))

angle = 360/n                                       # Ecart angulaire entre chaque crayon
orientation = 0                                     # Orientation du 1er crayon

##----- Création de la liste de crayons -----##
for i in range(n):
    stylo = Pen()                                   # Un crayon quelconque
    stylo.setheading(orientation)
    stylo.width(2)
    stylo.pencolor(255*1/(i+1), 255*1/(n-i), 255*(n-i)/n)
    stylo.speed(10)
    liste_stylos.append(stylo)
    orientation += angle

##----- Tracé de la rosace -----##
for i in range(16):
    deplacer(liste_stylos, 15, i)

for i in range(16, -2, -1):
    deplacer(liste_stylos, 15, i)

for stylo in liste_stylos:
    stylo.hideturtle()

exitonclick()