|
</li>
</ol>
</ol>
{{fin}}
== Un peu de détente avec le module turtle ==
Comme nous venons de le voir, l'une des grandes qualités de Python est qu'il est extrêmement facile de lui ajouter de nombreuses fonctionnalités par importation de divers ''modules''.
Pour illustrer cela, et nous amuser un peu avec d'autres objets que des nombres, nous allons explorer un module Python qui permet de réaliser des « graphiques tortue », c'est-à-dire des dessins géométriques correspondant à la piste laissée derrière elle par une petite « tortue » virtuelle, dont nous contrôlons les déplacements sur l'écran de l'ordinateur à l'aide d'instructions simples.
Activer cette tortue est un vrai jeu d'enfant. Plutôt que de vous donner de longues explications, nous vous invitons à essayer tout de suite :
<pre>
>>> from turtle import *
>>> forward(120)
>>> left(90)
>>> color('red')
>>> forward(80)
</pre>
L'exercice est évidemment plus riche si l'on utilise des boucles :
<pre>
>>> reset()
>>> a = 0
>>> while a <12:
a = a +1
forward(150)
left(150)
</pre>
[[Image:Apprendre à programmer avec Python 8.png|center]]
Attention cependant : avant de lancer un tel script, assurez-vous toujours qu'il ne comporte pas de boucle sans fin, car si c'est le cas vous risquez de ne plus pouvoir reprendre le contrôle des opérations (en particulier sous ''Windows'').
Amusez-vous à écrire des scripts qui réalisent des dessins suivant un modèle imposé à l'avance. Les principales fonctions mises à votre disposition dans le module ''turtle'' sont les suivantes :
{| style="width:100%"
|-
|<code>reset()</code> || On efface tout et on recommence
|-
|<code>goto(x, y)</code> || Aller à l'endroit de coordonnées x, y
|-
|<code>forward(distance)</code> || Avancer d'une distance donnée
|-
|<code>backward(distance)</code> || Reculer
|-
|<code>up()</code> || Relever le crayon (pour pouvoir avancer sans dessiner)
|-
|<code>down()</code> || Abaisser le crayon(pour recommencer à dessiner)
|-
|<code>color(couleur)</code> || <couleur> peut être une chaîne prédéfinie ('red', 'blue', 'green', etc.)
|-
|<code>left(angle)</code> || Tourner à gauche d'un angle donné (exprimé en degrés)
|-
|<code>right(angle)</code> || Tourner à droite
|-
|<code>width(épaisseur)</code> || Choisir l'épaisseur du tracé
|-
|<code>fill(1)</code> || Remplir un contour fermé à l'aide de la couleur sélectionnée
|-
|<code>write(texte)</code> || <texte> doit être une chaîne de caractères délimitée avec des " ou des '
|}
== Véracité/fausseté d'une expression ==
Lorsqu'un programme contient des instructions telles que <tt>while</tt> ou <tt>if</tt>, l'ordinateur qui exécute ce programme doit évaluer la véracité d'une condition, c'est-à-dire déterminer si une expression est vraie ou fausse. Par exemple, une boucle initiée par <code>while c<20</code>: s'exécutera aussi longtemps que la condition <code>c<20</code> restera vraie.
Mais comment un ordinateur peut-il déterminer si quelque chose est vrai ou faux ?
En fait - et vous le savez déjà - un ordinateur ne manipule strictement que des nombres. Tout ce qu'un ordinateur doit traiter doit d'abord toujours être converti en valeur numérique. Cela s'applique aussi à la notion de vrai/faux. En Python, tout comme en C, en Basic et en de nombreux autres langages de programmation, on considère que toute valeur numérique autre que zéro est « vraie ». Seule la valeur zéro est « fausse ». Exemple :
<pre>
a = input('Entrez une valeur quelconque')
if a:
print "vrai"
else:
print "faux"
</pre>
Le petit script ci-dessus n'affiche « faux » que si vous entrez la valeur 0. Pour toute autre valeur numérique, vous obtiendrez « vrai ».
Si vous entrez une chaîne de caractères ou une liste, vous obtiendrez encore « vrai ». Seules les chaînes ou les listes ''vides'' seront considérées comme « fausses ».
Tout ce qui précède signifie donc qu'une expression à évaluer, telle par exemple la condition a > 5 , est d'abord convertie par l'ordinateur en une valeur numérique. (Généralement 1 si l'expression est vraie, et zéro si l'expression est fausse). Exemple :
<pre>
a = input('entrez une valeur numérique : ')
b = (a < 5)
print 'la valeur de b est', b, ':'
if b:
print "la condition b est vraie"
else:
print "la condition b est fausse"
</pre>
Le script ci-dessus vous renvoie une valeur <code>b = 1</code> (condition vraie) si vous avez entré un nombre plus petit que 5.
Ces explications ne sont qu'une première information à propos d'un système de représentation des opérations logiques que l'on appelle ''algèbre de Boole''. Vous apprendrez plus loin que l'on peut appliquer aux nombres binaires des opérateurs tels que and, or, not, etc. qui permettent d'effectuer à l'aide de ces nombres des traitements logiques complexes.
== Révision ==
Dans ce qui suit, nous n'allons pas apprendre de nouveaux concepts mais simplement utiliser tout ce que nous connaissons déjà pour réaliser de vrais petits programmes.
=== Contrôle du flux - Utilisation d'une liste simple ===
Commençons par un petit retour sur les branchements conditionnels (il s'agit peut-être là du groupe d'instructions le plus important dans n'importe quel langage !) :
<source lang=python>
# Utilisation d'une liste et de branchements conditionnels
print ("Ce script recherche le plus grand de trois nombres")
print ('Veuillez entrer trois nombres séparés par des virgules : ')
# Note : la fonction list() convertit en liste la séquence de données qu'on
# lui fournit en argument. L'instruction ci-dessous convertira donc les
# données fournies par l'utilisateur en une liste nn :
nn = list(input())
max, index = nn[0], 'premier'
if nn[1] > max: # ne pas omettre le double point !
max = nn[1]
index = 'second'
if nn[2] > max:
max = nn[2]
index = 'troisième'
print ("Le plus grand de ces nombres est", max)
print ("Ce nombre est le", index, "de votre liste.")
</source>
{{remarque|Dans cet exercice, vous retrouvez à nouveau le concept de « bloc d'instructions », déjà abondamment commenté aux chapitres 3 et 4, et que vous devez absolument assimiler. Pour rappel, les blocs d'instructions sont délimités par l'indentation. Après la première instruction if, par exemple, il y a deux lignes indentées définissant un bloc d'instructions. Ces instructions ne seront exécutées que si la condition nn[1] > max est vraie.<br />
La ligne suivante, par contre (celle qui contient la deuxième instruction if) n'est pas indentée. Cette ligne se situe donc au même niveau que celles qui définissent le corps principal du programme. L'instruction contenue dans cette ligne est donc toujours exécutée, alors que les deux suivantes (qui constituent encore un autre bloc) ne sont exécutées que si la condition nn[2] > max est vraie.<br />
En suivant la même logique, on voit que les instructions des deux dernières lignes font partie du bloc principal et sont donc toujours exécutées.
}}
=== Boucle while - Instructions imbriquées ===
Continuons dans cette voie en imbriquant d'autres structures :
<source lang=python>
# Instructions composées <while> - <if> - <elif> - <else> # 1
print 'Choisissez un nombre de 1 à 3 (ou zéro pour terminer) ', # 3
a = input() # 4
while a != 0: # l'opérateur != signifie "différent de" # 5
if a == 1: # 6
print "Vous avez choisi un :" # 7
print "le premier, l'unique, l'unité ..." # 8
elif a == 2: # 9
print "Vous préférez le deux :" # 10
print "la paire, le couple, le duo ..." # 11
elif a == 3: # 12
print "Vous optez pour le plus grand des trois :" # 13
print "le trio, la trinité, le triplet ..." # 14
else : # 15
print "Un nombre entre UN et TROIS, s.v.p." # 16
print 'Choisissez un nombre de 1 à 3 (ou zéro pour terminer) ', # 17
a = input() # 18
print "Vous avez entré zéro :" # 19
print "L'exercice est donc terminé." # 20
</source>
Nous retrouvons ici une boucle <tt>while</tt>, associée à un groupe d'instructions <tt>if</tt>, <tt>elif</tt> et <tt>else</tt>. Notez bien cette fois encore comment la structure logique du programme est créée à l'aide des indentations (... et n'oubliez pas le caractère « : » à la fin de chaque ligne d'en-tête !)
L'instruction <tt>while</tt> est utilisée ici pour relancer le questionnement après chaque réponse de l'utilisateur (du moins jusqu'à ce que celui-ci décide de « quitter » en entrant une valeur nulle : rappelons à ce sujet que l'opérateur de comparaison != signifie « est différent de »). Dans le corps de la boucle, nous trouvons le groupe d'instructions <tt>if</tt>, <tt>elif</tt> et <tt>else</tt> (de la ligne 6 à la ligne 16), qui aiguille le flux du programme vers les différentes réponses, ensuite une instruction <tt>print</tt> et une instruction <tt>input()</tt> (lignes 17 & 18) qui seront exécutées dans tous les cas de figure : notez bien leur niveau d'indentation, qui est le même que celui du bloc <tt>if</tt>, <tt>elif</tt> et <tt>else</tt>, Après ces instructions, le programme boucle et l'exécution reprend à l'instruction <tt>while</tt> (ligne 5). Les deux dernières instructions print (lignes 19 & 20) ne sont exécutées qu'à la sortie de la boucle.
{{Exercices}}
<ol>
<li>Que fait le programme ci-dessous, dans les quatre cas où l'on aurait défini au préalable que la variable a vaut 1, 2, 3 ou 15 ?
<pre>
if a !=2:
print 'perdu'
elif a ==3:
print 'un instant, s.v.p.'
else :
print 'gagné'
</pre></li>
<li>Que font ces programmes ?
<pre>
a = 5
b = 2
if (a==5) & (b<2):
print '"&" signifie "et"; on peut aussi utiliser le mot "and"'
</pre>
<pre>
a, b = 2, 4
if (a==4) or (b!=4):
print 'gagné'
elif (a==4) or (b==4):
print 'presque gagné'
</pre>
<pre>
a = 1
if not a:
print 'gagné'
elif a:
print 'perdu'
</pre></li>
<li>Reprendre le programme c) avec a = 0 au lieu de a = 1. Que se passe-t-il ? Conclure !</li>
<li>Écrire un programme qui, étant données deux bornes entières a et b, additionne les nombres multiples de 3 et de 5 compris entre ces bornes.<br />
Prendre par exemple a = 0, b = 32 ® le résultat devrait être alors 0 + 15 + 30 = 45.<br />
Modifier légèrement ce programme pour qu'il additionne les nombres multiples de 3 ou de 5 compris entre les bornes a et b. Avec les bornes 0 et 32, le résultat devrait donc être : 0 + 3 + 5 + 6 + 9 + 10 + 12 + 15 + 18 + 20 + 21 + 24 + 25 + 27 + 30 = 225.</li>
<li>Déterminer si une année (dont le millésime est introduit par l'utilisateur) est bissextile ou non. (Une année A est bissextile si A est divisible par 4. Elle ne l'est cependant pas si A est un multiple de 100, à moins que A ne soit multiple de 400).</li>
<li>Demander à l'utilisateur son nom et son sexe (M ou F). En fonction de ces données, afficher « Cher Monsieur » ou « Chère Mademoiselle » suivi du nom de l'élève.</li>
<li>Demander à l'utilisateur d'entrer trois longueurs a, b, c. A l'aide de ces trois longueurs, déterminer s'il est possible de construire un triangle. Déterminer ensuite si ce triangle est rectangle, isocèle, équilatéral ou quelconque. Attention : un triangle rectangle peut être isocèle.</li>
<li>Demander à l'utilisateur qu'il entre un nombre. Afficher ensuite : soit la racine carrée de ce nombre, soit un message indiquant que la racine carrée de ce nombre ne peut être calculée.</li>
<li>Convertir une note scolaire N quelconque, entrée par l'utilisateur sous forme de points (par exemple 27 sur 85), en une note standardisée suivant le code suivant :
{| style="width:100%"
|-
|Note || Appréciation
|-
|N >= 80 % || A
|-
|80 % > N >= 60 % || B
|-
|60 % > N >= 50 % || C
|-
|50 % > N >= 40 % || D
|-
|N < 40 % || E
|}</li>
<li>Soit la liste suivante :<br />
<code>['Jean-Michel', 'Marc', 'Vanessa', 'Anne', 'Maximilien', 'Alexandre-Benoît', 'Louise']</code><br />
Ecrivez un script qui affiche chacun de ces noms avec le nombre de caractères correspondant.</li>
<li>Écrire une boucle de programme qui demande à l'utilisateur d'entrer des notes d'élèves. La boucle se terminera seulement si l'utilisateur entre une valeur négative. Avec les notes ainsi entrées, construire progressivement une liste. Après chaque entrée d'une nouvelle note (et donc à chaque itération de la boucle), afficher le nombre de notes entrées, la note la plus élevée, la note la plus basse, la moyenne de toutes les notes.</li>
<li>Ecrivez un script qui affiche la valeur de la force de gravitation s'exerçant entre deux masses de 10000 kg , pour des distances qui augmentent suivant une progression géométrique de raison 2, à partir de 5 cm (0,05 mètre).
La force de gravitation est régie par la formule <math>F = 6,67 \times10^{-11} \times \frac{m \times m'}{d^2}</math><br />
Exemple d'affichage :
<pre>
d = .05 m : la force vaut 2.668 N
d = .1 m : la force vaut 0.667 N
d = .2 m : la force vaut 0.167 N
d = .4 m : la force vaut 0.0417 N
etc.
</pre></li>
</ol>
{{solution}}
<ol>
<li>Réfléchissez !</li>
<li>Réfléchissez !</li>
<li>Réfléchissez !</li>
<li>
<pre>
# Traitement de nombres entiers compris entre deux limites
print "Veuillez entrer la limite inférieure :",
a = input()
print "Veuillez entrer la limite supérieure :",
b = input()
s = 0 # somme recherchée (nulle au départ)
# Parcours de la série des nombres compris entre a et b :
n = a # nombre en cours de traitement
while n <= b:
if n % 3 ==0 and n % 5 ==0: # variante : 'or' au lieu de 'and'
s = s + n
n = n + 1
print "La somme recherchée vaut", s
</pre>
</li>
<li>
<pre>
# Années bissextiles
print "Veuillez entrer l'année à tester :",
a = input()
if a % 4 != 0:
# a n'est pas divisible par 4 -> année non bissextile
bs = 0
else:
if a % 400 ==0:
# a divisible par 400 -> année bissextile
bs = 1
elif a % 100 ==0:
# a divisible par 100 -> année non bissextile
bs = 0
else:
# autres cas ou a est divisible par 4 -> année bissextile
bs = 1
if bs ==1:
ch = "est"
else:
ch = "n'est pas"
print "L'année", a, ch, "bissextile."
Variante (proposée par Alex Misbah) :
a=input('entrée une année:')
if (a%4==0) and ((a%100!=0) or (a%400==0)):
print a,"est une année bissextile"
else:
print a,"n'est pas une année bissextile"
Variante (de Mik)
a=input('année:')
if (a%4==0 and a%100!=0)or(a%400==0):
print "bi6"
else:
print "nbi6"
</pre>
</li>
<li>Réfléchissez !</li>
<li>
<pre>
from sys import exit # module contenant des fonctions système
print """
Veuillez entrer les longueurs des 3 côtés
(en séparant ces valeurs à l'aide de virgules) :"""
a, b, c = input()
# Il n'est possible de construire un triangle que si chaque côté
# a une longueur inférieure à la somme des deux autres :
if a < (b+c) and b < (a+c) and c < (a+b) :
print "Ces trois longueurs déterminent bien un triangle."
else:
print "Il est impossible de construire un tel triangle !"
exit() # ainsi l'on n'ira pas plus loin.
f = 0
if a == b and b == c :
print "Ce triangle est équilatéral."
f = 1
elif a == b or b == c or c == a :
print "Ce triangle est isocèle."
f = 1
if a*a + b*b == c*c or b*b + c*c == a*a or c*c + a*a == b*b :
print "Ce triangle est rectangle."
f = 1
if f == 0 :
print "Ce triangle est quelconque."
Variante (de Mik)
a,b= input('a:'),input('b:')
if b>a:
print '"c":](',b-a,');(',a+b,')['
else:
print '"c":](',a-b,');(',a+b,')['
c=input('c:')
if a < (b+c) and b < (a+c) and c < (a+b) :
print 'bien un triangle'
else:
print 'impossible constrution triangle'
exit()
if a>b and a>c:
max=a
x=c*c+b*b
elif b>a and b>c:
max=b
x=c*c+a*a
elif c>b and c>a:
max=c
x=a*a+b*b
if a==b and b==c :
print "triangle équilatéral."
elif a==b or b==c or c==a :
print "triangle isocèle."
elif x==max**2 :
print "triangle rectangle."
else:
print "triangle quelconque."
</pre>
</li>
<li>Réfléchissez !</li>
<li>Réfléchissez !</li>
<li>Réfléchissez !</li>
<li>
<pre>
# Notes de travaux scolaires
notes = [] # liste à construire
n = 2 # valeur positive quelconque pour initier la boucle
while n >= 0 :
print "Entrez la note suivante, s.v.p. : ",
n = float(raw_input()) # conversion de l'entrée en un nombre réel
if n < 0 :
print "OK. Terminé."
else:
notes.append(n) # ajout d'une note à la liste
# Calculs divers sur les notes déjà entrées :
# valeurs minimale et maximale + total de toutes les notes.
min = 500 # valeur supérieure à toute note
max, tot, i = 0, 0, 0
nn = len(notes) # nombre de notes déjà entrées
while i < nn:
if notes[i] > max:
max = notes[i]
if notes[i] < min:
min = notes[i]
tot = tot + notes[i]
moy = tot/nn
i = i + 1
print nn, "notes entrées. Max =", max, "Min =", min, "Moy =", moy
</pre>
</li>
<li>Réfléchissez !</li>
</ol>
{{fin}}
<noinclude>
==Références==
{{références}}
| 