SPE TES

from turtle import*
from random import*
def ovale(r):
speed(10),width(5)
left(45) # pour avoir l'ovale vertical au lieu d'horizontal
for i in range(2): # Pour renouveler deux fois
color("red") # premier arc en rouge à droite de rayon r
circle(r,90)
color("green") # second arc en vert en haut de rayon r/2
circle(r/2,90)
mainloop()

En activant ovale(150) on a :

>>>
>>> ovale(150)
>>>

puis:

La construction commence par l'arc rouge à droite puis par l'arc vert en haut

en tournant dans le sens trigo.

Le début de l'arc rouge est à l'origine mais le point le plus bas n'est pas l'origine..

Le tracé est très très proche de celui d'une elipse. La différence est imperceptible.

Dans la figure ci-dessous on voit en bleu une ellipse collée à l'ovale.

# Ellipse:

Une ellipse d'axes, les axes de coordonnées, de longueurs 2a et 2b

s'obtient en considérant les points de coordonnées:

( a cos(i) , b sin(i) ) avec i qui varie entre 0 et 2π radians.

Pour l'obtenir avec turtle on peut considérer:

from turtle import*
from random import*
from math import*
def deplace(x,y):
penup(),goto(x,y),pendown()
def ellipse(a,b): # a > 0 et b > 0 toujours
speed(0),width(3)
deplace(a,0)   #   ( a ,0 ) et (- a,0 ) sont les coord des points de l'ellipse sur l'axe des abscisses
ht() #   (0 , b ) et (0 , - b ) sont les coord des points de l'ellipse sur l'axe des ordonnées
color("blue")
i=0
while i<6.3: # 2π radians est environ 6,28 On a pris 6,3
x=a*cos(i)
y=b*sin(i)
goto(x,y)
i=i+0.1
mainloop()

En activant ellipse(60,120) il vient :

>>>
>>> ellipse(60,160)
>>>

Puis:

On peut comparer sur un exemple un ovale et une ellipse en considérant:

from turtle import*
from random import*
from math import*
def deplace(x,y):
penup(),goto(x,y),pendown()
def ellipse(a,b):
speed(0),width(5)
deplace(39,b-16)
ht()
i=0
while i<6.3:
x=-53+a*cos(i)
y=106+b*sin(i)
goto(x,y)
i=i+0.1
def ovale(r):
speed(10),width(5)
left(45)
for i in range(2):
color("red")
circle(r,90)
color("green")
circle(r/2,90)
def commande():
ovale(150)
color("blue")
fillcolor("white")
begin_fill()
ellipse(92,123)
end_fill()
mainloop()

En activant commande() il vient:

>>>
>>> commande()
>>>

Puis on retrouve la figure:

# ROTATION:

Soit le point M(x,y) dans le plan muni d'un repère orthonormé d'origine O.

Soit le point M ' ( x' ,y' ) son image par la rotation de centre O et d'angle θ.

On a :

x '= x cos(θ) - y sin(θ)

y ' = x cos( θ) + y sin(θ)

Dans le cas où θ = 45° on a: cos(θ) = sin(θ) = 0,5 √2

On utilise la rotation R( O , 45° ).

Il vient alors :

x'= 0,5 √2 ( x - y)

y'= 0,5 √2 ( x + y)

Si le point M(x,y) décrit une ellipse ( E ) alors le point M '( x' ,y ' ) va décrire

l'ellipse image ( E' ) par la rotation R.

Le point de coord ( a , 0 ) a pour image alors le point de coord ( 0,5 √2 , 0,5 √2 )

On peut donc ainsi obtenir le tracé de ( E' ) à partir de celui de ( E ).

---------------------------------------------------------------------------------------------------------------------------

EXERCICE 0:

1. Donner un script, en Python 2.7, qui permet d'obtenir une ellipse sans avoir à effacer le

tiret ( sorte de cordon ombilicale ) entre l'origine et le premier point de départ

de la construction de l'ellipse .

( En effet, dans le précédent script, pour masquer l'effet du premier goto(x,y) de la boucle while,

la couleur blanche de fond pour l'intérieur de l'ellipse a été nécessaire. Ce qui est gênant. )

2. Modifier, alors ce script pour avoir un bracelet d'ellipses identiques horizontales.

-------------------------------------------------------------------------------------------------------------------

REPONSE:

1. On peut considérer:

from turtle import*
from random import*
from math import*
def deplace(x,y):
penup(),goto(x,y),pendown()
def ellipse(d,a,b):
ht(),speed(0),width(3),color("blue")
x=d+a # ces trois lignes placent la souris déjà sur l'ellipse désirée
y=0 # Cela neutralise le premier got(o(x,y) de la boucle while.
deplace(x,y)
i=0
while i<6.3 :
x= d+a*cos(i) # Ce d permet de déplacer l'ellipse horizontalement
y=b*sin(i)
goto(x,y)
i=i+0.1
def commande():
ellipse(100,20,50) # Elle est verticale de centre, à 100 de l'origine O sur l'axe des abscisses
mainloop()
On obtient en activant commande()

>>>
>>> commande()
>>>

Puis :

2. Pour avoir le bracelet il suffit seulement de remplacer le def commande()

par:

def commande():
for i in range(10):
ellipse(12*i,20,50) # De 12 en 12 on deplace l'éllipse pour former un bracelet

mainloop() # de 10 ellipses identiques

En activant commande() on a :

>>>
>>> commande()
>>>

Puis :

En modifiant le script on peut faire varier la couleur des ellipses:

from turtle import*
from random import*
from math import*
def deplace(x,y):
penup(),goto(x,y),pendown()
def ellipse(d,a,b,couleur): # On introduit un paramètre couleur pour l'ellipse
ht(),speed(0),width(3),color(couleur)
x=d+a
y=0
deplace(x,y)
i=0
while i<6.3:
x=d+a*cos(i)
y=b*sin(i)
goto(x,y)
i=i+0.1
def commande(): # Les modifications suivantes
E=["black","green","blue","grey","red","yellow","violet","orange","brown"]
  for i in range(9):
ellipse(12*i,20,50,E[i])
mainloop()

En activant commande() il vient :

>>>
>>> commande()
>>>

Puis

-------------------------------------------------------------------------------------------------------------------------

EXERCICE 1:

Donner un script, en Python 2.7, qui fait tomber la pointe d'une tour.

-------------------------------------------------------------------------------------------------------------------------

On peut proposer:

from turtle import*
from random import*
from math import*
def deplace(x,y):
penup()
goto(x,y)
pendown()
def triangleiso(c,h):
l=round(c/2,2)
u=round(h**2,2)
v=round(l**2)
p=u+v
m=round(p**0.5,2)
k=round(h/l,2)
q=round(atan(k),2)
j =degrees(q)
left(j)
forward(m)
right(2*j)
forward(m)
right(180-j)
forward(c)
right(180)
def rect(a,b):
for i in range(2):
forward(a)
right(90)
forward(b)
right(90)
def pointe():
speed(10)
reset()
width(1)
ht()
fillcolor("yellow")
begin_fill()
rect(100,200) # fabrication de la tour
end_fill()
rect(100,10)
rect(100,15)
width(3)
E=["green","orange","red","brown"] # Les couleurs successives de la pointe
for i in range(4):
left(10*i)
color("white") # Pour éviter d'avoir à effacer les bords on les
fillcolor(E[i])    #  met en couleur du fond blanc
begin_fill()
triangleiso(100,300)
end_fill()
color("white")
fillcolor("white") # On n'a plus que l'intérieur de la pointe à
begin_fill() # effacer en le mettant en couleur de fond
triangleiso(100,300)
end_fill()

color("white")
fillcolor("red")
begin_fill()
triangleiso(100,300)
end_fill()
deplace(-100,20)
width(4)
color("white")
fillcolor("white")
begin_fill()
triangleiso(100,300)
end_fill()
left(30)
deplace(-150,-40)
color("white")
fillcolor("orange")
begin_fill()
triangleiso(80,150)
end_fill()
color("white")
fillcolor("white")
begin_fill()
triangleiso(80,150)
end_fill()
left(30)
deplace(-150,-100)
color("white")
fillcolor("brown")
begin_fill()
triangleiso(80,150)
end_fill()
mainloop()

En activant pointe() on obtient :

>>>
>>> pointe()
>>>

Puis on a à la fin:

Au début on a la pointe, au dessus de la tour, verte.

La pointe change de couleur en tombant sur la gauche

---------------------------------------------------------------------------------------------------------------------------------------------------------------------

EXERCICE 2

Donner un script, en Python 2.7 qui anime un Monsieur Fil de Fer.

----------------------------------------------------------------------------

REPONSE:

On peut proposer:

from turtle import*
from random import*
from math import*
def deplace(x,y):
penup()
goto(x,y)
pendown()
def sol():
ht()
speed(0),width(6),color("brown")
deplace( 200,-103)
backward(340)
deplace(0,0)

def jambesbras():
speed(0),ht(),width(3)
deplace(-15,70)
color("black")
circle(13)
    for i in range(5):
color("black")
deplace(-20,-8) #jambe noire
right(120),forward(60)
right(40), forward(40)
left(10)

deplace(-10,-8) # jambe noire
left(110),forward(60)
right(30),forward(40)
left(80)

deplace(-30,50) # bras noir
right(130)
forward(30)
left(60)
forward(15)
left(70)

deplace(0,50) # bras noir
right(40)
forward(30)
left(50)
forward(15)
right(90)

width(7)
color("white")
deplace(-20,-10)
right(51),forward(60) # Pour effacer jambe
right(42), forward(40)

deplace(-10,-9)
left(124),forward(60) # Pour effacer jambe
right(33),forward(40)

deplace(-30,50)
right(45)
forward(30)
left(50)
forward(15)

deplace(0,50)
left(40)
forward(30)
left(50)
forward(15)
width(3)
right(17)

color("black")
deplace(-20,-8) #jambe noire à la fin
right(120),forward(60)
right(40), forward(40)
left(10)

deplace(-10,-8) # jambe noire à la fin
left(110),forward(60)
right(30),forward(40)
left(80)

deplace(-30,50) # bras noir à la fin
right(130)
forward(30)
left(60)
forward(15)
left(70)

deplace(0,50)   # bras noir à la fin
right(40)
forward(30)
left(50)
forward(15)
right(90)

def commande():
ht(),speed(0),reset()
sol()
jambesbras()
mainloop()

En activant commande() il vient:

>>>
>>> commande()
>>>

Puis:

Le sol et la tête restent. les jambes et les bras semblent bouger.

-------------------------------------------------------------------------------------------------------------------------

EXERCICE 3:

Donner un script, en Pyton 2.7, qui donne une paire d'yeux ovales.

---------------------------------------------------------------------------------------------------

REPONSE:

On peut proposer:

from turtle import*
from random import*
from math import*
def deplace(x,y):
penup(),goto(x,y),pendown()
def vue(c,d):
ht() ,  speed(0),width(3)
i=0
fillcolor("yellow")
begin_fill()
while i<6.3: # Création de l'ellipse pleine jaune
color("yellow")
   x=c+40*cos(i)
y=d+60*sin(i)
goto(x,y)
i=i+0.1
end_fill()
ht()
backward(20)
fillcolor("green")   # Pupille verte
begin_fill()
left(90)
circle(20)
end_fill()
right(90)
width(5)

color("yellow") # Ajustement précis pour que les bords ne soient pas entaillés.
forward(24)
color("white")
forward(26)
width(3)

def trace():
speed(0)
vue(0,0)
vue(100,0)
mainloop()

En activant trace() il vient :

>>>
>>> trace()
>>>

Puis:

Pour éviter les ajustements liés au traces des déplacements on peut aussi proposer:

from turtle import*
from random import*
from math import*
def deplace(x,y):
penup(),goto(x,y),pendown()
def ellipse(d,a,b):
ht(),speed(0),width(3),color("yellow")
x=d+a
y=0
deplace(x,y)
i=0
while i<6.3 :
x=d+a*cos(i)
y=b*sin(i)
goto(x,y)
i=i+0.1
def mire():
for i in range(2):
color("white")
fillcolor("yellow")
begin_fill()
ellipse(60*i,20,50)
end_fill()
left(90*(1-i))
color("green")
fillcolor("green")
begin_fill()
deplace(10+i*60,0)
circle(10)
end_fill()
mainloop()

En activant mire() on a :

>>>
>>> mire()
>>>

Puis on a :

-------------------------------------------------------------------------------------------------------------------

EXERCICE 4:

Donner un script , en Python 2.7 , qui plante un clou.

-----------------------------------------------------------------------------------

REPONSE:

On peut proposer simplement avec quatre positions du marteau:

( Horizontal , En haut , Oblique , En bas)

from turtle import*
from random import*
def deplace(x,y):
penup(),goto(x,y),pendown()
def rect(a,b,couleur):
speed(0),width(2),color(couleur)
for i in range(2):
forward(a),left(90),forward(b),left(90)
def sol():
width(4),speed(0)
deplace(-50,0)
color("brown"),forward(250)
def clou():
ht(),speed(0),width(3)
deplace(50,22)
rect(20,5,"black")
forward(13) ,  right(180)
rect(5,20,"black")

def marteau_horizontal():
width(4), color("black")
deplace(129,43)
forward(60), left(90),forward(15),right(180)
fillcolor("black")
begin_fill()
rect(30,20,"black")
end_fill()
deplace(129,43),left(90)
def supprime_marteau_horizontal(): # En fait on repasse en couleur blanche du fond
width(4),color("white"), forward(60),left(90)
forward(15),right(180),color("white")
fillcolor("green")
begin_fill()
rect(30,20,"white")
end_fill()
deplace(129,43), left(90)

def marteau_en_haut():
width(4),color("black"),right(40),forward(60),left(90)
forward(15),right(180)
fillcolor("black")
begin_fill()
rect(30,20,"black")
end_fill()
deplace(129,43),left(90)
def supprime_marteau_en_haut():
width(5),color("white"),forward(60),left(90)
forward(15),right(180)
fillcolor("white")
begin_fill()
rect(30,20,"white")
end_fill()
deplace(129,43),right(40)

def retour_marteau_oblique():
width(4),color("black"),left(150)
   deplace(129,43)
forward(60),left(90),forward(15)
right(180)
fillcolor("black")
begin_fill()
rect(30,20,"black")
end_fill()
deplace(129,43)
left(90)
def supprime_marteau_oblique():
width(4),color("white")
deplace(129,43)
forward(60),left(90),forward(15),right(180)
fillcolor("white")
begin_fill()
rect(30,20,"white")
end_fill()
deplace(129,43),left(90)

def marteau_enfonce_clou():
width(4),color("black"),left(40)
deplace(129,43)
forward(60),left(90),forward(15),right(180)
fillcolor("black")
begin_fill()
rect(30,20,"black")
end_fill()
deplace(129,43),left(90)
color("blue")
write(" Hé Bé !")

def mis():
speed(0)
setup(),sol(),clou()
marteau_horizontal(),supprime_marteau_horizontal() # tracé puis effacement
marteau_en_haut(),supprime_marteau_en_haut() # tracé puis effacement
retour_marteau_oblique(),supprime_marteau_oblique() # tracé puis effacement
marteau_enfonce_clou() # Tracé final
mainloop()

En activant mis() on a :

>>>
>>> mis()
>>>

Puis à la fin :

-----------------------------------------------------------------------------------------------------------------------------------------

EXERCICE 5:

Donner un script qui permet d'avoir une fleur formée de quatre ellipses blanches de bords noirs et

d'un disque central jaune.

---------------------------------------------------------------------------------------------------------------------------------------------------

REPONSE:

On peut proposer:

from turtle import*
from random import*
from math import*
def deplace(x,y):
penup(),goto(x,y),pendown()
def ellipse(a,b):
ht(),speed(0),width(3)
x=a
y=0
deplace(x,y)
i=0
while i<6.3 :
x=a*cos(i)
y=b*sin(i)
goto(x,y)
i=i+0.1 # La première ellipse est tracée
x=a*0.5*2**0.5 # Pour placer la souris au point correspondant à i = 0 de l'ellipse image
y=a*0.5*2**0.5 # Cela évite le tiret créé par goto(x,y) entre O et ce point.
deplace(x,y)
i=0
while i<6.3 :
x=(0.5*2**0.5)*(a*cos(i)-b*sin(i))
y=(0.5*2**0.5)*(a*cos(i)+b*sin(i))
goto(x,y)
i=i+0.1
def commande():
color("black")
ellipse(120,240)
ellipse(240,120) # Permuter a et b permet d'envisager l'ellipse horizontale et son image
fillcolor("yellow")
begin_fill()
deplace(120,0)
left(90)
circle(120)
end_fill()
mainloop()
En activant commande() on a :

>>>
>>> commande()
>>

Puis :

----------------------------------------------------------------------------------------------------------------------------------------------------------------------

EXERCICE 6:

Donner un script, en Python 2.7, qui crée une couronne de huit cercles de couleurs variées

avec un disque jaune bordé de noir au centre.

-----------------------------------------------------------------------------------------------------------------------------------

REPONSE:

On peut proposer:

from turtle import*
from random import*
from math import*
def deplace(x,y):
penup(),goto(x,y),pendown()
def cercle(r,a,b,couleur):
ht()
width(4)
deplace(a,b)
color(couleur)
circle(r)
def commande():
speed(0)
m=3.14116/4 # cela correspond à 45°
E=["green","blue","grey","red","yellow","violet","orange","brown"]
a=10
b=15
for i in range(8):
x=a+140*cos(i*m) # les points de départ des constructions des huit cercles
y=b+140*sin(i*m) # sont sur le cercle de centre de coord( a,b ) et de rayon 140
cercle(60,x,y,E[i]) # décalés de 45° dans le sens trigo
color("black")
deplace(10,-3)
fillcolor("yellow")
begin_fill()
circle(78)
end_fill()
mainloop()

En activant commande() il vient:

>>>
>>> commande()
>>

Puis:

------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

Mentions légales Gestion des cookies