Plus tard ! Le contenu de cette page peut être travaillé en seconde lecture.

Algorithmique et programmation ont été introduits dans les classes de collège en 2016-2017. De même que le document ressource pour la classe de seconde ne propose que des exemples en langage Python, le document ressource pour le collège ne présente que des exemples avec le logiciel Scratch.

Les sujets du DNB 2017 présentaient des exercices sur ce thème, tous illustrés avec Scratch.

Dans ce qui suit, nous vous présentons quelques-uns de ces sujets et vous demandons de les réécrire en Python à l'aide du module turtle.

Vous trouverez la documentation du module turtle ici.

Exercice 2, métropole.

Traduire le programme proposé avec le module turtle de Python.
Donner de même le script modifié demandé en question 4.

Question 1 - Version 1
Question 1 - Version 2
Question 2 - Version 1
Question 2 - Version 2

Une version « classique » :

from turtle import *

def triangle(cote):
	pendown()				# on pose le crayon
	for i in range(3):
		forward(cote)		# on avance de la longueur cote
		left(120)			# tourne à gauche de 120 degrés
	penup()					# on relève le crayon
		
	
	
def aller_a_sans_tracer(x, y) :
	""" On place la tortue en (x,y) sans tracer."""
	penup()
	goto(x, y)
	pendown()

##----- Initialisation du tracé -----##
reset()						# effacer tout
aller_a_sans_tracer(-200, -100) 
setheading(0)				# orientation vers la droite 
cote = 100

##----- Le tracé -----##
for i in range(5):
	triangle(cote)
	forward(cote)
	cote = cote-20

exitonclick()

Une version orientée-objet, où la tortue est affectée à une variable. Dans ce cas, la tortue est aussi définie comme paramètre des fonctions.

import turtle
morla = turtle.Turtle()			# une tortue


def triangle(tortue, cote):
	tortue.pendown()			# on pose le crayon
	for _ in range(3):
		tortue.forward(cote)	# on avance de la longueur cote
		tortue.left(120)		# tourne à gauche de 120 degrés
	tortue.penup()				# on relève le crayon
		
	
	
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()

morla.reset() # effacer tout
aller_a_sans_tracer(morla, -200, -100) 
morla.setheading(0)				# orientation vers la droite 
cote = 100

for _ in range(5):
	triangle(morla, cote)
	morla.forward(cote)
	cote = cote-20

turtle.exitonclick()

Une version « classique » :

from turtle import *

def triangle(cote):
	pendown()				# on pose le crayon
	for i in range(3):
		forward(cote)		# on avance de la longueur cote
		left(120)			# tourne à gauche de 120 degrés
	penup()					# on relève le crayon
		
	
	
def aller_a_sans_tracer(x, y) :
	""" On place la tortue en (x,y) sans tracer."""
	penup()
	goto(x, y)
	pendown()

##----- Initialisation du tracé -----##
reset()						# effacer tout
aller_a_sans_tracer(-200, -100) 
setheading(0)				# orientation vers la droite 
cote = 100

##----- Le tracé -----##
for i in range(5):
	triangle(cote)
	forward(cote)
	left(60)
	cote = cote-20

exitonclick()

Une version orientée-objet, où la tortue est affectée à une variable. Dans ce cas, la tortue est aussi définie comme paramètre des fonctions.

import turtle
morla = turtle.Turtle()


def triangle(tortue, cote):
	tortue.pendown()
	for _ in range(3):
		tortue.forward(cote)
		tortue.left(120)
	tortue.penup()
		
	
	
def aller_a_sans_tracer(tortue, x, y) :
	tortue.penup()
	tortue.goto(x, y)
	tortue.pendown()

morla.reset()
aller_a_sans_tracer(morla, -200, -100) 
morla.setheading(0)
cote = 100

for _ in range(5):
	triangle(morla, cote)
	morla.forward(cote)
	morla.left(60)
	cote -= 20

turtle.exitonclick()

Exercice 6, centres étrangers.

Traduire le script de l'énoncé avec le module turtle de Python.
Répondre à la question 2 expérimentalement avec un script.
Modifier votre script Python de façon à ajouter une "belle sortie de cheminée".

Questions 1 et 2
Question 3

On a ajouté des instructions d'affichage des coordonnées de la tortue lorsqu'elle se trouve au point de départ et lorsqu'elle arrête de construire.


import turtle


# même fenêtre que scratch : 
xmin, ymin = -240, -180
xmax, ymax = 240, 180
turtle.setworldcoordinates(xmin, ymin, xmax, ymax)
  
 
 
 
# tortue de chantier :
constructeur = turtle.Turtle()

def maison() :
	constructeur.left(90)
	constructeur.forward(50)
	constructeur.right(45)
	constructeur.forward(50)
	constructeur.right(90)
	constructeur.forward(50)
	constructeur.right(45)
	constructeur.forward(50)
	constructeur.left(90)
	
	
def drapeau(n) :
	# cacher tortue :
	constructeur.hideturtle()
	# taille du stylo à 1 :
	constructeur.pensize(1)
	# effacer tout :
	constructeur.reset()
	# aller à (-240; 0) sans tracer :
	constructeur.penup()
	constructeur.goto(-240, 0)
	# pour vérifier coordonnées tortue 
	# (affichage dans le terminal) : 
	print(constructeur.pos())
	# stylo en position d'écriture :
	constructeur.pendown()
	# s'orienter à 0 (vers la droite) 
	# Par défaut en scratch  0 vers le haut, 90 vers la droite.
	# Par défaut, la tortue : comme cercle trigo math. 
	constructeur.setheading(0)
	# n répétitions :
	for _ in range(n) :
		maison()
		constructeur.forward(20)
	# pour vérifier coordonnées tortue 
	# (affichage dans le terminal) : 
	print(constructeur.pos())
	
	
	
drapeau(5)		
		
turtle.done()

On obtient :

Et dans le terminal :


import turtle
from math import sqrt

# même fenêtre que scratch : 
xmin, ymin = -240, -180
xmax, ymax = 240, 180
turtle.setworldcoordinates(xmin, ymin, xmax, ymax)
  
 
 
 
# tortue de chantier :
constructeur = turtle.Turtle()

def maison() :
	# mur gauche :
	constructeur.left(90)
	constructeur.forward(50)
	# pan toit gauche :
	constructeur.right(60)
	constructeur.forward(24)
	# mur gauche de la sortie de cheminée :
	constructeur.left(60)
	constructeur.forward(13)
	# dessus cheminée :
	constructeur.right(90)
	constructeur.forward(5 * sqrt(3))
	# mur droit sortie cheminée :
	constructeur.right(90)
	constructeur.forward(8)
	# fin pan toit gauche :
	constructeur.left(90 + 30)
	constructeur.forward(16)
	# pan toit droit : 
	constructeur.right(2*30)
	constructeur.forward(50)
	# mur droit :
	constructeur.right(60)
	constructeur.forward(50)
	constructeur.left(90)
	
	
def drapeau(n) :
	# cacher tortue :
	constructeur.hideturtle()
	# taille du stylo à 1 :
	constructeur.pensize(1)
	# effacer tout :
	constructeur.reset()
	# aller à (-240; 0) sans tracer :
	constructeur.penup()
	constructeur.goto(-240, 0)
	# stylo en position d'écriture :
	constructeur.pendown()
	# s'orienter à 0 (vers la droite) 
	# Par défaut en scratch  0 vers le haut, 90 vers la droite.
	# Par défaut, la tortue : comme cercle trigo math. 
	constructeur.setheading(0)
	# n répétitions :
	for _ in range(n) :
		maison()
		constructeur.forward(20)
	
	
	
	
drapeau(4)		
		
turtle.done()

On obtient :

Exercice 5, Amérique du nord.

Énoncé posé aux élèves

L’image ci-dessous représente la position obtenue au déclenchement du bloc départ d’un programme de jeu.

L’arrière-plan est constitué de points espacés de 40 unités. Dans cette position, le chat a pour coordonnées (−120 ; −80). Le but du jeu est de positionner le chat sur la balle.

Quelles sont les coordonnées du centre de la balle représentée dans cette position ?
Dans cette question, le chat est dans la position obtenue au déclenchement du bloc départ. Voici le script du lutin « chat » qui se déplace :
1. Expliquez pourquoi le chat ne revient pas à sa position de départ si le joueur appuie sur la touche → puis sur la touche ←.
2. Le joueur appuie sur la succession de touches suivante : → → ↑ → ↓. Quelles sont les coordonnées $x$ et $y$ du chat après ce déplacement ?
3. Parmi les propositions de succession de touches ci-dessous, laquelle permet au chat d’atteindre la balle ?
  
  Déplacement 1 Déplacement 2 Déplacement 3
  
  → → → → → → → ↑ ↑ ↑ ↑ ↑ → → → ↑ ↑ ↑ → ↓ ← ↑ → ↑ → ↑ → → ↓ ↓
Que se passe-t-il quand le chat atteint la balle?

Déplacement 1	Déplacement 2	Déplacement 3
`→ → → → → → → ↑ ↑ ↑ ↑ ↑`	`→ → → ↑ ↑ ↑ → ↓ ←`	`↑ → ↑ → ↑ → → ↓ ↓`

Travail demandé

Réaliser la figure initiale (grille de points et axes) avec le module turtle.
Écrire une fonction depart() plaçant la tortue en (-120, -80) et une balle en (160, 120).
Écrire l'équivalent du script Scratch (déplacements de la tortue par appui sur les touches) en termes d'événements turtle.
Ajouter maintenant l'équivalent du script Scratch concernant l'annonce "Je t'ai attrapé" (suivi du retour à l'état de départ).

Question 1
Question 2
Question 3
Question 4

Une proposition ci-dessous. Nous vous laissons l'améliorer (petites flèches sur les axes, tirets au lieu de points sur les axes).


# on importe le module turtle :
import turtle


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_point(tortue, x, y) :
	# la tortue se place en (x,y) sans tracer :
	aller_a_sans_tracer(tortue, x, y)
	# la tortue dessine un disque noir : 
	tortue.pensize(3)
	tortue.pencolor('black')
	tortue.dot()
	
	
def dessine_grille(tortue, pas, cigx, cigy, csdx, csgy) :
	""" (cigx, cigy) : coordonnées du coin inférieur gauche 
	du rectangle délimitant la grille.
	(csdx, csgy) : coordonnées du coin supérieur droit.
	"""
	for x in range( cigx, csdx + pas, pas) :
		for y in range( cigy, csgy + pas, pas) :
			dessine_point(tortue, x, y)
	


def dessine_axes(tortue, cigx, cigy, csdx, csgy) :
	""" 
	(cigx, cigy) : coordonnées du coin inférieur gauche 
	du rectangle délimitant la grille.
	(csdx, csgy) : coordonnées du coin supérieur droit.
	"""
	# axe des abscisses : 
	aller_a_sans_tracer(tortue, cigx, 0)
	tortue.pendown()
	tortue.goto(csdx, 0)
	tortue.penup()
	# axe des ordonnées : 
	aller_a_sans_tracer(tortue, 0, cigy)
	tortue.pendown()
	tortue.goto(0, csgy)
	tortue.penup()


#  création d'un objet tortue :
caroline = turtle.Turtle()
# on lui donne la forme d'une tortue :
caroline.shape('turtle')
# dimension du canevas : 
turtle.setworldcoordinates(-240, - 120, 240, 120)



# dessin des axes :
dessine_axes(caroline, -240, -120, 240, 120)


# dessin de la grille de points : 
dessine_grille(caroline, 40, -240, -120, 240, 120)



 
turtle.exitonclick()

On obtient :

Une proposition :


# on importe le module turtle :
import turtle


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_point(tortue, x, y, diametre, couleur) :
	""" Dessine un point,  
	de diamètre = diametre. """
	# la tortue se place en (x,y) sans tracer :
	aller_a_sans_tracer(tortue, x, y)
	# la tortue dessine un disque noir : 
	tortue.pensize(diametre)
	tortue.pencolor(couleur)
	tortue.dot()
	
	
def dessine_grille(tortue, pas, cigx, cigy, csdx, csgy) :
	""" (cigx, cigy) : coordonnées du coin inférieur gauche 
	du rectangle délimitant la grille.
	(csdx, csgy) : coordonnées du coin supérieur droit.
	"""
	for x in range( cigx, csdx + pas, pas) :
		for y in range( cigy, csgy + pas, pas) :
			dessine_point(tortue, x, y, 3, 'black')
	


def dessine_axes(tortue, cigx, cigy, csdx, csgy) :
	""" 
	(cigx, cigy) : coordonnées du coin inférieur gauche 
	du rectangle délimitant la grille.
	(csdx, csgy) : coordonnées du coin supérieur droit.
	"""
	tortue.pencolor('black')
	# axe des abscisses : 
	aller_a_sans_tracer(tortue, cigx, 0)
	tortue.pendown()
	tortue.goto(csdx, 0)
	tortue.penup()
	# axe des ordonnées : 
	aller_a_sans_tracer(tortue, 0, cigy)
	tortue.pendown()
	tortue.goto(0, csgy)
	tortue.penup()
	
	
	
	
def dessine_balle(tortue, x,y) :
	"""dessine une balle et la place en position (x,y). """
	dessine_point(tortue, x, y, 6, 'red')
	
	
def depart(tortue) :
	"""place la tortue en (-120, -80)
	et une balle en (160, 120). """
	dessine_balle(tortue, 160, 120)
	aller_a_sans_tracer(tortue, -120, -80) 





#  création d'un objet tortue :
caroline = turtle.Turtle()
# on lui donne la forme d'une tortue :
caroline.shape('turtle')
# dimension du canevas : 
turtle.setworldcoordinates(-240, - 120, 240, 120)
# vitesse :
caroline.speed(0)



# dessin des axes :
dessine_axes(caroline, -240, -120, 240, 120)


# dessin de la grille de points : 
dessine_grille(caroline, 40, -240, -120, 240, 120)

# les positions au départ du jeu  :
depart(caroline)

 
turtle.exitonclick()

On obtient :

Dans la proposition ci-dessous, quelques modifications ont été apportées : nous introduisons une seconde tortue. La première sert à préparer le terrain de jeu (dessin des axes, de la grille, de la position intiale de la balle). La seconde est la tortue du "jeu" (celle que l'on déplace par appui sur les flèches). Nous avons supprimé ici le paramètre tortue de certaines fonctions en utilisant les variables tortues en tant que variables globales. La fonction aller_a_sans_tracer(tortue, x, y) sera appelée par les deux tortues, le paramètre "tortue" est donc ici nécessaire.


# on importe le module turtle :
import turtle



# dimension du canevas : 
turtle.setworldcoordinates(-240, - 120, 240, 120)

# une première tortue qui servira aux dessins des axes, grille de points, balle :
preparation  = turtle.Turtle()
# cette tortue ne sera pas dessinée : 
preparation.hideturtle()
# on la rend speed :
preparation.speed(0)




#  la tortue qui servira au "jeu" :
caroline = turtle.Turtle()
# on lui donne la forme d'une tortue :
caroline.shape('turtle')



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_point(x, y, diametre, couleur) :
	""" Dessine un point,  
	de diamètre = diametre. """
	# la tortue se place en (x,y) sans tracer :
	aller_a_sans_tracer(preparation, x, y)
	# la tortue dessine un disque noir : 
	preparation.pensize(diametre)
	preparation.pencolor(couleur)
	preparation.dot()
	
	
def dessine_grille(pas, cigx, cigy, csdx, csgy) :
	""" (cigx, cigy) : coordonnées du coin inférieur gauche 
	du rectangle délimitant la grille.
	(csdx, csgy) : coordonnées du coin supérieur droit.
	"""
	for x in range( cigx, csdx + pas, pas) :
		for y in range( cigy, csgy + pas, pas) :
			dessine_point(x, y, 3, 'black')
	


def dessine_axes( cigx, cigy, csdx, csgy) :
	""" 
	(cigx, cigy) : coordonnées du coin inférieur gauche 
	du rectangle délimitant la grille.
	(csdx, csgy) : coordonnées du coin supérieur droit.
	"""
	preparation.pencolor('black')
	# axe des abscisses : 
	aller_a_sans_tracer(preparation, cigx, 0)
	preparation.pendown()
	preparation.goto(csdx, 0)
	preparation.penup()
	# axe des ordonnées : 
	aller_a_sans_tracer(preparation, 0, cigy)
	preparation.pendown()
	preparation.goto(0, csgy)
	preparation.penup()
	
	
	
	
def dessine_balle(x,y) :
	"""dessine une balle et la place en position (x,y). """
	dessine_point(x, y, 6, 'red')
	
	
def depart() :
	"""place la tortue en (-120, -80)
	et une balle en (160, 120). """
	dessine_balle(160, 120)
	aller_a_sans_tracer(caroline, -120, -80) 
	caroline.setheading(90)


def pas_gauche():
	# on lève le crayon pour s'assurer de ne rien tracer :
	caroline.penup()
	# un pas à gauche de -40 
	#(on pourrait utiliser un paramètre plutôt que cette valeur fixe de -40) : 
	caroline.setheading(180)
	caroline.forward(40)
	
	
	
def pas_droit():
	# on lève le crayon pour s'assurer de ne rien tracer :
	caroline.penup()
	# un pas à gauche de -40 
	#(on pourrait utiliser un paramètre plutôt que cette valeur fixe de -40) : 
	caroline.setheading(0)
	caroline.forward(40)
	
	
def pas_haut():
	# on lève le crayon pour s'assurer de ne rien tracer :
	caroline.penup()
	# un pas à gauche de -40 
	#(on pourrait utiliser un paramètre plutôt que cette valeur fixe de -40) : 
	caroline.setheading(90)
	caroline.forward(40)
	
	
def pas_bas():
	# on lève le crayon pour s'assurer de ne rien tracer :
	caroline.penup()
	# un pas à gauche de -40 
	#(on pourrait utiliser un paramètre plutôt que cette valeur fixe de -40) : 
	caroline.setheading(-90)
	caroline.forward(40)









 


# dessin des axes :
dessine_axes(-240, -120, 240, 120)


# dessin de la grille de points : 
dessine_grille(40, -240, -120, 240, 120)

# les positions au départ du jeu  :
depart()



# on crée une variable de type Screen :
screen = turtle.Screen() 
# on associe la fonction pas_gauche à l'appui de la touche flèche gauche : 
screen.onkey(pas_gauche, 'Left')
screen.onkey(pas_droit, 'Right')
screen.onkey(pas_haut, 'Up')
screen.onkey(pas_bas, 'Down')
# on lance une écoute des événements : 
screen.listen()
 
turtle.exitonclick()


# on importe le module turtle :
import turtle
# module pour fonction sleep : 
import time



# dimension du canevas : 
turtle.setworldcoordinates(-240, - 120, 240, 120)

# une première tortue qui servira aux dessins des axes, grille de points, balle :
preparation  = turtle.Turtle()

 

#  la tortue qui servira au "jeu" :
caroline = turtle.Turtle()



# tortue pour le message de victoire : 
disque = turtle.Turtle()




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_point(x, y, diametre, couleur) :
	""" Dessine un point,  
	de diamètre = diametre. """
	# la tortue se place en (x,y) sans tracer :
	aller_a_sans_tracer(preparation, x, y)
	# la tortue dessine un disque noir : 
	preparation.pensize(diametre)
	preparation.pencolor(couleur)
	preparation.dot()
	
	
def dessine_grille(pas, cigx, cigy, csdx, csgy) :
	""" (cigx, cigy) : coordonnées du coin inférieur gauche 
	du rectangle délimitant la grille.
	(csdx, csgy) : coordonnées du coin supérieur droit.
	"""
	for x in range( cigx, csdx + pas, pas) :
		for y in range( cigy, csgy + pas, pas) :
			dessine_point(x, y, 3, 'black')
	


def dessine_axes( cigx, cigy, csdx, csgy) :
	""" 
	(cigx, cigy) : coordonnées du coin inférieur gauche 
	du rectangle délimitant la grille.
	(csdx, csgy) : coordonnées du coin supérieur droit.
	"""
	preparation.pencolor('black')
	# axe des abscisses : 
	aller_a_sans_tracer(preparation, cigx, 0)
	preparation.pendown()
	preparation.goto(csdx, 0)
	preparation.penup()
	# axe des ordonnées : 
	aller_a_sans_tracer(preparation, 0, cigy)
	preparation.pendown()
	preparation.goto(0, csgy)
	preparation.penup()
	
	
	
	
def dessine_balle(x,y) :
	"""dessine une balle et la place en position (x,y). """
	dessine_point(x, y, 6, 'red')
	
	
def depart() :
	"""place la tortue en (-120, -80)
	et une balle en (160, 120). """
	dessine_balle(160, 120)
	aller_a_sans_tracer(caroline, -120, -80) 
	caroline.setheading(90)
	
	
	
	
def balle_attrapee() :
	if caroline.position() == (160, 120) :
		# affichage du message : 
		disque.write("Tu m'as attrapée.", font=("Arial", 12, "normal"))
		# attente de 2 secondes :
		time.sleep(2)
		# retour à l'état initial :
		raz()
		


def pas_gauche():
	# on lève le crayon pour s'assurer de ne rien tracer :
	caroline.penup()
	# un pas à gauche de -40 
	#(on pourrait utiliser un paramètre plutôt que cette valeur fixe de -40) : 
	caroline.setheading(180)
	caroline.forward(40)
	balle_attrapee()
	
	
def pas_droit():
	# on lève le crayon pour s'assurer de ne rien tracer :
	caroline.penup()
	# un pas à gauche de -40 
	#(on pourrait utiliser un paramètre plutôt que cette valeur fixe de -40) : 
	caroline.setheading(0)
	caroline.forward(40)
	balle_attrapee()
	
	
def pas_haut():
	# on lève le crayon pour s'assurer de ne rien tracer :
	caroline.penup()
	# un pas à gauche de -40 
	#(on pourrait utiliser un paramètre plutôt que cette valeur fixe de -40) : 
	caroline.setheading(90)
	caroline.forward(40)
	balle_attrapee()
	
	
def pas_bas():
	# on lève le crayon pour s'assurer de ne rien tracer :
	caroline.penup()
	# un pas à gauche de -40 
	#(on pourrait utiliser un paramètre plutôt que cette valeur fixe de -40) : 
	caroline.setheading(-90)
	caroline.forward(40)
	balle_attrapee()





def raz() :
	""" fonction de remise à zéro. """
	# on efface le message de la partie précédente :
	disque.reset()
	# la tortue disque n'est pas dessinée :
	disque.hideturtle()
	# la tortue disque se rend à la position d'affichage du message :
	aller_a_sans_tracer(disque, 140, 100)
	# caroline retourne à sa position de départ : 
	aller_a_sans_tracer(caroline, -120, -80) 
	caroline.setheading(90)
	


def initialise() :
	# la tortue disque n'est pas dessinée :
	disque.hideturtle()
	# la tortue disque se rend à la position d'affichage du message :
	aller_a_sans_tracer(disque, 140, 100)
	# la tortue preparation ne sera pas dessinée : 
	preparation.hideturtle()
	# la tortue preparation est rapide : 
	preparation.speed(0)
	# caroline est dessinée sous forme d'une tortue :
	caroline.shape('turtle')
	# dessin des axes :
	dessine_axes(-240, -120, 240, 120)
	# dessin de la grille de points : 
	dessine_grille(40, -240, -120, 240, 120)
	# les positions au départ du jeu  :
	depart()
 


initialise()






# on crée une variable de type Screen :
screen = turtle.Screen() 
# on associe la fonction pas_gauche à l'appui de la touche flèche gauche : 
screen.onkey(pas_gauche, 'Left')
screen.onkey(pas_droit, 'Right')
screen.onkey(pas_haut, 'Up')
screen.onkey(pas_bas, 'Down')
# on lance une écoute des événements : 
screen.listen()
 
turtle.exitonclick()

Exercice 4, Asie.

Traduire le script de Margot avec le module turtle de Python.
Modifier votre script Python de façon équivalente à la modification de Julie.

Orientation et fenêtre
Question 1
Question 2

En scratch, l'orientation par défaut est 0 vers le haut et 90 vers la droite.
Par défaut, pour la tortue, les références sont celles du prof de maths ! (0 vers la droite, 90 vers le haut).

On peut avoir l'orientation scratch pour la tortue avec turtle.mode('logo').

La fenêtre d'ouverture est par défaut en scratch de -240 à 240 en abscisses et de -180 à 180 en ordonnées.

On peut imposer cela avec la tortue avec le code turtle.setworldcoordinates(-240, -180, 240, 180).

Malheureusement, les deux codes ci-dessus sont incompatibles car l'usage de turtle.setworldcoordinates bascule la tortue dans un autre mode que le mode logo.

En fait, la fenêtre turtle est par défaut plus large que celle de scratch. On utilisera donc ici le choix turtle.mode('logo').

Pour disposer de l'équivalent d'un clic sur le drapeau (qui a ici pour effet une remise à zéro), on a associé la fonction initialisation à la touche 'r' du clavier.


import turtle



# limites  fenêtre like scratch  : 
xmin, ymin = -240, -180
xmax, ymax = 240, 180

# mode logo pour que les angles 0, 90, -90, 180
# soient les mêmes que dans le cartouche "pour information"
turtle.mode('logo')

# une tortue
caro = turtle.Turtle() 
caro.shape('turtle')



def initialisation():
	# efface le dessin précédent :
	caro.reset()
	# positionne le stylo à gauche (sans tracer)
	# stylo relevé
	caro.penup()
	caro.goto(xmin, 0)
	
	
def fleche_haut() :
	caro.setheading(0)
	caro.pendown()
	caro.forward(50)
	caro.penup()
	
def fleche_droite() :
	caro.setheading(90)
	caro.pendown()
	caro.forward(50)
	caro.penup()
	
	
def fleche_bas() :
	caro.setheading(180)
	caro.pendown()
	caro.forward(50)
	caro.penup()



initialisation()
 

# on crée une variable de type Screen :
screen = turtle.Screen()
# on associe les fonctions aux touches "flèche" : 
screen.onkey(fleche_droite, 'Right')
screen.onkey(fleche_haut, 'Up')
screen.onkey(fleche_bas, 'Down')
# on associe la fonction initialisation à la touche 'r' :
screen.onkey(initialisation, 'r')
# on lance une écoute des événements :
screen.listen()

turtle.mainloop()

On peut remarquer que les trois fonctions fleche sont très semblables. Il est possible de factoriser un peu le code comme suit :


import turtle



# limites  fenêtre like scratch  :
xmin, ymin = -240, -180
xmax, ymax = 240, 180

# mode logo pour que les angles 0, 90, -90, 180
# soient les mêmes que dans le cartouche "pour information"
turtle.mode('logo')

# une tortue
caro = turtle.Turtle()
caro.shape('turtle')



def initialisation():
	# efface le dessin précédent :
	caro.reset()
	# positionne le stylo à gauche (sans tracer)
	# stylo relevé
	caro.penup()
	caro.goto(xmin, 0)



def fleche(direction) :
	dirige = {'haut' : 0, 'droite' : 90, 'bas' : 180}
	caro.setheading(dirige[direction])
	caro.pendown()
	caro.forward(50)
	caro.penup()
	
 

initialisation()


# on crée une variable de type Screen :
screen = turtle.Screen()
# on associe les fonctions aux touches "flèche" :
screen.onkey(lambda : fleche('droite'), 'Right')
screen.onkey(lambda : fleche('haut'), 'Up')
screen.onkey(lambda : fleche('bas'), 'Down')
# on associe la fonction initialisation à la touche 'r' :
screen.onkey(initialisation, 'r')
# on lance une écoute des événements :
screen.listen()

turtle.mainloop()

Il n'y a que deux lignes à effacer.


import turtle
 

# limites  fenêtre like scratch  : 
xmin, ymin = -240, -180
xmax, ymax = 240, 180

# mode logo pour que les angles 0, 90, -90, 180
# soient les mêmes que dans le cartouche "pour information"
turtle.mode('logo')

# une tortue
caro = turtle.Turtle() 
caro.shape('turtle')



def initialisation():
	# efface le dessin précédent :
	caro.reset()
	# positionne le stylo à gauche (sans tracer)
	# stylo relevé
	caro.penup()
	caro.goto(xmin, 0)
	
	
def fleche_haut() :
	caro.setheading(0)
	caro.pendown()
	caro.forward(50)
	caro.penup()
	
def fleche_droite() :
	caro.setheading(90)
	caro.forward(50)
 
	
	
def fleche_bas() :
	caro.setheading(180)
	caro.pendown()
	caro.forward(50)
	caro.penup()



initialisation()
 

# on crée une variable de type Screen :
screen = turtle.Screen()
# on associe les fonctions aux touches "flèche" : 
screen.onkey(fleche_droite, 'Right')
screen.onkey(fleche_haut, 'Up')
screen.onkey(fleche_bas, 'Down')
# on associe la fonction initialisation à la touche 'r' :
screen.onkey(initialisation, 'r')
# on lance une écoute des événements :
screen.listen()

turtle.mainloop()