SPE TES

from random import*
def exemple():
chaine="maison"
print "chaîne = ", chaine
C=""
for i in [0,1,2,4,5]:
C=C+chaine[i]
chaine=C
print "chaîne = ",chaine

On obtient en activant exemple()

>>> exemple()
chaine = maison
chaine = maion
>>>

Avec replace on écrit:

from random import*
def situation():
chaine="maison"
print "chaine = ", chaine
chaine.replace("s","") # "s" est remplacé par la chaine vide
print "chaine = ",chaine

On obtient pareil:

>>> situation()
chaine = maison
chaine = maison
>>>

# Notion de tuple:

C'est comme une liste mais avec des parenthèses au lieu de crochets

et l'impossibilité, comme pour les chaines, d'en modifier le contenu.

Par exemple: ( 14,"a", 34, 56, "mai" )

# Pour transformer une chaine en un entier il y a la méthode qui consiste à utiliser int(chaîne)

Par exemple : int("100") est sensé nous donner l'entier 100

Mais il arrive parfois que cela soit refusé par Python avec un message du genre:

ValueError : invalid literal for int() with base 10:

Ce n'est donc pas fiable. Donc il nous faut autre chose.

LA METHODE EST:

Créer un entier dont le string est la chaine "100" de départ.

On fait balayer, à l'aide d'une boucle for, par la variable i les entiers de 0 à 10000 ,

voire plus, jusqu'à avoir str(i) qui soit "100".

Ainsi l'entier i trouvé sera 100.

La méthode fonctionne pour toute chaine de chiffres .

# Il peut nous arriver d'avoir une chaine M du style M = "100G30" .

Nous souhaitons avoir un entier dont le sring est la partie de la chaine avant le G

et un entier dont le sring est la partie de la chaine après le G.

On détermine d'abord l'indice i de la lettre G avec M.index("G")

Le morceau de chaine avant le G est M[ :i]

Donc M[ : i] = "100"

Le morceau de chaine après le G est M[ i+1 :]

Donc M[ i +1 : ] = "30"

On a aussi : G[i] = "G"

La méthode exposée plus haut permet alors d'obtenir deux entiers dont les

strings sont de part et d'autre de G

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

EXERCICE 1

"Archie", qui est encore très jeune, ne sait pas ce que donne le script,

en Python 2.7, suivant .

Pouvez-vous l'aider ?

from turtle import*
from random import*
def tour():
speed("fast")
width(2)
# Les Tours
vit()
transfert(220,0)
vit()
transfert(100,-90)
  # La Facade centrale
for k in [10,15,130,135]:
rect(120,k)
  transfert(98,-90)
  tri(120)
forward(10)
tri(100)
forward(50)
  # La Rosace
circle(28)
fill=color("purple")
penup()
left(90)
forward(7)
right(90)
pendown()
circle(20)
for k in range(10,19):
fill=color("yellow")
circle(k)
fill=color("purple")
   # Complément du motif de la tour
transfert(5,3)
rect(85,3)
transfert(225,3)
rect(85,3)
   # Les Portes latérales
transfert(27,-150)
rect(45,60)
forward(10)
rect(25,60)
  transfert(250,-150)
  rect(45,60)
forward(10)
rect(25,60)
transfert(120,-150)
# La Porte Principale
rect(80,60)
forward(10)
rect(60,60)
left(20)
forward(33)
right(40)
forward(33)
# Le Toit des tours
transfert(5,-10)
right(-20)
rect(90,105)
transfert(225,-10)
rect(90,105)
clocher()
def clocher():
transfert(137,-22)
fill=color("blue")
left(83)
forward(180)
right(166)
forward(179)
transfert(0,0)
def transfert(x,y):
penup()
goto(x,y)
pendown()
def vit():
color("red")
for k in [230,120,220,10,215,115,5]:
rect(100,k)
   forward(25)
right(90)
depl(25)
left(90)
for i in range(3,18,4):
pendown()
color("blue")
rect(i,75)
depl(35)
for i in range(3,18,4):
pendown()
color("blue")
rect(i,75)
color("black")
penup()
def depl(s):
penup()
forward(s)
pendown()
def tri(a):
for i in range(3):
forward(a)
left(120)
def rect(p,v):
for i in range(2):
forward(p)
right(90)
forward(v)
right(90)
penup

Pour obtenir la réponse

activer tour()

Vous aurez un aperçu d'un édifice.

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

EXERCICE 2

Donner un script, en Python 2.7, qui donne un entier dont les chiffres dans l'ordre

sont ceux de la chaine "100".

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

REPONSE:

On peut proposer :

from random import*

def rendentier():
chaine=raw_input("Donner une chaîne de chiffres comme 100 ")
for i in range(100000):
if str(i)==chaine:
print " On obtient " , i

Cela donne en activant rendentier()

>>> rendentier()
Donner une chaîne de chiffres comme 100 100
On obtient 100
>>>

Ici chaine est un string car sais par raw_input( )

Le résultat final est lui un entier dont le str est la chaine

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

EXERCICE 3

Donner un script, en Python 2.7 , qui quand on saisit une chaine,

par exemple comme "100G30" , déplace dans l'écran de

Turtle, la souris avec le même effet que

goto(100,30 ) mais sans trace.

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

REPONSE:

On peut proposer le script suivant:

from turtle import*
from random import*
def deplace():
instr=raw_input("Donner une instruction comme 100G50 ")
m=instr.index("G")
if "G" in instr:
m=instr.index("G")
deb=instr[:m]
fin=instr[m+1:]
# Nous voulons des entiers , pas des str
# Il arrive que int(deb) et int(fin) ne
# soient pas acceptés par Python
for i in range(1000):
if str(i) == deb:
x= i
if str(i)==fin:
y=i
print x
print y

penup()
goto(x,y)
pendown

Cela donne quand on active deplace()

>>> deplace()
Donner une 'instruction comme 100G50 100G50
100
50
>>>

La souris s'est déplacée de 50 sans rien marquer à l'écran

entre ses deux positins. Il y a juste le v couché qui indique le sens

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

EXERCICE 4

Donner un script, en Python 2.7 ,qui quand on saisit les instructions,

par exemple, N F100 120G20 R90 F100 , dessine, automatiquement

dans l"écran de Turtle le tracé correspondant.

Rappel: 120G20 provoque le déplacement de la souris comme goto( 120 , 20 )

le fait mais sans trace.

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

REPONSE:

On peut considérer :

from turtle import*
from random import*

def instruction():
x=0
y=0
   D=raw_input("instruction de la forme N F20 30G15 : ")
W=D.split(" ")
    for elem in W:
if len(elem)==1:
print elem
trajet(elem,0,x,y)
   elif "G" in elem:
i=elem.index("G")
deb=elem[:i]
fin=elem[i+1:]
for j in range(1000):
   if str(j) == deb:
x=j
   if str(j)==fin:
y=j
print elem
a=elem[i]
trajet(a,0,x,y)
else:
fin=elem[1:]
    for j in range(1000):
  if str(j)==fin:
m=j
    print elem[0],m
width(3)
pencolor("red")
trajet(elem[0],m,x,y)

def trajet(a,m,x,y):
   if a=="F":
forward(m)
elif a=="G":
penup()
  goto(x,y)
pendown()
  elif a=="R":
right(m)
  elif a=="L":
left(m)
elif a=="B":
backward(m)
  elif a=="U":
penup()
  elif a=="D":
pendown
   elif a=="N":
reset()
  else:
   print " Cela ne veut rien dire"
input()

On obtient en activant instruction()

>>> instruction()
instruction de la forme N F20 30G15 : N F20 30G15 F40 R90 70G-40 F30
N
F 20
30G15
F 40
R 90
70G-40
F 30
>>>

On a dans la fenêtre :

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

EXERCICE 5:

Reprendre l'objectif de l'exercice précédent en permettant de choisir aussi

directement une épaisseur, une couleur et un cercle, en écrivant simplement,

E3 ( pour width(3) ). O5 ( pour un cercle de rayon 5) , C4 ( pour la couleur 4 ).

On conviendra pour cet exercice que:

1 est pour " red" , 2 pour "blue" , 3 pour "yellow", 4 pour "green",

5 pour orange" , 6 pour "brown" , 7 pour purple, 8 pour black.

REPONSE:

On peut proposer :

On repennd le même programme

from turtle import*
from random import*

def couleur(m):

speed(10) # pour la vitesse de tracé la plus rapide
if m==1:
pencolor("red")
   elif m==2:
pencolor("blue")
elif m==3:
pencolor("yellow")
   elif m==4:
pencolor("green")
elif m==5:
pencolor("orange")
elif m==6:
pencolor("brown")
   elif m==7:
pencolor("purple")

elif m==8:

pencolor("black")
else:
print "Mauvaise couleur"
input()

def instruction():
x=0
y=0
   D=raw_input("Donner une instruction de la forme N W3 C1 F20 3G15 : ")
W=D.split(" ")
    for elem in W:
if len(elem)==1:
print elem
trajet(elem,0,x,y)
   elif "G" in elem:
i=elem.index("G")
deb=elem[:i]
fin=elem[i+1:]
for j in range(1000):   # Ne pas prendre plus pour ne pas être out of range
   if str(j) == deb:
x=j
   if str(j)==fin:
y=j
print elem
a=elem[i]
trajet(a,0,x,y)
else:
fin=elem[1:]
    for j in range(1000): # Ne pas prendre plus pour ne pas être out of range
  if str(j)==fin:
m=j
    print elem[0],m
width(3)
pencolor("red")
trajet(elem[0],m,x,y)

def trajet(a,m,x,y):
if a=="F":
forward(m)

   elif a=="C":
couleur(m)
elif a=="E":
width(m)
elif a=="O":
circle(m)
elif a=="G":
penup()
  goto(x,y)
pendown()
elif a=="R":
  right(m)
elif a=="L":
left(m)
elif a=="B":
backward(m)
elif a=="U":
penup()
elif a=="D":
pendown
   elif a=="N":
reset()
else:
   print " Cela ne veut rien dire"
  input()

On obtient en activant instruction()

>>> instruction()
Donner une instruction de la forme N W3 C1 F20 3G15 : N E3 C4 F50 C2 O30 C4 F100 C2 O30 C4 F100
N
E 3
C 4
F 50
C 2
O 30
C 4
F 100
C 2
O 30
C 4
F 100
>>>

Cela donne à l'écran:

Autre exemple:

>>> instruction()
Donner une instruction de la forme N W3 C1 F20 3G15 : N E3 C4 F60 C2 O30 C4 F100 C2 O30 C4 F100 C1 200G30

F30 L90 F40 L90 F225 L90 F40 L90 F15 60G70 L45 F30 100G30 R45 F20
N
E 3
C 4
F 60
C 2
O 30
C 4
F 100
C 2
O 30
C 4
F 100
C 1
200G30
F 30
L 90
F 40
L 90
F 225
L 90
F 40
L 90
F 15
60G70
L 45
F 30
100G30
R 45
F 20

>>>

On obtient la VroumVroum suivante

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

Mentions légales Gestion des cookies