Ouvrez - Cité Scolaire Pardailhan

LE BASTARD YANNICK
Enseignant au LEGTA Frédéric Bazille (34)
ALGORITHMIQUE AU LYCEE
Colloque de Toulouse (9 et 10 Juin 2011)
Avant propos
Les présentes notes sont inspirées d'une expérience de trois ans en lycée et sur deux niveaux
différents : Licence de Biologie au LEGTA de Venours (86) : de 2008 à 2010, ainsi qu'en classe de
seconde générale et technologique à l'issu de la réforme des programmes (été 2009) durant deux
années : 2009-2010 au LEGTA de Venours et 2010-2011 au LEGTA Frédéric Bazille (34). Mes
sources sont diverses : réflexions personnelles, conversations avec des collègues (je remercie
notamment Jacques Texier pour son importante contribution), lectures sur le web, ainsi que
l'excellent livre de Gérard Swinnen : Apprendre à programmer avec Python.
J'ai eu la chance de pouvoir enseigner pendant deux années complètes à des effectifs réduits, ce qui
a permis une utilisation efficace des salles informatiques de l'établissement, mais surtout une
régularité dans l'apprentissage des concepts pour les élèves et les étudiants, à raison de 2h/semaine
pour la classe de licence et d'une heure par quinzaine en moyenne pour la classe de seconde.
Ces conditions, il est vrai, exceptionnelles ont permis la réalisation de quelques projets de classe,
par groupe de trois élèves en seconde et de deux pour les étudiants.
La réforme de la filière S prévoit la continuité de l'apprentissage de l'algorithmique et de sa mise en
œuvre sur calculette ou ordinateur jusqu'en terminale. Ces notes tiennent compte de cette évolution,
et proposent un suivi à différent niveaux : depuis l'apprentissage qui peut être réalisé dès la classe
de seconde jusqu'à l'écriture de scripts mathématiquement plus consistants en lien avec le
programme de la terminale S.
Les sujets abordés ne sont en rien originaux, mais la démarche peut-être en proposant une
progression dans l'apprentissage des concepts, avec une analyse des difficultés rencontrées,
s'appuyant sur l'expérience effective sur le terrain. Un outil sera utilisé : le langage de
programmation Python. Des séances d'initiation sont proposées par ordre chronologique pour
acquérir les bases puis sous forme de TP réalisables en classe.
Ces notes ne sont pas du tout exhaustives sur le sujet à traiter et je serai infiniment reconnaissant au
lecteur de toutes les suggestions ou critiques qu'il voudra bien me formuler.
Utilisation de ces notes
Dans le cadre d'une utilisation tout au long des trois années de lycée : seconde générale et
technologique, première et terminale scientifique, ces notes ont été découpées en plusieurs chapitres
avec des buts bien précis. Ils sont adaptés à chacun des niveaux. On ne considère ici que la classe de
seconde GT, le reste des chapitres est en construction... et en test ! Même si quelques prolongements
seront donnés dans le dernier chapitre.
Classe de seconde
Chapitres 2 et 3 : On met en place les notions fondamentales de boucle et d'instruction
conditionnelle et leur mise en œuvre sur Python.
Le Chapitre 4 regroupe des idées de projets faisables à ce niveau par groupes d'élèves. Tous sont
entièrement décortiqués et corrigés.
Chapitre 5 : correction des exercices et des TP du chapitres 3.
Classes de première et de terminale S
Chapitre 6 : quelques TP et leurs corrigés.
TABLE DES MATIERES
Chapitre 1 : Motivations...................................................................................................................5
Chapitre 2 : Notions d'algorithmique..............................................................................................8
Fiche élève n°1...........................................................................................................10
Fiche professeur n°1...................................................................................................16
Fiche élève n°2...........................................................................................................23
Fiche professeur n°2...................................................................................................26
Chapitre 3 : Python..........................................................................................................................30
Langage Python..........................................................................................................32
Séance Python n°1......................................................................................................33
Séance Python n°2......................................................................................................39
Séance Python n°3......................................................................................................43
Séance Python n°4......................................................................................................45
Séance Python n°5......................................................................................................47
Séance Python n°6......................................................................................................51
Fiches de complément Python....................................................................................55
Fiches de TP en seconde GT.......................................................................................63
Chapitre 4 : Projets en seconde GT.................................................................................................72
Énoncé des projets......................................................................................................74
Corrigé des projets......................................................................................................83
Chapitre 5 : Corrigé des exercices du chapitre 3...........................................................................95
Chapitre 6 : TP en filière S.............................................................................................................113
Énoncé des TP...........................................................................................................115
Corrigé des TP...........................................................................................................123
Bibliographie...................................................................................................................................137
CHAPITRE 1 : MOTIVATIONS
Conformément au BO n°30 du 23 Juillet 2009, l'algorithmique a été introduite dans le cadre du
nouveau programme de seconde générale et technologique dont voici un extrait.
Al g orith miq u e (obj e c tif s p o ur l e ly c é e )
La démarche algorithmique est, depuis les origines, une composante essentielle de l’activité
mathématique. Au collège, les élèves ont rencontré des algorithmes (algorithmes opératoires,
algorithme des différences, algorithme d’Euclide, algorithmes de construction en géométrie). Ce qui
est proposé dans le programme est une formalisation en langage naturel propre à donner lieu à
traduction sur une calculatrice ou à l’aide d’un logiciel. Il s’agit de familiariser les élèves avec les
grands principes d’organisation d’un algorithme : gestion des entrées-sorties, affectation d’une
valeur et mise en forme d’un calcul.
Dans le cadre de cette activité algorithmique, les élèves sont entraînés :
• à décrire certains algorithmes en langage naturel ou dans un langage symbolique ;
• à en réaliser quelques uns à l’aide d’un tableur ou d’un petit programme réalisé sur une
calculatrice ou avec un logiciel adapté ;
• à interpréter des algorithmes plus complexes.
Aucun langage, aucun logiciel n’est imposé.
L’algorithmique a une place naturelle dans tous les champs des mathématiques et les problèmes
posés doivent être en relation avec les autres parties du programme (fonctions, géométrie,
statistiques et probabilité, logique) mais aussi avec les autres disciplines ou la vie courante.
À l’occasion de l’écriture d’algorithmes et de petits programmes, il convient de donner aux élèves
de bonnes habitudes de rigueur et de les entraîner aux pratiques systématiques de vérification et de
contrôle.
Instructions élémentaires (affectation, calcul, entrée, sortie).
Les élèves, dans le cadre d’une résolution de problèmes, doivent être capables :
• d’écrire une formule permettant un calcul ;
• d’écrire un programme calculant et donnant la valeur d’une fonction ;
ainsi que les instructions d’entrées et sorties nécessaires au traitement.
Boucle et itérateur, instruction conditionnelle
Les élèves, dans le cadre d’une résolution de problèmes, doivent être capables :
• de programmer un calcul itératif, le nombre d’itérations étant donné ;
• de programmer une instruction conditionnelle, un calcul itératif, avec une fin de boucle
conditionnelle.
S'appuyant sur cette ligne, les présentes notes ont pour but de :
1. Faire l'analyse détaillée d'un problème (géométrique, numérique, de la vie courante).
2. De proposer un algorithme, éventuellement plusieurs, apportant une solution.
3. De le mettre en œuvre à l'aide de l'outil informatique.
La démarche adoptée a été la suivante :
• Définir les tenants et les aboutissants de l'algorithmique.
• Écrire des algorithmes en pseudo-langage et les « faire tourner à la main ». Y ont été
notamment définies les notions d'affectation, de boucle et d'instruction conditionnelle.
• Passer à la programmation en « langage machine » à l'aide du langage Python
AVERTISSEMENT : Il ne s'agit en aucun cas de réaliser un apprentissage poussé de ces deux
langages : des ouvrages ou des sites web didactiques conçus dans ce but existent déjà ; l'idée est de
s'en servir comme miroir de la réflexion de l'élève en soulevant les difficultés rencontrées dans la
pratique par le professeur.
Quels sont donc les intérêts d' utiliser un ordinateur ou une calculatrice ?
1. Le face à face élève-machine est différent de celui, plus traditionnel, élève-professeur. Les
élèves, habitués pour la très grande majorité à l'ordinateur sont familiers avec cet instrument,
du moins pour certaines utilisations. Cette familiarité, cette habitude du visuel de l'écran est
un point positif pour l'apprentissage. Très peu sont réfractaires à son utilisation.
2. Autre intérêt de ce face à face élève-machine : Lorsque la machine dit « non », il n'y a pas
de contestation possible comme devant un être humain. La machine ne pardonne aucune
erreur de syntaxe : voilà un excellent apprentissage de la rigueur. Il faut recommencer à la
moindre faute de frappe. Même chose en cas de mauvaise conception du programme.
3. Enfin, la possibilité de voir très rapidement le résultat de son travail devant ses yeux. Dans
une génération habituée à zapper, c'est un plus. Le fait de ne pas aboutir sur une machine au
résultat escompté pousse le plus souvent à la ténacité : « ce n'est quand même pas un ordi
qui va me résister !! »
CHAPITRE 2 : NOTIONS D'ALGORITHMIQUE
Objectifs et mise en œuvre
Le présent chapitre se compose de deux fiches élèves et autant de fiches professeur, contenant les
corrigés des exercices proposés, ainsi que des commentaires pédagogiques liés aux séances.
Les objectifs au cours de ces séances formelles, mais néanmoins instructives, pour ne pas dire
indispensables pour la suite sont :
•
•
•
•
Définir ce qu'est un algorithme et la démarche algorithmique à travers quelques exemples
géométriques et calculatoires.
Introduire les notions de variables, de boucle et d'instruction conditionnelle.
Savoir interpréter quelques algorithmes simples.
Créer des algorithmes en langage naturel, prêts à être interprétés en langage machine.
Une fiche de synthèse clôt ce chapitre.
Les séquences sont supposées durer entre deux et trois heures chacune.
Fiche élève n°1
Prolégomènes
Avant de définir précisément ce qu'est l'algorithmique et quels en sont les buts, intéressons-nous de
suite à un premier exemple graphique : la construction d'un objet fractal appelé flocon de Von Koch.
On donne ici les deux premières étapes. A vous d'en déterminer la troisième ainsi que le processus
général qui permet de passer de l'étape n à l'étape n + 1.
Flocon à l'étape 0
Flocon à l'étape 1
Flocon à l'étape 2
Récapitulons ce processus ; il comprend deux instructions à effectuer qui sont :
•
•
Définitions : On peut définir un algorithme comme une suite d'instructions précises, à appliquer
dans un ordre précis, pour arriver en un nombre fini d'étapes à un certain résultat. L'algorithmique
est la science des algorithmes (création, amélioration...)
Premiers exercices
Dans les deux exercices qui suivent, vous pouvez utiliser les instructions suivantes :
1. Avancer (d'une longueur donnée)
2. Tourner à gauche ou à droite (d'un angle donné en degré)
On suppose que le « crayon » se déplace par défaut horizontalement et vers la droite au départ.
Exercice 1 : Écrire un programme permettant de construire un carré de côté 50 tout en revenant à la
position de départ.
Exercice 2 : Écrire un programme permettant de construire un triangle équilatéral de côté 100 tout
en revenant à la position de départ.
Remarque : Dans l'exercice 1 comme dans le suivant, un même bloc d'instructions a été répété
plusieurs fois. Repérer lequel dans chacun des deux cas.
Cette répétition des mêmes instructions un certain nombre de fois peut être « résumée » en
introduisant une notion très importante en programmation, et très économique au niveau du nombre
de lignes à écrire.
Les instructions répétitives : notion de boucle
Il existe essentiellement deux méthodes pour écrire une boucle, c'est-à-dire un procédé qui permet
la répétition un certain nombre de fois d'un même processus (addition, multiplication, etc...).
Afin de les mettre en pratique, nous allons résoudre l'exercice 1 de cette manière.
METHODE 1
Analysons le programme en langage naturel suivant :
i←0
Tant que i<4 (ou i<=3) faire
avancer de 50
tourner à gauche de 90°
i←i+1
J'affecte à i la valeur 0
Tant que la condition annoncée est vraie, on
effectue les deux instructions qui suivent
On réaffecte à i sa valeur précédente augmentée
de 1
Quel est le résultat obtenu ?
On peut alors résumer la structure de boucle décrite ici de la manière suivante :
Tant que condition vérifiée faire
Bloc d'instructions
Remarques : Si la condition n'est pas vérifiée au début, alors le bloc d'instructions ne sera pas
exécuté du tout.
ATTENTION ! Pour que l'algorithme soit correct, il est nécessaire que la condition cesse d'être
vérifiée au bout d'un nombre fini de répétitions. Sinon, le programme « boucle indéfiniment ».
Exercice 3 : Que fait le programme suivant ?
S ← 80
Tant que S>20 faire
S ← S + 10
METHODE 2
Une autre manière courante d'écrire une boucle est :
Pour i variant de 0 à 3 (ou de 1 à 4) faire
avancer de 50
tourner à gauche de 90°
La variable i évolue comme indiqué, par défaut
de 1 en 1.
Les deux instructions suivantes sont alors
effectuées
Le résultat obtenu est exactement le même : le dessin d'un carré de côté 50.
On peut alors résumer la structure de boucle décrite ici de la manière suivante :
Pour i variant de 0 à N (ou de 1 à N) faire
Bloc d'instructions
Exercice 4 : Écrire deux programmes utilisant chaque type de boucle pour résoudre l'exercice 2.
Problème type : on veut calculer la somme
S = 123…99100 .
Analyse : Bien évidemment, on ne va pas saisir à la machine cette longue opération ! Il nous faut
donc trouver un moyen pour que cette dernière l'exécute, mais en écrivant le moins de lignes
possible.
On commence par remarquer que l'opération qui est sans cesse utilisée est l'addition. D'où l'idée
d'utiliser une boucle : on répète plusieurs fois le même procédé : ici additionner.
Additionner oui, mais quoi ? 1 d'abord, puis 2, puis 3, … , jusqu'à 100. Autrement dit on additionne
une suite de nombres qui « varient », dans le cas présent de 1 en 1.
L'idée essentielle est de calculer S petit à petit, comme on le ferait à la main en ajoutant peu à peu
tous les termes contenus dans l'addition.
Comme S va évoluer et les termes qui la composent aussi, on a l'idée d'introduire deux
variables : S elle-même et un « compteur » i, qui devra prendre successivement les valeurs 1, 2, 3,
…, 100.
Nous allons résoudre ce problème en créant un algorithme efficace, utilisant (mais ce n'est pas une
obligation), le premier type de boucle.
Mise en œuvre :
Instructions
Signification
S←0
i←1
Tant que i ≤ 100 faire
On affecte à S la valeur 0 (valeur initiale)
On affecte à i la valeur 1 (valeur initiale)
La condition est posée: i varie jusqu'à 100
S←S+i
i←i+1
On réaffecte à S sa valeur précédente plus la
valeur actuelle de i
On réaffecte à i sa valeur augmentée de 1
Afficher S
Une fois sorti de la boucle, on affiche S
Vous allez à présent « faire tourner l'algorithme à la main », c'est-à-dire regarder, étape par étape
l'évolution des variables i et S, et enfin le résultat final. Pour cela, compléter le tableau suivant.
Vous ne donnerez pas le résultat du calcul de S à chaque étape, mais seulement l'écriture de S sous
la forme d'une somme.
Après l'itération
i
S
0
1
0
1
2
3
...
99
100
Quelle est la dernière valeur prise par la variable S ? Quel est le résultat affiché par le programme ?
Exercice 5 : Écrire un programme utilisant une boucle Tant que calculant et affichant le résultat
de :
S = 369…201
1.
P = 2×4×6×8×…×40
2.
1
1
1
S = 1

...
3.
2
3
10
Exercice 6 : Construire la figure suivante en utilisant l'instruction Tant que (longueur d'un côté du
quadrillage 50).On partira du point A.
Exercices supplémentaires : Ces exercices sont destinés à vous entraîner à utiliser la notion de
boucle. Ils sont classés par ordre progressif de difficulté. Reportez-vous à ceux déjà faits lors de
cette séance. Travaillez en profondeur votre compréhension du cours. Il suffit de quelques
modifications pour trouver la solution.
Exercice 7 : Vous pouvez utiliser les instructions suivantes :
• Avancer (d'une longueur donnée)
• Tourner à gauche ou à droite (d'un angle donné en degré)
1. Construire la figure suivante en utilisant une boucle (longueur du côté du quadrillage égale à
30). On partira du point central.
2. En utilisant toujours une boucle, construire la figure suivante (longueur du côté du
quadrillage égale à 30). Le repère n'a aucune importance.
Exercice 8 : En utilisant une boucle Tant que, écrivez un programme permettant de calculer puis
d'afficher le résultat de la somme suivante :
1
1
1
1
T = 1 

…
2 2×3 2×3×4
2×3×4×…×10
Indication : bien analyser de combien de variables vous avez besoin.
Exercice 9 :
En utilisant l'instruction Tant que, soit une fois soit deux fois dans le même programme, obtenir le
dessin suivant :
Carré de côté 10 et intervalle entre les carrés 10.
Vous disposez en plus de deux instructions :
lever le crayon (permet d'avancer sans que ceci dessine quoi que ce soit)
baisser le crayon (permet de redessiner à nouveau)
Fiche professeur n°1
Construction du flocon
On donne ici les deux premières étapes. A vous d'en déterminer la troisième ainsi que le processus
général qui permet de passer de l'étape n à l'étape n + 1.
Flocon à l'étape 0
Flocon à l'étape 1
Flocon à l'étape 2
Récapitulons ce processus ; il comprend deux instructions à effectuer qui sont :
•
On partage chacun des segments en trois segments de longueurs égales.
•
On construit extérieurement un triangle équilatéral de base le segment du milieu.
Corrigé des exercices
Corrigé de l'exercice 1 :
Avec les instructions dont on dispose, on peut construire un carré de côté 50 de la manière
suivante :
Avancer de 50
Tourner à gauche de 90°
Avancer de 50
Tourner à gauche de 90°
Avancer de 50
Tourner à gauche de 90°
Avancer de 50
Tourner à gauche de 90°
Remarque : on aurait tout aussi bien pu écrire : Tourner à droite de 90° à chaque fois.
Le bloc d'instructions qui se répète est :
Avancer de 50
Tourner à gauche de 90°
Commentaire pédagogique : Beaucoup d'élèves disent : pourquoi ne pas multiplier ça par 4 ? L'idée
de boucle est déjà sous-jacente.
Corrigé de l'exercice 2 :
Avancer de 100
Tourner à gauche de 120°
Avancer de 100
Tourner à gauche de 120°
Avancer de 100
Tourner à gauche de 120°
Le bloc d'instructions qui se répète est :
Avancer de 100
Tourner à gauche de 120°
Commentaire pédagogique : Le « piège » est de penser immédiatement : Tourner de 60°. Le
professeur démontre rapidement par un petit dessin au tableau que c'est erroné et laisse trouver aux
élèves la bonne mesure d'angle.
Corrigé de l'exercice 3 :
La variable S est initialisée à 80. Par conséquent la condition S>20 est vérifiée. Or le bloc
d'instructions de la boucle est composée d'une seule ligne : réaffecter à S sa valeur augmentée de 10.
Il s'ensuit que la variable S va prendre des valeurs de plus en plus grandes et la condition de la
boucle sera toujours vérifiée. Le programme boucle indéfiniment !
Commentaire pédagogique : Cet exercice permet de mettre en garde les élèves sur la condition
choisie. On veut arriver à un certain résultat en un nombre fini d'étapes.
Corrigé de l'exercice 4 :
Avec une boucle Tant que
i←0
Tant que i<3 faire
avancer de 100
tourner à gauche de 120°
i←i+1
Avec une boucle Pour
Pour i variant de 0 à 2 (ou de 1 à 3) faire
avancer de 100
tourner à gauche de 120°
Commentaire pédagogique : La boucle Tant que, universelle quel que soit le langage de
programmation choisie me semble préférable à celle de Pour, dont la syntaxe est très variable. Par
ailleurs, on y voit mieux l'évolution du « compteur » i.
Analyse du problème résolu : Ceci permet de compléter pas à pas le tableau donné aux élèves.
Situation initiale
i
1
S
0
Comme i est égal à 1 et que 1100 , la condition de la boucle est bien vérifiée, donc cette
dernière exécute la suite d'instructions précédente :
• S est remplacé par sa valeur précédente : 0 à laquelle on rajoute la valeur actuelle de i : 1.
Ainsi, S = 0 + 1 soit S = 1.
• i est remplacé par sa valeur actuelle : 1 à laquelle on rajoute 1. Ainsi i = 1 + 1 soit i = 2.
Situation après une itération
i
2
S
1
Comme i est égal à 2 et que 2100 , la condition de la boucle est bien vérifiée, donc cette
dernière exécute la suite d'instructions précédente :
• S est remplacé par sa valeur précédente : 1 à laquelle on rajoute la valeur actuelle de i : 2.
Ainsi, S = 1 + 2
• i est remplacé par sa valeur actuelle : 2 à laquelle on rajoute 1. Ainsi i = 2 + 1 soit i = 3.
Situation après deux itérations
i
3
S
1+2
Et ainsi de suite... Tant que la condition de la boucle est valide, le bloc d'instruction est exécuté.
Situation après 99 itérations
i
100
S
1+2+...+99
Comme i est égal à 100 et que 100100 , la condition de la boucle est bien vérifiée, donc cette
dernière exécute la suite d'instructions précédente :
• S est remplacé par sa valeur précédente : 1+2+...+99 à laquelle on rajoute la valeur actuelle
de i : 100. Ainsi, S = 1 + 2 + … + 100
• i est remplacé par sa valeur actuelle : 100 à laquelle on rajoute 1. Ainsi i = 101
Situation après 100 itérations
i
101
S
1+2+...+100
Cette fois-ci, i est égal à 101, donc la condition de la boucle n'est plus valide. La boucle s'arrête. Le
programme effectue alors la dernière instruction (qui n'était pas dans la boucle) : afficher la valeur
de S, c'est-à-dire le résultat de 1 + 2 + … + 100.
On remarque, puisque S évolue en premier dans le bloc d'instructions, qu'il y aura toujours 1 d'écart
entre i et la dernière valeur apparaissant dans la somme constituant S. Ceci permet de compléter le
tableau après 99 itérations.
Après l'itération
i
S
0
1
0
1
2
1
2
3
1+2
3
4
1+2+3
99
100
1 + 2 + 3 + … + 99
100
101
1 + 2 + … + 99 + 100
...
Corrigé de l'exercice 5 :
Question 1 : Il s'agit de sommer tous les multiples de 3 compris entre 3 et 201. L'idée est la même
que dans le problème résolu : utiliser une boucle (car on répète l'opération « addition ») et utiliser
deux variables : i, variable qui va énumérer touts les termes à additionner et S (la somme recherchée
qui va évoluer à chaque itération de i). Un algorithme possible est :
S←0
i←3
Tant que i ≤ 201 faire
S←S+i
i←i+3
Afficher S
Question 2 : Cette fois-ci, on multiplie tous les entiers pairs de 2 à 40.
P←1
i←2
Tant que i ≤ 40 faire
P ← P*i
i←i+2
Afficher P
On initialise le produit P à 1 (préciser pourquoi pas à 0)
On initialise i à 2
On remplace P par sa valeur précédente multipliée par la valeur
actuelle de i
i est incrémenté de 2 à chaque itération
Question 3 : Remarquons que l'on peut réécrire la somme cherchée sous la forme
1 1 1 1
1
S =    …
.
1 2 3 4
10
L'idée est la même que dans le problème résolu : utiliser une boucle (car on répète l'opération
« addition »). Cette fois encore, on aura besoin de deux variables : i qui prendra successivement les
valeurs des dénominateurs successifs 1, 2, 3, … jusqu'à 10, et S qui évoluera à chaque itération de i.
S←0
i←1
Tant que i ≤ 10 faire
S ← S + 1/i
i←i+1
Afficher S
Corrigé de l'exercice 6 :
Il s'agit de tracer un hexagone régulier.
i← 0
Tant que i<6 faire
avancer de150
tourner à gauche de 60°
i←i+1
Il y a 6 côtés...
de longueur 150
Corrigé des exercices supplémentaires :
Question 1 : Dessin d'une spirale dont la mesure des segments varie. L'idée est d'utiliser une boucle
car on répète plusieurs fois le même processus : avancer, puis tourner à gauche de 90°. La
différence par rapport à la question précédente est qu'à chaque itération, on avance de 30 unités
supplémentaires. D'où l'idée d'utiliser deux variables : i qui va compter le nombre de segments de la
spirale et l la longueur du premier segment, qui va s'accroître de 30 à chaque itération.
i←0
l ← 30
Tant que i<9 faire
avancer de l
tourner à gauche de 90°
l ← l + 30
i←i+1
Il y a neuf segments.
On avance de l
l est incrémenté de 30
Question 2 : Dessin d'une spirale dont la mesure des segments varie mais pas consécutivement.
L'idée est d'utiliser une boucle car on répète plusieurs fois le même processus : avancer, puis tourner
à gauche de 90°. La différence par rapport à la question précédente est que deux segments
consécutifs ont la même longueur. D'où l'idée d'utiliser deux variables : i qui va compter le nombre
de segments de la spirale et l la longueur du premier segment, qui va s'accroître de 30 à chaque
itération. Le bloc d'instructions « avancer, tourner » sera répété deux fois par rapport à la question 1.
i←0
l ← 30
Tant que i<6 faire
avancer de l
tourner à gauche de 90°
avancer de l
tourner à gauche de 90°
l ← l + 30
i←i+1
Corrigé de l'exercice 8 :
Remarquons
que
l'on
peut
réécrire
la
somme
cherchée
sous
la
forme
1
1
1
1
1
T = 


…
.
1 1×2 1×2×3 1×2×3×4
1×2×3×4×…×10
Cette fois-ci, on aura besoin de trois variables : i qui prendra successivement les valeurs 1, 2, 3, …
jusqu'à 10, P qui prendra successivement les valeurs 1, 1×2 , 1×2×3 , …, jusqu'à
1×2×…×10 et T qui évoluera en même temps que les deux autres variables.
Tableau des 2 premières itérations en partant des conditions
initiales.
i←1
P←1
i
P
T
T←0
1
1
0
2
1
1
3
2
1+1/2
Tant que i ≤ 10 faire
P ← P*i
T ← T + 1/P
i ← i+1
Afficher T
valeurs
initiales
Après
itération 1
Après
itération 2
Corrigé de l'exercice 9 :
Cet exercice va nécessiter deux boucles, donc deux compteurs i et j par exemple ; l'un servira pour
dessiner un carré, l'autre servira pour le nombre de carrés à dessiner. Attention de ne pas oublier les
espaces entre les carrés !
j←0
Tant que j<10 faire
i←0
Tant que i<4 faire
avancer de 10
tourner à gauche de 90°
i←i+1
lever le crayon
avancer de 20
baisser le crayon
j ← j+1
j est le compteur qui sert à dessiner les 10 carrés
i est le compteur qui sert à dessiner les 4 côtés d'un carré
Bien analyser pourquoi il est placé ici !
on avance de 10+10 = 20 comme demandé dans l'énoncé
Remarque : Les blocs d'instructions sont indentés. On verra plus loin que cette écriture est
essentielle lorsque l'on écrit un programme en langage Python.
Commentaire pédagogique : Il est intéressant de faire apparaître bien précisément les blocs
d'instructions en précisant à quelle boucle ils sont rattachés.
Fiche élève n°2
Instructions conditionnelles
Nous avons vu à la séance précédente la notion de boucle, utilisée dans le cas où une même suite
d'opérations est répétée un certain nombre de fois. Nous allons nous intéresser ici au cas
d'instructions conditionnelles.
Cette notion permet à un algorithme d'effectuer certaines instructions seulement si une certaine
condition est remplie.
Ceci prend la forme suivante en pseudo-langage :
Si (condition vérifiée) faire
Bloc d'instructions
Dans le cas où la condition de départ n'est pas vérifiée, il est également possible d'indiquer à
l'algorithme une alternative qu'il doit effectuer. On obtient alors la structure suivante :
Si (condition vérifiée) faire
Bloc d'instructions n°1
Sinon faire
Bloc d'instruction n°2
Exercice 1
Écrire dans la zone de texte adjacente le résultat affiché à l'écran par l'ordinateur pour chacun des
programmes suivants :
Question 1
N←4
a←7
Si N<a faire
écrire « Eh »
Sinon
écrire « Oh »
Question 2
i←1
Tant que i<5 faire
Si i est divisible par 2 faire
écrire 3*i
Sinon
écrire i
i←i+1
Exercice 2
Écrire un programme qui demande à l'utilisateur d'écrire son sexe à l'écran : M pour masculin ; F
pour féminin.
a) Si l'utilisateur saisit M, l'ordinateur affichera : Bonjour monsieur !
b) Si l'utilisateur saisit F, l'ordinateur affichera : Bonjour mademoiselle !
Le symbole de comparaison égalité se note =
Vous avez le droit aux instructions suivantes :
• Si … Sinon
• écrire (un texte apparaissant à l'écran)
• lire (un texte sur l'écran de l'ordinateur)
Notons le cas où la condition de départ peut être constituée de plusieurs autres conditions qui
doivent être vérifiées simultanément. Nous obtenons alors une suite d'instructions conditionnelles
imbriquées. Il y a essentiellement deux structures pour décrire ceci.
Méthode n°1
Méthode n°2
Si (condition 1 vérifiée) faire
Si (condition 1 vérifiée ET condition 2 vérifiée
Si (condition 2 vérifiée) faire
ET… ET condition k vérifiée) faire
Si (condition 3 vérifiée) faire
…
Bloc d'instructions
Si (condition k vérifiée) faire
Bloc d'instructions
Exercice 3
Un automobiliste veut louer une grosse cylindrée dans une agence. Ceci n'est possible que s'il a 25
ans ou plus et au minimum 5 ans de permis. Écrire un programme qui demande à l'utilisateur son
âge, puis le nombre d'années qu'il possède son permis et renvoie le résultat « Location acceptée » ou
« Location refusée » selon les réponses saisies.
Analyse : L'utilisateur doit vérifier deux conditions pour que sa location soit acceptée : « Avoir un
âge au moins égal à 25 ans » ET « posséder le permis depuis au moins 5 ans ».
Vous avez le droit aux instructions suivantes :
• Si … Sinon
• écrire (un texte apparaissant à l'écran)
• lire (une valeur sur l'écran de l'ordinateur)
On dispose aussi de l'opérateur logique OU au sens mathématique du terme (ce n'est pas un OU
exclusif).
Exercice 4 : 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).
Vous disposez des mêmes instructions qu'à l'exercice précédent ainsi que de l'instruction : est
divisible par et de son contraire.
Dans certains cas, il se peut que plusieurs alternatives soient possibles si la condition initiale
n'est pas vérifiée. On obtient alors la structure suivante :
Si (condition 1 vérifiée) faire
Bloc d'instructions n°1
Sinon si (condition 2 vérifiée) faire
Remarque : L'écriture « Sinon si » signifie que les
conditions 1, 2,..., N-1 ne sont jamais vérifiées
simultanément deux à deux. On a une partition
des cas possibles.
Bloc d'instruction n°2
…etc...
Sinon si (condition N-1 vérifiée) faire
Exemple : le fait que la condition 3 soit vérifiée
implique nécessairement que les conditions 1 et 2 ne
l'aient pas été.
Bloc d'instructions n° N-1
Sinon faire
Bloc d'instruction n° N
Exercice 5 : Convertir une note scolaire N quelconque (sur 20), entrée par l'utilisateur sous forme
de points (par exemple 12,75), en une note standardisée suivant le code suivant :
Note
N >= 16
16 > N >=12
12 > N >= 10
10 > N >= 8
N<8
Appréciation
A
B
C
D
E
Vous avez le droit aux instructions suivantes :
• Si … Sinon si … Sinon
• écrire (un texte apparaissant à l'écran)
• lire (une valeur sur l'écran de l'ordinateur)
Fiche professeur n°2
Corrigé des exercices
Corrigé de l'exercice 1
Question 1 : Il va s'afficher Eh
Question 2 : Il va s'afficher la suite de nombres :
1
6
3
12
Commentaire pédagogique : La dernière question de cet exercice fait travailler simultanément les
notions de boucle et d'instruction conditionnelle, ce qui présente une difficulté. Certains élèves
peuvent confondre l'instruction écrire 3*i avec réaffecter à i la valeur 3*i.
Corrigé de l'exercice 2
écrire "Quel est votre sexe ? M ou F ?"
lire texte
Si texte="M" faire
écrire "Bonjour Monsieur !"
Sinon faire
écrire "Bonjour Mademoiselle !"
Corrigé de l'exercice 3
écrire "Quel est votre âge ? "
lire age
écrire "Depuis combien de temps avez-vous le permis ? "
lire N
Si (age>=25) ET (N>=5) faire
écrire "Location acceptée"
Sinon faire
écrire "Location refusée"
Corrigé de l'exercice 4
Analyse : Le texte ne semble pas si évident a priori. On peut néanmoins le modéliser à l'aide d'un
diagramme de Venn ("patatoïde") qui va donner tout le squelette de l'algorithme. Remarquons que :
Tout multiple de 400 est un multiple de 100 (Réciproque fausse)
Tout multiple de 100 est un multiple de 4 (Réciproque fausse)
A divisible par 4
A divisible par 100
A divisible par 400
écrire "Entrez une année "
lire A
Si (A est divisible par 4 ET A n'est pas divisible par 100) OU (A est divisible par 400) faire
écrire "Cette année est bissextile"
Sinon faire
écrire "Cette année n'est pas bissextile"
Corrigé de l'exercice 5
Analyse : Les différentes conditions sont liées à la valeur de la note N. On peut les résumer dans le
programme en pseudo-langage suivant.
Algorithme
Si N>=16 faire
Commentaires
La première condition est N>=16
écrire "A"
Sinon si N>=12 faire
écrire "B"
Pas besoin d'écrire 16>N>=12. En effet si la
première condition n'est pas vérifiée, on a
nécessairement N<16. La seconde condition ne
porte plus que sur la comparaison de N à 12.
Sinon si N>=10 faire
écrire "C"
Sinon si N>=8 faire
écrire "D"
Sinon faire
écrire "E"
Pas besoin d'écrire Sinon si N<8. En effet,
lorsque toutes les conditions précédentes ne sont
pas vérifiées, il n'y a plus qu'une alternative.
Commentaire pédagogique : Ces exercices sont difficiles de premier abord. Il convient d'avoir
travaillé auparavant en classe les notions de logique standard. Bien que ne figurant pas
explicitement au programme, les tables de vérité sont un bon outil pour manipuler ET, OU. On peut
les travailler à partir d'exemples mathématiques ou non...
Un exemple pour comprendre... Une table de vérité. A, B sont des propositions, C'est-à-dire des
« phrases logiques » qui ne peuvent avoir que deux valeurs de vérité : VRAI ou FAUX. Un des
principes fondamentaux est celui du « tiers-exclus », à savoir qu'une proposition ne peut pas être
vraie et fausse à la fois, alors que toute proposition est vraie ou bien fausse.
On peut résumer ceci dans un tableau illustrant les « connecteurs » logiques ET – OU.
A
B
F
F
F
V
V
F
V
V
A et B
A ou B
Ainsi, pour N entier, la proposition « N est pair » et « N est impair » sera toujours fausse, tandis que
la proposition « N est pair » ou « N est impair » est toujours vraie : on parle de tautologie.
Ces opérateurs logiques ET ; OU peuvent être aisément combinés avec les instructions
conditionnelles : SI...alors ; Tant que (condition) faire... pour créer des algorithmes plus complexes.
Exercice possible :
Vous avez droit aux instructions suivantes :
a) Les opérateurs logiques ET ; OU
b) L'instruction conditionnelle SI
c) L'instruction « être divisible par » (un entier)
d) lire (un entier)
e) écrire (une phrase)
Écrire un programme en pseudo-langage demandant à l'utilisateur d'entrer deux entiers. Si
ces deux entiers sont divisibles par 3 et par 5, écrire N est divisible par 15, sinon écrire N
n'est pas divisible par 15.
Fiche de synthèse
Les notions du cours
Définitions
1. Dans un programme, une variable correspond à un emplacement de la mémoire de la
calculatrice ou de l'ordinateur. Elle est repérée par un nom et contient une valeur.
2. La notion d'affectation (ou d'assignation) désigne l'opération par laquelle on établit un lien
entre le nom de la variable et sa valeur (son contenu). On l'a noté ici avec le symbole ←
3. L'entrée des données (ou lecture des données) est l'opération qui consiste à saisir des
valeurs pour qu'elles soient utilisées par le programme. On la note « Saisir valeur » ou « lire
valeur ». Remarque : une valeur peut être un nombre entier, un nombre réel, une chaîne de
caractères...
4. La sortie des résultats (ou écriture des résultats) permet d'afficher les valeurs des variables
après traitement. On note cette instruction « Afficher valeur » ou « écrire valeur »
La notion de boucle
Elle est utilisée lorsqu'une même suite d'instructions doit être répétée un certain nombre de fois. On
en rencontre essentiellement deux dans la pratique :
Initialisation des variables
Tant que condition faire
Bloc d'instructions
Pour i variant de 0 à N (ou de 1 à N) faire
Bloc d'instructions
Les instructions conditionnelles
Selon qu'une condition est vérifiée ou non, on effectuera un bloc d'instruction ou bien un autre. Par
exemple, un nombre entier est pair s'il est divisible par 2 et impair dans le cas contraire.
Si (condition vérifiée) faire
Bloc d'instructions n°1
Sinon faire
Bloc d'instruction n°2
Dans le cas où l'on dispose de plusieurs alternatives incompatibles les unes avec les autres, la
structure précédente est légèrement plus complexe. Par exemple :
Si (condition 1 vérifiée) faire
Bloc d'instructions 1
Sinon si (condition 2 vérifiée) faire
Blocs d'instructions 2
Sinon faire
Blocs d'instructions 3
CHAPITRE 3 : LE LANGAGE PYTHON
Objectifs et mise en œuvre
Jusqu'à présent, nous avons conçu des algorithmes, c'est-à-dire une suite d'instructions bien précises
pour résoudre un problème posé. Cependant un algorithme n'est pas un programme. Ce-dernier doit
être écrit dans un langage de programmation que l'ordinateur interprétera.
Je cite :
La programmation d'un ordinateur consiste à « expliquer » en détail à une machine ce qu'elle doit
faire. Un programme est une suite d'instructions, encodées en respectant de manière très
stricte un ensemble de conventions fixées à l'avance, qu'on appelle un langage informatique.
La machine est pourvue d'un mécanisme qui décode ces instructions en associant à chaque « mot »
du langage une instruction précise. Autrement dit, elle traduit les instructions que vous lui
fournissez à l'écran en « langage machine » : une longue suite de 0 et de 1, que l'on appelle le
langage binaire. Le système de traduction s'appelle interpréteur ou compilateur. Le langage de
programmation est un ensemble de mots clés, associé à un ensemble de règles très précises
indiquant comment on peut assembler ces « mots » pour former des « phrases » que l'interpréteur ou
le compilateur puisse traduire en langage machine. (Gérard Swinnen : apprendre à programmer avec
Python)
A l'issu des deux séances précédentes d'introduction à l'algorithmique, il est indispensable que les
élèves se confrontent à un langage de programmation ou du moins un avatar. Les notions vues
précédemment vont y trouver des applications innombrables, et la rigueur sera obligatoire, leur
créativité mise à l'épreuve. Il faudra en effet :
• repérer les données nécessaires à la résolution du problème (variables, données saisies au
clavier par l'utilisateur...)
• Créer un algorithme utilisant ces données pour apporter une solution au problème,
• Le transcrire en langage informatique.
Dans ces notes, un logiciel (libre) va être étudié : le langage Python. Comme d'autres logiciels, il a
ses particularités, ses forces et ses faiblesses pour l'enseignement du second degré. Sa puissance
tient à ses nombreuses possibilités, alliée à une simplicité de syntaxe remarquable.
1.
2.
3.
4.
5.
6.
7.
Prise en main du logiciel (séance 1)
Travail sur la notion de boucle (séances 2 et 3)
Travail sur la notion d'instruction conditionnelle (séance 4)
Travail avec des données du type chaîne de caractères et listes (séance 5)
Travail sur la notion de fonction (informatique)
Compléments utiles en pratique : les annexes.
Fiches de TP en lien avec les chapitres du programme de seconde
Certaines séances demandent du temps (2 à 3h ou plus).
Des énoncés de TP sont également proposés.
LE LANGAGE PYTHON
(version 3.1)
INITIATION AU LANGAGE PYTHON
séance n°1
L'environnement de travail
Python présente la particularité de pouvoir être utilisé de plusieurs manières différentes.
Vous allez d'abord l'utiliser en mode interactif, c'est-à-dire d'une manière telle que vous pourrez
dialoguer avec lui directement depuis le clavier. Cela vous permettra de découvrir très vite un
grand nombre de fonctionnalités du langage.
Dans un second temps, vous apprendrez comment créer vos premiers programmes (scripts)
et les sauvegarder sur disque dur ou sur clef USB. Si vous utilisez une interface graphique telle que
Windows, Gnome, WindowMaker ou KDE, vous préférerez vraisemblablement travailler dans une
« fenêtre de terminal », ou encore dans un environnement de travail spécialisé tel que IDLE. Voici
par exemple ce qui apparaît dans une fenêtre de Windows :
Les trois caractères « supérieur à » constituent le signal d'invite, ou prompt principal, lequel
vous indique que Python est prêt à exécuter une commande.
Calculer avec Python
Vous pouvez utiliser l'interpréteur comme une simple calculatrice de bureau. Testez par
exemple les commandes suivantes dans l'environnement IDLE :
>>> 15+3
>>> 2 - 17
# les espaces sont facultatifs
>>> 8 + 3 * 4
# la hiérarchie des opérations mathématiques
# est-elle respectée ?
>>> (8+3)*4
>>> 20 / 3
Comme vous pouvez le constater, les opérateurs arithmétiques pour l'addition, la soustraction, la
multiplication et la division sont respectivement +, -, * et /. Les parenthèses sont fonctionnelles.
Affectation-réaffectation
Nous avons vu en cours l'opération d'affectation, qui consiste à donner à une variable une valeur
(nombre entier, réel, chaîne de caractères, etc...).
En pseudo-langage, l'opération d'affectation a été symbolisée par le sigle "←"
Exemple : a←5
# J'affecte à la variable a la valeur 5
En langage Python l'opération d'affectation s'écrit « = ».
Testez par exemple les commandes suivantes :
>>> a=3
>>>a
>>>a+10
>>>a/2
Ne croyez pas que cette affectation soit définitive. On peut réaffecter à la variable « a » une
nouvelle valeur en réutilisant le symbole « = ».
>>>a
#Quelle est la valeur actuelle de a ?
>>>a=a+5
>>>a
#On réaffecte à a sa valeur précédente augmentée de 5
#Que vaut a maintenant ?
Remarque : le signe « = » utilisé ici n'a absolument aucun rapport avec l'égalité au sens
mathématique du terme.
Python a une convention :si ce que l'on écrit est vrai, il renverra true en réponse ; si c'est faux, il
renverra false.
Par exemple, testez les commandes suivantes (en vous souvenant bien de la dernière valeur affectée
à la variable a).
>>> a<1
>>>a>2
>>>a==8
#le sigle « == » est l'égalité classique, au sens mathématique usuel.
>>>a!=4
#le sigle « != » signifie « différent ».
Que va renvoyer l'instruction a>=4 ?
Synthèse partielle : Quelle différence fondamentale faîtes-vous entre l'écriture a=10 et a==10 ?
Typage des variables
La variable a que nous avons rencontrée jusqu'ici appartient à une seule catégorie : celle des entiers.
En anglais, cela se dit « Integer ».
Testez les commandes suivantes :
>>>a
>>>type(a)
#Quel est le résultat affiché ? Signification ?
>>>b=2.3
#Le séparateur décimal est le point, pas la virgule.
>>>type(b)
#Quel est le résultat affiché ? Signification ?
>>>c="Salut"
>>>type(c)
>>>d=[20,35,87,12]
>>>type(d)
>>>e=[5, "coucou",32.5,"Hugh"]
#Mélange de types dans un autre ?
>>>type(e)
Ces variables appartiennent à des types très différents. Nous verrons dans quelle mesure les utiliser
séparément, puis ensemble. Rappeler ces types :
Opérations sur les variables
Commençons par réaffecter à chacune des valeurs a,b c et d d'autres valeurs.
Testez les commandes suivantes:
>>>a=2
>>>b=5.5
>>>c="Hello "
>>>d="vous !"
#avec l'espace entre Hello et le guillemet de fin.
>>>a+b
>>>c+d
>>>print(c+d)
#Quelle différence remarquez-vous entre les deux commandes précédentes ?
>>>a+c
#On ne mélange pas les genres!
>>> a*2
>>>a**2
>>>a**3
>>>a**4
>>>a**5
Que signifie l'opération « ** » entre un nombre et un entier ?
>>>c*2
>>>c*3
Même question entre une chaîne de caractères et un entier non nul pour « * ».
Exercices :
1. Signalons au passage la disponibilité de l'opérateur modulo, représenté par le symbole %.
Cet opérateur fournit le reste de la division entière d'un nombre par un autre. Essayez par
exemple :
>>> 10 % 3
(et notez ce qui se passe !)
>>> 10 % 5
Cet opérateur vous sera très utile plus loin, notamment pour tester si un nombre a est
divisible par un nombre b. Il suffira en effet de vérifier que a % b donne un résultat égal à
zéro.
Vérifier à l'aide de la commande modulo si le nombre 33294 est divisible par 3 puis par 17.
2. Écrire un programme qui permet d'échanger la valeur de 2 nombres a et b indépendamment
des valeurs affectées à a et à b au départ.
Récapitulatif
A faire sur feuille, sans ordinateur
I) Affectation
Définition : La notion d'affectation (ou d'assignation) désigne l'opération par laquelle on établit
un lien entre le nom de la variable et sa valeur (son contenu). On l'a noté en langage usuel avec le
symbole ←
Question 1 : Comment se note-t-elle en Python ?
Question 2 : Comment fait-on pour affecter à une variable a la valeur 3 ?
Question 3 : Cette affectation est-elle définitive ? Comment fait-on pour lui ré-affecter une autre
valeur ?
Question 4 : Quelle est la signification du symbole « == » en Python ?
Question 5 : On écrit les lignes de commande suivantes. Quel résultat va renvoyer l'ordinateur ?
>>>a=5
>>>a
>>>a==3
>>>a==5
>>>a=18
>>>a<20
>>>a>10
>>>a=a+6
>>>a
>>>b=30
>>>b>a
>>>a+b
Question 6 : On écrit les lignes de commande suivantes. Quel résultat va renvoyer l'ordinateur ?
>>>a=10
>>>b="salut"
>>>a+b
Même question avec :
>>>a=10
>>>b= 5.2
>>>a+b
II) Typage des variables
Question 7 : Rappeler les différents types de variables rencontrés.
Question 8 :
a) Comment assigne-t-on à une variable a le type string ? (chaîne de caractères)
b) Que signifie l'opération concaténer deux chaînes de caractères ?
c) Que va renvoyer les commandes suivantes ?
>>>a="Bonjour "
>>>b="vous !"
>>>a+b
>>>print(a+b)
Question 9 : Que va renvoyer la commande suivante ?
>>> a="Oui "
>>>a*3
Question 10 : On admet que le premier élément d'une liste LIST se note LIST[0], le second
LIST[1], etc...
On se donne une liste par la commande suivante :
>>>LIST=[5,48,-57,"ABC",451.9,"soleil",-789]
Que va renvoyer les commandes suivantes ?
>>>LIST[0]
>>>LIST[2]
>>>LIST[5]
Pour un complément sur la notion d'affectation avec Python, se référer à la fiche : Plus sur
l'affectation.
INITIATION AU LANGAGE PYTHON
séance n°2
Objectifs : savoir écrire un script en Python et l'enregistrer pour une utilisation ultérieure.
Travailler la notion de boucle.
Consignes : La dernière fois, nous avons utilisé Python en mode interactif grâce à l'interface IDLE
(Python Gui). De cette manière, nous avons été en mesure d'apprécier « en direct » quelques outils
néanmoins fondamentaux : affectation d'une valeur à une variable, les différents types de variables :
int, float, string, list... Mais dès lors que nous fermons la fenêtre dans laquelle nous avons travaillé,
toutes les données sont irrémédiablement perdues.
Au cours de cette séance, vous allez apprendre comment écrire un script et l'enregistrer pour une
éventuelle ré-utilisation dans le futur.
Exercice 1 : votre premier programme
Remarque : Tout ce qui suit le signe dièse : # est considéré par Python comme un commentaire.
Cela n'apparaîtra pas dans le script final et n'est destiné qu'à votre intention ou à celle des lecteurs
du programme. Il sera ESSENTIEL que vous commentiez vos programmes. D'une cela facilite leur
compréhension, et de deux cela vous aidera à les reprendre plus tard si vous ne les avez pas terminé.
1. Rechercher le logiciel Python dans menu démarrer>programmes>Python 3.1>IDLE(Python
GUI)
2. Ouvrir une nouvelle fenêtre à l'aide de l'onglet file puis New window. Il apparaît une fenêtre
vierge attendant vos instructions.
3. Saisir alors exactement le texte ci-dessous. La mise en forme se fait automatiquement. En
particulier l'indentation du bloc d'instructions suivant while est ESSENTIELLE. Elle se
fera automatiquement sous IDLE.
4. TRES IMPORTANT : enregistrez ce fichier sur votre clef USB dans le dossier TP Python en
lui donnant le nom suivant : TP2_exercice1.py
(l'extension .py est capitale)
5. Vous allez compiler le programme en appuyant simultanément sur les touches Ctrl et F5.
6. Alors, que se passe-t-il ?
Exercice 2
En créant une nouvelle feuille vierge grâce à l'instruction file New Window, répondez au problème
suivant. Vous l'enregistrerez sous le nom : TP2_exercice2.py
Construire la figure suivante en utilisant l'instruction while (longueur d'un côté du quadrillage 50).
Quel nom porte cette figure ?
Quelques instructions pour obtenir les figures demandées.
from turtle import *
left(x)
right(x)
Permet d'importer les commandes pour les
tracés.
On efface tout et on recommence
Aller à l'endroit(x,y)
Avancer de la distance x
Reculer de la distance x
Relever le crayon (pour pouvoir avancer sans
dessiner).
Abaisser le crayon pour recommencer à
dessiner.
Tourner à gauche d'un angle en degrés égal à x.
Tourner à droite d'un angle en degrés égal à x.
sqrt(x)
racine carré de x (
reset()
goto(x,y)
forward(x)
backward(x)
up()
down()
Instructions en Python
while condition:
Bloc d'instructions
x
)
Commentaires
while signifie « tant que »
Les « : » sont indispensables pour dire « faire »
L'indentation après while est obligatoire.
Exercice 3
De même, après avoir écrit votre programme dans une nouvelle feuille vierge, enregistrez-le sur
votre clef USB sous le nom : TP2_exercice3.py.
En utilisant toujours l'instruction while, soit une fois soit deux fois, obtenir la figure suivante
(longueur d'un côté d'un petit carré : 50.
Cette figure devra être construite en une seule fois. On construira d'abord les côtés de
l'hexagone puis les trois diagonales.
Exercice 4
Écrire un programme dans une nouvelle feuille vierge calculant et affichant le résultat de
S = 591317...101105 .
Vous l'enregistrerez sur votre clef USB sous le nom : TP2_exercice4.py
La commande pour afficher une variable S est : print(S)
Récapitulatif
Écrire une boucle « Tant que » avec Python
Syntaxe en langage usuel
Tant que condition vérifiée faire
bloc d'instructions
Syntaxe en Python
while condition vérifiée :
bloc d'instructions
Remarques :
• Les : sont obligatoires après la condition associée à while.
• l'indentation du bloc d'instructions associé à while est obligatoire.
Utilisation du module turtle
Toute utilisation des outils graphique du module turtle nécessite qu'on l'ait « appelé » par la
commande : from turtle import * avant toute chose. On redonne les commandes usuelles pour
tracer des figures :
reset()
On efface tout et on recommence
goto(x,y)
Aller à l'endroit(x,y)
forward(x)
Avancer de la distance x
backward(x)
Reculer de la distance x
up()
Relever le crayon (pour pouvoir avancer sans
dessiner).
Abaisser le crayon pour recommencer à
dessiner.
Tourner à gauche d'un angle en degrés égal à x.
Tourner à droite d'un angle en degrés égal à x.
down()
left(x)
right(x)
INITIATION AU LANGAGE PYTHON
séance n°3
Objectifs : Travailler la notion de boucle sur des exemples plus poussés.
Consignes : on veillera dans cette séance à enregistrer soigneusement ses programmes pour une
utilisation ultérieure dans certains scripts.
Exercice 1
1. Rappeler dans l’encart de texte ci-dessous un script écrit en Python qui permet de dessiner
un carré de côté 10. Vous utiliserez une boucle while.
2.
En modifiant ce script, en écrire un autre qui trace une série de dix carrés de côté 10.
L’espace entre les carrés est de 10. Vous enregistrerez votre programme sous le nom :
TP3_exercice1.py
3. En modifiant le script précédent, en écrire un autre qui trace une série de quatre carrés dont
les côtés augmentent de 15 en 15. Le premier carré a un côté de 10 et l’espace entre chaque
carré est de 10. Vous l’enregistrerez sous le nom : TP3_exercice1bis.py
Exercice 2
Écrire un script en Python qui trace une série alternée de carrés et d’hexagones espacés de 30. Les
carrés comme les hexagones ont leurs côtés égaux à 20. Vous l'enregistrerez sous le nom
TP3_exercice2.py.
Exercice 3
Considérons une liste de nombres entiers ou flottants :
a=[20,3.5,44, 37, 151, 28,15.5]
Le premier élément de la liste se note a[0], le second a[1],etc...
Il existe une fonction prédéfinie en Python qui renvoie le nombre d'éléments d'une liste : c'est la
fonction len. Dans le cas présent, si l'on tape len(a), l'ordinateur affichera 7.
Écrire un script qui :
• part d'une liste de nombres entiers ou flottants, par exemple on prendra la liste précédente.
• En parcourant la liste, renvoie au final la somme des éléments qui la constitue. Vous
utiliserez une boucle while et la fonction len.
Vous enregistrerez votre programme sous le nom TP3_exercice3.py
Pour un complément sur la notion de saisie de données avec Python, se référer à la fiche : Plus sur
la saisie de données.
INITIATION AU LANGAGE PYTHON
séance n°4
Objectifs : Travailler la notion d'instruction conditionnelle.
Consignes : on enregistrera également tous les programmes réalisés au cours de la séance.
Écrire une instruction conditionnelle « Si...alors » avec Python
Syntaxe en langage usuel
Si condition vérifiée faire
Syntaxe en Python
if condition vérifiée:
bloc d'instructions
bloc d'instructions
Remarques :
• Les : sont obligatoires après la condition associée à if.
• l'indentation du bloc d'instructions associé à if est obligatoire.
Exercice 1
Écrivez un programme qui affiche les 20 premiers termes de la table de multiplication par 7, en
signalant au passage (à l'aide d'une astérisque) ceux qui sont des multiples de 3.
Exemple : 0 7 14 21* 28 35 42* 49
(penser à utiliser la commande modulo %)
Enregistrez votre programme sous le nom TP4_exercice1.py
Exercice 2
Écrivez un programme qui :
• demande à l'utilisateur de saisir une chaîne de caractères
• compte le nombre d'occurrences du caractère « g » dans cette chaîne.
Enregistrez votre programme sous le nom TP4_exercice2.py
Écrire une instruction conditionnelle « Si...alors...sinon » avec Python
Syntaxe en langage usuel
Si condition vérifiée faire
Syntaxe en Python
if condition vérifiée:
bloc d'instructions 1
Sinon faire
bloc d'instructions 2
bloc d'instructions 1
else:
bloc d'instructions 2
Remarques :
• Les : sont obligatoires après la condition associée à if ainsi qu'après else.
• l'indentation du bloc d'instructions associé à if est obligatoire ; même chose pour celui
associé à else.
• if et else sont indentés identiquement
Exercice 3
Écrire un programme qui demande à l'utilisateur de saisir un entier naturel N.
Si N est un multiple de 5, il sera affiché « multiple de 5 », sinon ce sera « pas multiple de 5 »
Enregistrez votre programme sous le nom TP4_exercice3.py
Exercice 4
Écrire un programme qui demande à l'utilisateur de saisir un entier naturel N.
Si N est pair, le programme dessinera un carré de côté 50, sinon il dessinera un triangle équilatéral
de côté 70.
Enregistrez votre programme sous le nom TP4_exercice4.py
Écrire une instruction conditionnelle « Si...Sinon si...sinon » avec Python
Syntaxe en langage usuel
Si (condition 1 vérifiée) faire
Syntaxe en Python
if (condition 1 vérifiée):
bloc d'instructions n°1
Sinon si (condition 2 vérifiée) faire
bloc d'instructions n°1
elif (condition 2 vérifiée):
bloc d'instructions n°2
…etc...
bloc d'instructions n°2
...etc...
Sinon si (condition N-1 vérifiée) faire
bloc d'instructions n° N-1
Sinon faire
bloc d'instruction n° N
elif (condition N-1 vérifiée):
bloc d'instructions n° N-1
else:
bloc d'instruction n°N
Remarques :
• elif signifie sinon si
• Les : sont obligatoires après la condition associée à if ainsi qu'après celles associées aux
elif et à else.
• l'indentation du bloc d'instructions associé à if est obligatoire ; même chose pour celui
associés aux elif et à else.
• if, elif et else sont indentés identiquement
• Toutes les conditions énoncées sont par construction incompatibles deux à deux.
Exercice 5
Lors d'un sondage, une personne interrogée a le choix entre trois réponses :
• satisfait
• moyennement satisfait
• pas satisfait
Écrire un programme qui demande à l'utilisateur son avis parmi ces trois propositions dans l'ordre
précité. Si la première réponse est donnée, il affichera "Merci ! Very Good" ; si c'est la seconde il
affichera "Ok ok" sinon il affichera "Snif ! "
INITIATION AU LANGAGE PYTHON
séance n°5
Objectifs : Travailler la notion de chaîne de caractères et de liste.
Consignes : on enregistrera également tous les programmes réalisés au cours de la séance.
Les chaînes de caractères (type string)
Sous Python, une donnée de type string est une suite quelconque de caractères (texte ou même
nombres) délimitée soit par des apostrophes (simple quotes), soit par des guillemets (double
quotes).
Exemples :
>>> phrase1='Voilà un écrit '
>>> phrase2='bien intéressant'
>>> print(phrase1,phrase2)
Voilà un écrit bien intéressant
A l'intérieur d'une chaîne de caractères, l'antislash « \ » permet d'insérer un certain nombre de codes
spéciaux (sauts à la ligne, apostrophes, guillemets, etc.). On ne donne que l'exemple des
apostrophes.
>>> phrase3='Comment s\'appelle-t-il ?'
# L'antislash est placé avant l'apostrophe
>>> print(phrase3)
Comment s'appelle-t-il ?
Python considère les chaînes de caractères comme une collection ordonnée d'éléments. Pour
accéder à un élément de la chaîne, on saisit le nom de la variable et on lui accole entre crochets le
numéro de l'élément considéré. Attention, la numérotation commence à zéro !
Exemples :
>>> mot='erg4ju6op'
>>> print(mot[0])
e
>>> print(mot[3])
4
Opérations sur les chaînes de caractères
1. La concaténation
Cette opération consiste à mettre bout à bout les éléments constitutifs de plusieurs chaînes de
caractères. Elle se symbolise à l'aide de l'opération +
Exemple :
>>> mot1='Mais c\'est '
>>> mot2='merveilleux !'
>>> print(mot1+mot2)
Mais c'est merveilleux !
>>> print(mot2+mot1)
merveilleux !Mais c'est
# on concatène mot1 et mot2
# L'ordre est important.
2. Déterminer la longueur d'une chaîne
Cette opération s'effectue grâce à la fonction len().
Exemple :
>>> mot="adseghbm55f"
>>> len(mot)
11
3. Convertir une chaîne de caractères en nombre
Exemple :
>>> nb1='54'
>>> nb1+5
Traceback (most recent call last):
File "<pyshell#27>", line 1, in <module>
nb+5
TypeError: Can't convert 'int' object to str implicitly
>>> int(nb1)+5
# on convertit la chaîne nb1 en entier grâce à la fonction int()
59
>>> nb2='20.36'
>>> float(nb2)+4
# on convertit la chaîne nb2 en flottant grâce à la fonction float()
24.36
Remarque : La chaîne qui ne contient aucun élément se note "" (rien entre les guillemets)
Exercice 1
Écrire un programme qui :
• demande à l'utilisateur de saisir une chaîne de caractères
• compte le nombre d'occurrences du caractère « a » dans cette chaîne.
• Si « a » n'apparaît pas, le programme le rajoute à la fin de la chaîne.
Enregistrez votre programme sous le nom TP5_exercice1.py
Exercice 2
Écrire un programme qui recopie une chaîne (dans une nouvelle variable) en l'inversant.
Ainsi par exemple, « bouchon » deviendra « nohcuob ».
Enregistrez votre programme sous le nom TP5_exercice2.py
Les listes d'éléments (type list)
Sous Python, on peut définir une liste comme une collection d'éléments (éventuellement de
types divers) séparés par des virgules, l'ensemble étant encadré par des crochets.
Exemple :
>>> maliste=['abc','hello',20,3.14,'coucou']
>>> print(maliste)
['abc', 'hello', 20, 3.14, 'coucou']
Remarque : Comme les chaînes de caractères, les éléments d'une liste sont numérotés en
commençant à zéro.
Exemple :
>>> maliste=['abc','hello',20,3.14,'coucou']
>>> maliste[0]
'abc'
>>> maliste[2]
20
A retenir : l'indice d'une liste de n éléments commence à 0 et se termine à n-1
Opérations sur les listes
1. Concaténation et duplication
Comme pour les chaînes de caractères, l'opérateur + sert pour concaténer des listes et * pour les
dupliquer.
Exemple :
>>> liste1=[325,'bonjour',65,69]
>>> liste2=['ha','gros',564]
>>> liste1+liste2
[325, 'bonjour', 65, 69, 'ha', 'gros', 564]
>>> liste2*3
['ha', 'gros', 564, 'ha', 'gros', 564, 'ha', 'gros', 564]
2. Ajouter ou supprimer un élément dans une liste
Python est un langage « orienté objet ». On dispose de méthodes spécifiques permettant d'effectuer
certaines actions sur des objets. Nous considérerons ici qu'une liste est un objet.
• Ajouter un élément à la fin d'une liste
Exemple :
>>> maliste=[201,45.8,12]
>>> maliste.append(35)
>>> maliste
[201, 45.8, 12, 35]
On a appliqué la méthode append() à l'objet maliste avec l'argument 35. La syntaxe est :
liste.append(objet)
• Ajouter un élément à l'intérieur d'une liste
Exemple :
>>> maliste=[201,45.8,12,35,89]
>>> maliste.insert(3,100)
>>> maliste
[201, 45.8, 12, 100, 35, 89]
La commande liste.insert(indice,objet) insère l'objet dans la liste avant l'indice précisé.
•
Supprimer un élément dans une liste
Cette opération s'effectue grâce à la commande del liste[indice]
Exemple :
>>> maliste=[55,201,89,33]
>>> del maliste[1]
>>> maliste
[55, 89, 33]
Remarque : la liste vide se note []. La méthode append() est particulièrement adaptée pour
construire une liste à partie d'une boucle.
La fonction len() renvoie également le nombre d'éléments d'une liste.
Exemple :
>>> maliste=[55,120,40,-8]
>>> len(maliste)
4
Exercice 3
Écrire un programme qui :
• demande à l'utilisateur de saisir une liste de nombres, par exemple [20,35,11,56,41,10].
• détermine le plus grand élément de cette liste,
• affiche cet élément.
Par exemple si l'utilisateur saisit [20,35,11,56,41,10] il s'affichera :
le plus grand élément de cette liste est 56
Enregistrez votre programme sous le nom TP5_exercice3.py
Exercice 4
Écrire un programme qui :
• demande à l'utilisateur de saisir deux listes,
• alterne les éléments de la première liste avec ceux de la seconde.
Par exemple si l'utilisateur saisit ['coucou','bonjour','ça va ?'] et ['Charles','Edouard','Au poil !'], il
s'affichera : ['coucou','Charles','bonjour','Edouard','ça va ?','Au poil !']
Enregistrez votre programme sous le nom TP5_exercice4.py
INITIATION AU LANGAGE PYTHON
séance n°6
Objectifs : Initiation à la notion de fonction.
Motivation : De même qu'un organisme vivant (donc une structure biologiquement complexe) est
constitué d'un assemblage de nombreuses cellules, un programme « compliqué » se structure en un
assemblage de plus petits sous-programmes, chacun ayant un rôle bien défini. Nous allons
découvrir au cours de cette séance, comment créer ces petits sous-programmes et les utiliser pour en
construire un autre plus compliqué.
L'utilité de ces sous-programmes, que l'on appellera fonctions est primordiale lorsque l'on veut
réaliser plusieurs fois la même opération au sein d'un même programme.
La syntaxe Python pour définir une fonction est la suivante :
def nom_de_la_fonction(liste de paramètres):
Blocs d'instructions
• Vous pouvez choisir n'importe quel nom pour la fonction que vous créez, à l'exception des mots
réservés du langage, et à la condition de n'utiliser aucun caractère spécial ou accentué (le
caractère souligné « _ » est permis).
• Comme les instructions if et while que vous connaissez déjà, l'instruction def est une instruction
composée. La ligne contenant cette instruction se termine obligatoirement par un double point,
lequel introduit un bloc d'instructions que vous ne devez pas oublier d'indenter.
• La liste de paramètres spécifie quelles informations il faudra fournir en guise d'arguments
lorsque l'on voudra utiliser cette fonction (Les parenthèses peuvent parfaitement rester vides si la
fonction ne nécessite pas d'arguments). (Gérard Swinnen. Programmer avec Python)
Tout en suivant les instructions, vous répondrez sur cette feuille aux questions posées au cours
des exercices.
Exercice 1
Pour le moment nous allons utiliser Python en mode interactif. Ouvrez un fichier vierge via : menu
démarrer>tous les programmes>Python 3.1>IDLE (Python GUI). Recopiez ensuite le script cidessous et tapez deux fois entrée. Le prompt de commande >>> apparaît. Écrire alors table5()
>>> def table5():
i=0
while i<11:
print("5 *",i," = ",5*i)
i=i+1
# Pas de paramètres en argument ici
# Remarquez l'indentation du bloc d'instructions de def
# Remarquez l'indentation du bloc d'instructions de while
>>> table5()
# Que s'affiche-t-il à l'écran ?
Analyse :
• L'intérieur des parenthèses est vide. Dans cette fonction, nous n'avons utilisé aucun
paramètre, c'est-à-dire que l'utilisateur ne se donne pas le choix de faire varier par exemple
le choix de la table : 5 est fixé.
• Bien remarquer l'indentation après l'instruction def suivie de deux points. Elle est
obligatoire.
Exercice 2
On aimerait pouvoir écrire n'importe quelle table d'entiers. Encore faut-il le choisir ! Pour cela, on
mettra celui-ci en paramètre. A la suite de ce que vous avez saisi précédemment, écrire le script cidessous :
>>> def table_d_entiers(n):
i=0
while i<11:
print(n," * ",i," = ",n*i)
i=i+1
Appuyez deux fois sur la touche Entrée. Le prompt de commande >>> réapparait.
Saisir :
>>>table_d_entiers(4)
# Que s'affiche-t-il à l'écran ?
Saisir :
>>>table_d_entiers(8)
# Que s'affiche-t-il à l'écran ?
Analyse :
• Le fait d'avoir mis un entier n en paramètre (à l'intérieur des parenthèses) permet d'afficher
la table de multiplication de l'entier n. Il suffit de remplacer n par la valeur choisie en
appelant la fonction.
• On aimerait néanmoins demander à l'utilisateur de saisir n à l'écran pour qu'ensuite la
fonction soit appelée et affiche la table de multiplication de n. On séparera donc en deux la
construction de la fonction et le programme principal.
Exercice 3
A partir de la fenêtre présentement ouverte, ouvrir une fenêtre vierge via file>New Window.
Saisir ensuite le script qui suit :
def table_d_entiers(n):
i=0
while i<11:
print(n," * ",i," = ",n*i)
i=i+1
# programme principal
n=int(input("Saisissez un entier "))
table_d_entiers(n)
# Construction de la fonction
1. Enregistrez ce programme sous le nom : TP6_exercice3.py
2. Appuyez sur Ctrl + F5 simultanément pour le faire fonctionner. Vous choisirez n'importe
quelle valeur de n pour le tester.
Remarque : Tout programme en Python un peu complexe prendra nécessairement la forme
suivante :
Liste de fonctions
# il peut n'y en avoir qu'une
Programme principal
# on utilise les fonctions précédentes
Exercice 4
Ouvrir une autre fenêtre vierge via file>New Window
1. Écrire une fonction carre(taille) permettant de dessiner un carré de côté taille.
2. Écrire le programme principal à la suite. Celui-ci :
a) demandera à l'utilisateur de saisir la taille du côté d'un carré
b) dessinera 5 carrés de la taille choisie, l'espace entre les carrés étant de 10.
3. Enregistrez le programme sous le nom TP6_exercice4.py
4. Le tester en appuyant sur Ctrl+F5 simultanément.
Exercice 5
Ouvrir une autre fenêtre vierge via file>New Window
1. Copier le script de la fonction carré précédente.
2. Écrire le programme principal à la suite. Celui-ci :
a) demandera à l'utilisateur de saisir la taille du côté du carré initial.
b) construira une suite de 4 carrés dont les côtés s'accroissent de 15 à chaque fois.
c) sera tel que l'espace entre les carrés est de 10.
3. Vous enregistrez ce programme sous le nom TP6_exercice5.py et le testerez.
Exercice 6
Écrire un programme utilisant deux fonctions carre(taille) et hexagone(taille) permettant de dessiner
le motif suivant. Les carrés comme les hexagones ont leur côtés égaux à 20 et l'espace entre chaque
figure est de 30. Vous l'enregistrerez sous le nom TP6_exercice6.py et le testerez.
Exercice 7
En créant deux fonctions pentagone et triangle, écrire un programme qui dessine une alternance
pentagone (de côté 15, de couleur bleue) et triangle équilatéral (sommet vers le bas, de côté 25, de
couleur rouge) 5 fois de suite. L'espacement entre la base d'un pentagone et d'un triangle est de 20.
On partira du point de coordonnées (-100,0). Vous l'enregistrerez sous le nom TP6_exercice7.py et
le testerez.
Liste de couleurs : 'blue','red','green','yellow','pink',etc...
Pour affecter une couleur à une ligne la commande est : color(couleur)
Remarque : Les exercices 4, 5 et 6 ont déjà été traités avant. Quelle différence notez-vous ?
Pour un complément sur la notion de fonction avec Python, se référer à la fiche : Plus sur la
notion de fonction
Fiches de complément Python
PLUS SUR LA NOTION D'AFFECTATION
L'affectation
Dans le langage de programmation Python, on dispose de l'opération d'affectation symbolisée par le
signe « égale » : =
Par exemple, analysez les séquences d'instructions suivantes :
1. L'affectation simple
>>> a = 3
>>> b = 4
# J'affecte à la variable a la valeur 3
# J'affecte à la variable b la valeur 4
2. L'affectation parallèle
>>> a,b = 3,4
# J'affecte simultanément à a la valeur 3 et à b la valeur 4
Ici, la ligne de code ci-dessus parvient exactement au même résultat que les 2 lignes de codes
précédentes.
♦♦♦ ATTENTION ! Il convient cependant de bien comprendre comment fonctionne l'affectation
parallèle par rapport à l'affectation simple.
Exercice résolu : on souhaite échanger les valeurs de 2 variables a et b.
• Résolution avec l'affectation simple
>>> a = 3
>>> b = 4
# Fausse bonne idée : échanger directement les valeurs de a et b
>>> a = b
# a prend la valeur 4
>>> b = a
# La valeur 4 étant à présent affectée à la variable a, b la prend aussi !
# Au final, a et b valent 4
# On va avoir besoin d'une variable supplémentaire pour stocker
la valeur initiale de a. Corrigeons-donc notre script...
>>> a = 3
>>> b = 4
>>> c= a
# J'affecte à c la valeur initiale de a, ç'est-à-dire 3
>>> a = b
# a prend la valeur de b, ç'est-à-dire 4
>>> b = c
# b prend la valeur de c, ç'est-à-dire la valeur initiale de a : 3
• Résolution avec l'affectation parallèle
>>> a,b= 3,4
# J'affecte simultanément à a la valeur 3 et à b la valeur 4
>>> a,b = b,a
#ET LA, GROSSE DIFFERENCE : les expressions de la partie
droite sont d'abord toutes évaluées avant qu'aucune affectation
ne se fasse. Comme b vaut 3 et a vaut 4, le tour est joué !
Exercice
Quelles valeurs vont être affectées à a et à b au final après les lignes de codes suivantes ?
>>> a,b = 6,10
>>> a,b= 6,10
>>> a = b
OU
>>> a,b = b, a - b
>>> b = a – b
On a aussi la notion d'affectation multiple. Exemple a=b=5
On affecte à a et b la valeur 5
PLUS SUR LA SAISIE DE DONNEES
La commande input()
Dans le langage de programmation Python, on dispose de la fonction prédéfinie input() qui permet à
l'utilisateur de saisir des données à l'écran.
Par exemple testez :
>>> a=input()
3
>>> a
'3'
>>> type(a)
<class 'str'>
>>> a=int(input())
3
>>> a
3
>>> type(a)
<class 'int'>
# l'ordinateur attend la saisie de l'utilisateur.
# Attention même si c'est un entier qui est saisi, a est du type « string »
# Comment le convertir en entier ?
La commande input() permet aussi d'afficher du texte. Il suffit d'écrire entre guillemets ou simple
quotes le message à l'intérieur des parenthèses.
Exemple :
>>> a=input("Saisissez un nombre décimal ")
Saisissez un nombre décimal
# l'ordinateur attend la saisie de l'utilisateur
# Si l'on veut que a soit du type float, on doit composer deux instructions.
# On modifie la ligne précédente par :
>>> a=float(input("Saisissez un nombre décimal "))
Saisissez un nombre décimal 20.6
# je saisis 20.6 par exemple
>>> type(a)
<class 'float'>
# La variable a a été convertie en flottant
On retiendra : la commande a=input() permet d'affecter à la variable a ce qui est saisi par
l'utilisateur à l'écran. ATTENTION ! On gardera à l'esprit que a est du type string. Si l'on souhaite
travailler avec des nombres ou des listes, il faudra convertir a en composant une instruction
adéquate avec la commande input().
PLUS SUR LA NOTION DE FONCTION
Comment retourner une valeur ?
Lorsqu'une fonction est destinée à renvoyer une valeur, on utilise l'instruction return(argument)
Exercice 1
Dans une fenêtre vierge, recopier le script suivant :
def puissance3(x)
return(x**3)
Puis testez ce programme en l'enregistrant sous le nom : TP_fonctions_calcul1.py . Appuyez ensuite
sur Ctrl+F5. Testez:
1. puissance3(2)
2. puissance3(10)
Exercice 2
On souhaite dans cet exercice calculer le volume d'un parallélépipède rectangle. Écrire une fonction
volume dépendant de trois paramètres qui renvoie le volume d'un tel parallélépipède. Testez-la
ensuite sur quelques exemples. Vous enregistrerez ce programme sous le nom :
TP_fonctions_calcul2.py
Variables locales et globales
Lorsque l'on définit une fonction, il est nécessaire de connaître la portée des variables.
Exemple : Définissons une fonction en mode interactif sous IDLE.
>>> def fonction1():
x=3
print("Dans cette fonction x est égal à ",x)
>>> fonction1()
Dans cette fonction x est égal à 3
>>> x
# message d'erreur
Traceback (most recent call last):
File "<pyshell#14>", line 1, in <module>
x
NameError: name 'x' is not defined
Remarque : la variable x n'existe pas en dehors de la fonction où elle a été définie.
On dit que x est une une variable locale.
Par contre, une valeur déclarée à la racine du module principal est visible partout.
Exemple :
>>> def fonction2():
print(x)
>>> x=4
>>> fonction2()
4
>>> x=5
>>> fonction2()
5
On dit que x est une variable globale. Cette variable est visible dans tout le module.
††† ATTENTION aux types modifiables comme les listes †††
>>> liste=[1,2,3]
>>> def change_liste():
liste[1]=-15
>>> change_liste()
>>> liste
[1, -15, 3]
# liste est une variable globale
# liste a été modifiée par la fonction change_liste()
De la même manière, en passant une liste en arguments, elle est tout autant modifiable !
>>> liste=[1,2,3]
>>> def change_liste2(x):
x[1]=-20
>>> change_liste2(liste)
>>> liste
[1, -20, 3]
# x est passé en argument
# liste a été modifiée par la fonction change_liste2()
La règle LGI
Nous avons vu au paragraphe précédent les notions de variables locales ou globales. Il existe aussi
un troisième type de variables : les variables internes. Exemple : la fonction len() qui renvoie la
taille d'une liste ou d'une chaîne de caractères et qui existe dès qu'on lance Python.
Python traite les variables par ordre de priorité :
1. D'abord, il regarde si la variable considérée est une variable locale,
2. Ensuite, si elle n'existe pas localement, il regarde si c'est une variable globale,
3. Enfin, il regarde si c'est une variable interne.
Exemple :
>>> def fonction():
x=10
print('Dans la fonction x vaut ',x)
>>> x=20
>>> fonction()
Dans la fonction x vaut 10
>>>print('Dans le module principal x vaut ',x)
Dans le module principal x vaut 20
# x est une variable locale
# x est une variable globale
Remarque : Notez bien ce qui s'est passé. x a pris en priorité la valeur qui lui était définie
localement par rapport à celle qui lui était définie globalement.
Il est possible de forcer une variable à prendre sa valeur globale dans une fonction avec le mot clé :
global
Exemple :
>>> def double():
global x
x=x*2
>>> x=3
>>> double()
>>> x
6
Remarque : cette notion a son importance lorsque dans une fonction qui renvoie une ou plusieurs
valeurs, on souhaite que ces dernières servent dans le programme principal. On doit donc les
déclarer en tant que variables globales.
Exemple : On souhaite subdiviser un intervalle [a ; b] en n sous-intervalles égaux. On accepte le
chevauchement aux points de subdivision.
def subdivision(a,b,n):
global subdi
subdi=[]
i,c=0,0
while i<=n:
c=a+i*(b-a)/n
subdi.append(c)
i=i+1
# la variable subdi est déclarée comme globale
# on initialise subdi par la liste vide
# on construit les points de la subdivision
return subdi
# programme principal
a=float(input("Entrer la borne inférieure de l\'intervalle "))
b=float(input("Entrer la borne supérieure de l\'intervalle "))
n=int(input(" Entrer le nombre d\'intervalles n de la subdivision "))
subdivision(a,b,n)
print (subdi)
# on compile le programme avec Ctrl+F5
Entrer la borne inférieure de l'intervalle 2
Entrer la borne supérieure de l'intervalle 10
Entrer le nombre d'intervalles n de la subdivision 20
[2.0, 2.4, 2.8, 3.2, 3.6, 4.0, 4.4, 4.8, 5.2, 5.6, 6.0, 6.4, 6.8, 7.2, 7.6, 8.0, 8.4, 8.8, 9.2, 9.6, 10.0]
LA RECURSIVITE
Définition : Un algorithme est dit récursif s'il s'appelle lui-même.
Reprenons l'exemple de la factorielle vu en classe. On rappelle que :
• n doit être un entier naturel.
1. Si n=0, on a n! = 1
ie 0! = 1
2. Si n est supérieur ou égal à 1, on a n !=1×2×3×...×n .
n! se lit « factorielle n »
Écrire une fonction factorielle(n) qui renvoie la factorielle d'un entier naturel choisi par l'utilisateur.
Quel lien existe-t-il entre n ! et n−1 ! ?
Ce lien nous suggère l'algorithme récursif suivant, où la fonction factorielle va s'appeler elle-même.
def factorielle(n):
if n = = 0:
return 1
else:
return n * factorielle(n-1)
# la fonction factorielle est appelée à l'intérieur d'elle
même.
Essayez de comprendre ce qui se passe. Schématisez-le pour n=2.
Exercice : on pose u 0 = 2 et pour tout entier naturel n non nul, u n = 3 u n−18 . Créer une
fonction suite(n) en utilisant un algorithme récursif capable de calculer n'importe quelle valeur
un .
Test avec un tableur :
Calcul des 20 premiers termes
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
A
n
0
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
B
u_n
2
14
50
158
482
1454
4370
13118
39362
118094
354290
1062878
3188642
9565934
28697810
86093438
258280322
774840974
2324522930
6973568798
20920706402
Utilisation du logiciel Python :
def suite(n):
if n==0:
return 2
else:
return 3*suite(n-1)+8
# programme principal
a=0
while a<=20:
print suite(a)
a=a+1
On compile ensuite ce code.
Formule dans B3 :
Résultat à l'écran
>>>
2
14
50
158
482
1454
4370
13118
39362
118094
354290
1062878
3188642
9565934
28697810
86093438
258280322
774840974
2324522930
6973568798
20920706402
>>>
=3*B2+8
Fiches de TP en seconde GT
TP GEOMETRIE N°1
DISTANCE ET COORDONNEES
Question 1 : Écrire un programme qui étant donné les coordonnées x A et y A d'un point A,
puis x B et y B d'un point B, renvoie les coordonnées du point I, milieu du segment [AB].
Sous Python vous créerez une fonction milieu(x_A,x_B,y_A,y_B)
Question 2 : Écrire un programme qui étant donné les coordonnées
puis x B et y B d'un point B, renvoie la distance AB.
xA
et
yA
d'un point A,
Sous Python la fonction racine carrée se note sqrt() : sqrt(x) est la racine carrée d'un réel positif x.
Vous créerez une fonction distance(x_A,x_B,y_A,y_B).
Question 3 : Soit C le cercle de diamètre [AB]. Dans un repère orthonormé on se donne A(-2 ;2) et
B(3 ; -5). On cherche à savoir si un point M(x ; y) appartient ou non au cercle C.
1. Écrire un programme utilisant les deux fonctions précédentes qui réponde à la question.
−3  65
2. Le tester avec M( 1; 14) puis M 2 ;
2


Rappels mathématiques :
A x A ; y A  et B  x B ; y B  alors I milieu de [AB] a pour coordonnées
x x
y  yB
.
I A B ; A
2
2
2. Dans un repère orthonormé O ; i ; j , si A x A ; y A  et B  x B ; y B  , alors
AB =  x B −x A 2  y B− y A 2
1. Si


PS : Vous pouvez répondre à toutes les questions sans utiliser la notion de fonction. La
question 3 sera alors plus longue à programmer.
TP GEOMETRIE N°2
VECTEURS ET PARALLELOGRAMME
Question 1 : On considère un repère O ; i ; j . On se donne deux points A, B repérés par
leurs coordonnées.
Écrire un programme qui étant donné les coordonnées x A et y A d'un point A, puis x B et
y B d'un point B, renvoie celles du vecteur 
AB sous la forme d'une liste.
Sous Python vous pouvez créer une fonction vecteur(x_A,x_B,y_A,y_B)
Question 2 : On se donne quatre points distincts du plan A, B, C et D repérés par leurs coordonnées.
1. Écrire un programme qui étant donné les coordonnées des points A,B,C et D affiche si le
quadrilatère ABCD est un parallélogramme.
2. Écrire un programme qui étant donné les coordonnées des points A,B,C et D affiche si le
quadrilatère ABCD est un trapèze.
Vous pourrez vous servir de la fonction créée à la question 1.
Les tester avec A(-1 ; 2), B (3 ; 4), C(1 ; 5) et D(9 ; 7)
Question 3 : On se donne trois points du plan A,B et C repérés par leurs coordonnées.
Écrire un programme qui étant donné les coordonnées des points A,B,C détermine les coordonnées
 x D ; y D  du point D tel que ABCD soit un parallélogramme.
Rappels mathématiques :
AB  x B −x A ; y B − y A  .
1. Si A x A ; y A  et B  x B ; y B  alors 
2. ABCD est un parallélogramme si et seulement si 
AB = 
DC
3. ABCD est un trapèze si et seulement si les vecteurs 
AB et 
DC sont colinéaires.
TP FONCTION N°1
TRACE D'UNE COURBE
Comment créer un graphique avec Python ?
Il faut d'abord importer les modules matplotlib et numpy associés à votre distribution de Python et
à votre système d'exploitation. Vous pouvez les trouver à l'adresse suivante : http://www.python.org
1 3 2
x − x 1 .
6
Le module matplotlib a tous les outils graphiques utiles pour les tracés de fonctions.
Le module numpy possède quant à lui plein de fonctions prédéfinies.
Exemple : on souhaite tracer la fonction f définie sur [-4 ; 5] par
f x =
Ouvrez une fenêtre via démarrer>tous les programmes>python 3.1>IDLE (Python Gui)
Testez ensuite les commandes suivantes :
>>> import matplotlib.pyplot as plt
>>> import numpy as np
>>> x=np.linspace(-4,5,100)
# la courbe est tracée à partir de 100 points
>>> plt.plot(x,x**3/6-x**2+1)
[<matplotlib.lines.Line2D object at 0x03AD2D10>]
>>> plt.show()
Remarque : le curseur de la souris indique les coordonnées du point.
Après avoir importé les modules matplotlib et numpy comme dans l'exemple précédent :
Commandes
signification
np.linspace(a,b,N)
On crée une matrice ligne de N valeurs
régulièrement espacées entre a et b.
plt.plot(x,f(x))
plt.show()
plt.clf()
plt.axis([xmin,xmax,ymin,ymax])
plt.savefig()
plt.grid(True ou False)
Tracer la fonction f de variable x
Afficher le graphique
Efface la fenêtre graphique
Spécifie un rectangle de représentation
Sauvegarde le graphique en format PNG
Affiche une grille en pointillés
Exercice :
1. Tracer dans une fenêtre graphique la courbe représentative C de la fonction f définie sur
[−4 ; 8] par f  x  = x 2−3 x −10 . On affichera une grille.
2. Résoudre graphiquement l'équation f  x  = 0 .
3. Sur le même graphique, tracer la droite d'équation y = 12 .
4. a) Trouver les antécédents de 12 par f.
b) Résoudre graphiquement l'inéquation f  x 12 .
5. a) Tracer la droite d'équation y = −10
b) Trouver les coordonnées du sommet S de C.
PS : tracer d'abord tous les graphiques : C et les deux droites avant d'utiliser l'instruction plt.show()
Remarquer aussi que x 0 = 1 pour le tracé des droites horizontales.
TP PROBAS-STATS
Question 1 : Écrire un programme qui demande à un utilisateur de saisir N notes entre 0 et 20 (N
choisi par l'utilisateur) sous la forme d'une liste et N nombres entre 1 et 3 (les coefficients de ces
notes), puis qui renvoie la moyenne pondérée de ces N notes.
Question 2 : On considère un dé à 6 faces parfait et 3 urnes numérotées de 1 à 3.
L'urne 1 contient 3 boules blanches, 4 boules noires et 3 boules vertes.
L'urne 2 contient 2 boules blanches, 2 boules noires et 6 boules vertes.
L'urne 3 contient 4 boules blanches, 4 boules noires et 2 boules vertes.
Toutes ces boules sont indiscernables au toucher.
On considère l'expérience aléatoire qui consiste à lancer d'abord le dé puis :
• Si le numéro est 1 ou 2, on tire une boule dans l'urne n°1
• Si le numéro est 3, 4 ou 5 on tire une boule dans l'urne n°2
• Sinon, on tire une boule dans l'urne n°3.
1. Modéliser cette situation à l'aide d'un arbre de probabilité. On pourra prendre comme
événements : « U_1 » : obtenir 1 ou 2 ; « U_2 » : obtenir 3,4 ou 5 ; « U_3 » : obtenir 6, puis
« B » : tirer une boule blanche ; « N » : tirer une boule noire et « V » : tirer une boule verte.
2. Écrire un algorithme modélisant le lancer du dé, suivi du tirage d'une boule dans l'une des 3
urnes et le programmer sous Python.
3. Faire tourner le programme n fois (n choisi par l'utilisateur) et relever la fréquence
d'apparition d'une boule blanche, d'une boule noire et d'une boule verte. On testera avec
n=50, 100 et 1000.
4. Compléter le tableau donné en annexe avec n=50000
5. Calculer p(B), p(N) et p(V) et comparer avec les résultats trouvés à la question précédente.
Remarque : Pour simuler le tirage au sort d'un entier aléatoire entre 1 et N, on importe la fonction
randint de la bibliothèque random via la commande from random import randint ; randint(a,b)
renvoie un entier aléatoire entre a et b. L'instruction break sert à sortir d'une boucle.
Indication : On pourra numéroter les boules de chaque urne pour modéliser le tirage dans les urnes ;
par exemple dans l'urne 1 on notera : 1,2,3 pour les boules blanches ; 4, 5, 6, 7 pour les boules
noires et 8, 9, 10 pour les boules vertes.
Fréquence
Expérience n°
fB
f
N
1
2
3
4
5
Moyenne des
fréquences
fB
est la fréquence d'apparition d'une boule blanche, etc...
fV
TP EQUATIONS DE DROITE
Rappels mathématiques : Une équation de droite s'écrit sous la forme x=c (droite verticale) ou
sous la forme y=m x p (équation réduite d'une droite non verticale).
Le réel s'appelle m est appelé coefficient directeur et p ordonnée à l'origine.
Deux droites parallèles (et non verticales) ont le même coefficient directeur. Réciproquement, si
deux droites ont le même coefficient directeur, elles sont parallèles (au sens large).
Question 1 : Écrire une fonction estverticale(x_A,y_A,x_B,y_B) qui étant donné deux points
A x A ; y A  et B  x B ; y B  détermine si la droite (AB) est verticale ou pas. La valeur
renvoyée par cette fonction sera un booléen : True pour vertical et False dans le cas contraire.
Question 2 : Dans le cas où la droite (AB) ne soit pas verticale, écrire une fonction
equation(x_A,y_A,x_B,y_B) qui :
• calcule le coefficient directeur m
• calcule l'ordonnée à l'origine p
• affiche le résultat sous la forme : "La droite (AB) a pour équation y = ",m,"x+",p
On stockera le couple (m,p) dans une liste.
Question 3 : Écrire un programme qui détermine si les droites (AB) et (CD) sont parallèles ou pas.
Le cas où ces deux droites sont verticales sera considéré.
Seconde B 2009-2010
le 10/12/2009
Devoir de programmation
Exercice 1 ( A TTENTION, à faire sans l'ordinateur !)
Écrire dans la zone de texte adjacente le résultat affiché à l'écran par l'ordinateur pour chacun des
programmes suivants :
N°1
i,S=1,0
while i<6:
S=S+i
i=i+1
N°2
from turtle import *
forward(50)
left(90)
forward(30)
goto(0,0)
N°3
i=1
while i<5:
if i%2 = = 0:
print 3*i
else:
print i
N°4
N=4
a=7
if N<a:
print « Eh »
else:
print « Oh »
N°5
a,b=3,4
a=b
b=a
print a,b
Exercice 2
Ecrire un script utilisant la fonction while permettant de calculer
S = 12 22 ...102
Exercice 3
A l'aide du mode turtle, écrire un script permettant d'obtenir la figure ci-dessous. Cette figure devra
être construite en une seule fois. On construira d'abord les côtés de l'hexagone (de longueur 50)
puis les trois diagonales. Indication : la fonction while sera utilisée 2 fois.
CHAPITRE 4 : PROJETS EN SECONDE GT
Objectifs et mise en œuvre
La liste de projets qui suit a été effectivement proposée en classe de seconde générale pendant
l'année 2009-2010.
Des groupes de trois élèves ont été constitués à cet effet et la durée de recherche a été de l'ordre d'un
mois et demi environ. Ils disposaient de Python chez eux et l'accès à une salle informatique en
semaine pour les internes (la grande majorité). Les sujets ont été distribués mi mars 2010 et résolus
sous la forme d'un rapport écrit suivi d'une soutenance orale et sur machine en mai de la même
année.
L'expérience fut enrichissante, tant pour les élèves que pour le professeur, de par les interrogations
qui n'ont pas manqué de se poser, la relative liberté de création jusqu'à l'apprentissage du travail
collectif. Une heure par semaine était consacrée en classe à la recherche des activités proposées.
Certains projets étaient ardus et ont nécessité beaucoup de travail de fond, ce qui m'a permis
également d'éclaircir certains points. Bien entendu, les élèves qui en ont hérité ont reçu une aide
plus poussée.
PROJET n°1
Le but de ce projet est de construire une suite d'étoiles à 5 branches de tailles
variées. Le choix de la taille de chaque branche et de l'espacement entre chaque
étoile est de votre choix.
Vous commencerez d'abord par créer une fonction étoile avec pour variable la
taille, que vous utiliserez dans votre script principal.
Indication : pour construire l'étoile à 5 branches, imaginez-là inscrite dans un
ABC .
pentagone régulier. Vous pourrez calculer l'angle 
PROJET n°2
Le but de ce projet est de trouver un nombre mystère choisi par l'ordinateur en
un nombre limité d'essais.
Comme pour l'utilisation du mode Turtle pour effectuer des dessins, il faudra
demander à l'ordinateur d'appeler une bibliothèque gérant tout ce qui concerne
la simulation du hasard. On écrira donc :
from random import *
On aura également besoin de la fonction prédéfinie randint(a,b). Cette fonction
permet à l'ordinateur de choisir un entier aléatoire (donc non connu de vous a
priori) entre les entiers a et b.
Vous écrirez un programme qui demande à l'ordinateur de choisir un entier
aléatoire N entre 1 et 100 et proposant à l'utilisateur de le deviner.
L'utilisateur aura alors cinq essais maximum pour réussir.
Si au cours de ces essais le nombre saisi par l'utilisateur est plus petit que N, il
apparaîtra à l'écran : « plus grand » ; s'il est plus grand, il apparaîtra à l'écran :
« plus petit ». Si l'utilisateur le trouve avant les 5 essais, il apparaîtra : « gagné
en (nombre d'essais utilisés) ». Si l'utilisateur ne l'a pas trouvé avant les 5
essais réglementaires, il apparaîtra : « perdu ». On affichera alors le nombre
mystère qu'il fallait trouver.
PS : Ce n'est pas nécessaire pour ce programme, mais cela peut être utilisé : la
fonction prédéfinie break permet de sortir d'une boucle.
PROJET n°3
Le but de ce projet est de construire une « spirale » de 8 triangles équilatéraux
de tailles toutes différentes choisies par vous. L'espacement entre les bases des
triangles sera de 20 au départ et ira en s'accroissant de 50 en 50 ; de même la
taille des côtés des triangles ira en augmentant de 10 en 10. Et important, tous
les côtés des triangles seront respectivement parallèles deux à deux.
Vous créerez d'abord une fonction triangle(taille).
Pour le script principal, vous utiliserez une boucle while permettant de
placer les triangles aux bons emplacements.
Le dessin obtenu devra ressembler à ceci : j'ai pris 15 pour côté du premier
triangle et je suis parti du point de coordonnées (80,-60).
Indication : on pourra créer les variables abscisse et ordonnee indiquant
l'emplacement exact du point de départ des triangles à construire. .On utilisera
aussi la commande goto(... ; ...) pour se déplacer à l'endroit voulu.
PROJET n°4
Le but de ce projet est de résoudre le problème suivant :
On demande à l'utilisateur de choisir un entier compris entre 1 et 3999.
L'ordinateur le convertit ensuite en nombres romains.
Rappel : En nombres romains, on a :
I : un
II : deux III : trois IV : quatre
VII : sept
VIII : huit
IX : neuf
L : cinquante
C : cent
D : 500
M : mille
V : cinq
X : dix
VI:six
Vous chercherez sur Internet le principe d'écriture d'un nombre en nombre
romain. Testez-le ensuite sur quelques exemples :
Convertir en nombres romains :
• 2397
• 3912
• 3812
PROJET n°5
Le but de ce projet est de résoudre le problème suivant :
Un programme principal saisit une chaîne d’ADN valide et une séquence
d’ADN valide (« valide » signifie qu’elles ne sont pas vides et sont formées
exclusivement d’une combinaison arbitraire de "a", "t", "g" ou "c").
1.
2.
3.
Écrire une fonction valide qui renvoie vrai si la saisie est valide, faux
sinon.
Écrire une fonction saisie qui effectue une saisie valide et renvoie la
valeur saisie sous forme d’une chaîne de caractères.
Écrire une fonction proportion qui reçoit deux arguments, la chaîne et la
séquence et qui retourne la proportion de séquence dans la chaîne (c’està-dire son nombre d’occurrences).
Le programme principal appelle la fonction saisie pour la chaîne et pour la
séquence et affiche le résultat.
Exemple d’affichage :
Il y a 13.33 % de "ca" dans votre chaîne.
PS : vous rechercherez dans l'aide Python la commande count pour les chaines
de caractères. La syntaxe est chaine.count(sous_chaine).
PROJET n°6
Le but de ce projet est de résoudre le problème suivant :
Le jeu de Nim
Écrire un programme qui joue au jeu de Nim contre un être humain. Le principe
est le suivant : Au départ, il y a un nombre N d'allumettes. Tour à tour, chaque
joueur (humain comme ordinateur) a le droit de prendre entre 1 et 3 allumettes.
Celui qui prend la dernière allumette a perdu.
Étape 1 : On suppose d'abord qu'il y a 15 allumettes initialement et que
l'utilisateur joue en premier. On suppose en plus que le joueur ne triche pas en
prenant bien entre 1 et 3 allumettes.
Étape 2 : Modifiez le programme précédent de sorte que l'on puisse choisir le
nombre initial d'allumettes et qui commence (le joueur humain ou l'ordinateur).
Étape 3 : Finalisez le programme de l'étape 2 en incluant un test qui empêche le
joueur humain de tricher.
PS : s'il reste moins de 3 allumettes et que c'est à l'ordinateur de jouer, il adopte une stratégie
gagnante. Vous pouvez même programmer, dans le cas où l'ordinateur débute la partie, une stratégie
où il gagne à coup sûr !
PROJET n°7
Le but de ce projet est de construire le motif suivant :
Vous fabriquerez d'abord une fonction carre(taille,couleur) et une fonction
triangle(taille,couleur). Dans l'exemple choisi le carré a pour côté 50 et le
triangle 35. Je me suis placé au départ au point de coordonnées (-100,-100).
Sur la rangée du bas comme sur la rangée du haut, l'écart entre le premier carré
et le triangle au milieu est de 20, puis de 35 entre le triangle du milieu et le
carré de droite.
Verticalement, sur la première colonne comme sur la troisième, je passe du
premier carré au triangle du milieu avec un écart de 20, puis du triangle du
milieu au carré du haut avec un écart de 40.
PROJET n°8
Le but de ce projet est de dessiner le flocon de Von Koch à une étape arbitraire
choisie par l'utilisateur et pour un triangle équilatéral initial de côté choisi par
l'utilisateur.
Pour rappel, on donne les trois premières figures, correspondant aux trois
premières étapes :
Flocon à l'étape 0
Flocon à l'étape 1
On pourra utiliser une programmation par récursivité.
Flocon à l'étape 2
On donne ci-dessous quelques autres idées de projets.
• Contrôle d'un numéro de sécurité sociale
• Jeu du Mastermind
• Détermination du signe du zodiaque en fonction de la date de naissance
• Simulation du lancer de deux dés
Analyse et corrigé des projets
Corrigé du projet n°1
Considérons le pentagone régulier ABCDE.
Il est aisé de constater que 
ABC = 108 ° . Comme le triangle ABC est isocèle en B, on en


déduit que BAC = BCA = 36 ° . D'où 
EBD = 36 ° . Ainsi, partant d'une branche : [EC]
par exemple, on devra tourner à droite de 180-36 =144° pour passer à la branche [CA].
D'où le programme suivant :
def etoile(taille):
i=0
while i<5:
forward(taille)
right(144)
i=i+1
# D'après ce qui précède
# programme principal
from turtle import *
up()
goto(-50,0)
down()
j,taille,espacement=0,50,10
while j<5:
etoile(taille)
up()
forward(taille+espacement)
down()
taille=taille+10
j=j+1
taille=taille-2*espacement
k=0
while k<4:
etoile(taille)
up()
forward(taille+espacement)
down()
taille=taille-10
k=k+1
# première série d'étoiles de tailles croissantes
# Attention à la transition !
# seconde série d'étoiles de tailles décroissantes
Corrigé du projet n°2
Algorithme
nb ← entier aléatoire entre 1 et 100
i←1
écrire « saisissez un entier entre 1 et 100 »
lire a
Tant que (a différent de nb) et (i<5) faire
Si a<nb faire
écrire « plus petit »
lire a
Sinon faire
écrire « plus grand »
lire a
i ← i+1
Si a = nb faire
écrire « gagné en »,i, « essais »
Sinon faire
écrire « perdu ! Il fallait trouver »,nb
En Python
from random import *
nb=randint(1,100)
i=1
a=int(input("saisissez un entier entre 1 et 100 "))
while a!=nb and i<5:
if a>nb:
print ("plus petit")
a=int(input())
elif a<nb:
print ("plus grand")
a=int(input())
i=i+1
if a==nb:
print ("gagné en ",i," essais")
else:
print ("perdu ! Il fallait trouver ",nb)
Commentaire pédagogique : Ce projet mêle boucle et instructions conditionnelles. Il est réalisable
lorsque ces notions ont été travaillées un certain nombre de fois en classe. Il a été bien réussi par le
groupe d'élèves l'ayant cherché ; il a fallu quelques tâtonnements, et après une aide (légère) de ma
part, ils ont débloqué d'eux mêmes ce qui leur manquait pour l'achever.
Corrigé du projet n°3
# Construction de la fonction triangle
def triangle(taille):
i=0
while i<3:
forward(taille)
left(120)
i=i+1
# programme principal
from turtle import *
i,taille,espacement=1,15,20
abscisse,ordonnee=80,-60
while i<=4:
# construction de la spirale de triangles
if i%2= =1:
up()
goto(abscisse,ordonnee)
down()
triangle(taille)
abscisse,taille,espacement=abscisse+taille+espacement,taille+10,espacement+50
up()
goto(abscisse,ordonnee)
down()
triangle(taille)
else:
up()
ordonnee=ordonnee+espacement
goto(abscisse,ordonnee)
down()
taille=taille+10
triangle(taille)
espacement,taille=espacement+50,taille+10
abscisse=abscisse-espacement-taille
up()
goto(abscisse,ordonnee)
down()
triangle(taille)
ordonnee=ordonnee-espacement
taille=taille+10
i=i+1
Commentaire pédagogique : C'est un projet difficile. Le groupe qui en a hérité a néanmoins fait
preuve d'acharnement en testant et re-testant ces scripts pour aboutir au résultat escompté. Il est
utile de remplir à la main un tableau avec les coordonnées du « point de départ » de chaque triangle
pour bien visualiser leur évolution.
Corrigé du projet n°4
ANALYSE : Avant de se lancer tête baissée dans l'écriture d'un script, les élèves ont commencé par
manipuler quelques nombres en les convertissant en nombres romains. Ce faisant, en leur donnant
en pâture quelques valeurs bien choisies, ils ont pu se rendre compte que certaines valeurs jouaient
le rôle de « pivot ». De plus, les lettres d'unités ont un rôle capital.
Rappelons le principe d'écriture en nombres romains (ce qu'ils ont cherché sur internet)
La numérotation a été normalisée dans l’usage actuel et repose sur quatre principes :
• Toute lettre placée à la droite d’une autre figurant une valeur supérieure ou égale à la sienne
s’ajoute à celle-ci.
• Toute lettre d’unité placée immédiatement à la gauche d’une lettre plus forte qu’elle,
indique que le nombre qui lui correspond doit être retranché au nombre qui suit.
• Les valeurs sont groupées en ordre décroissant, sauf pour les valeurs à retrancher selon la
règle précédente.
• La même lettre ne peut pas être employée quatre fois consécutivement sauf M.
Lettres d’unité :
I est une unité pour V et X
X est une unité pour L et C
C est une unité pour D et M.
Traitons les exemples proposés.
Exemple 1 : écrire en nombres romains 2397.
2397 = 2000300907 = 2×10003×100907 .
Le chiffre des milliers et celui des centaines ne posent pas de problèmes : 2000 s'écrit MM et 300
s'écrit CCC ; par contre 97 est entre 50 et 100, mais plus précisément entre 90 et 100. Comme X est
une lettre d'unité pour C, on interprète 97 comme 90 + 7, ce qui s'écrit XC suivi de VII
Finalement 2397 s'écrit MMCCCXCVII
Exemple 2 : écrire en nombres romains 3912. Même question avec 3812.
3912 = 3×1000900102 .
Le seul problème résulte en l'écriture de 900. C (cent) étant une unité pour M (mille), 900 s'écrit
CM. Ainsi 3912 s'écrit MMMCMXII
Par contre 800 s'écrit 500 + 300. Ainsi 3812 s'écrit MMMDCCCXII.
Il apparaît au vu des règles d'écritures que pour écrire un nombre romain entre 1 et 3999
(ainsi M n'apparait pas plus de 4 fois), on aura à considérer la liste des lettres suivantes :
[M,CM,D,CD,C,XC,L,XL,X,IX,V,IV,I], celles en rouge pouvant être répétées consécutivement.
en prenant bien en compte les considérations suivantes :
C étant une unité pour M, il faudra utiliser CM pour 900, donc après avoir « épuisé » tous les
milliers distinguer les cas 500<reste<900 et 900<reste<1000 ;
de même C étant une unité pour D (500), il faudra distinguer les cas 400<reste<500 et
100<reste<400 ;
Ainsi de suite...
On arrive alors au script suivant :
N=int(input("saisissez un entier entre 1 et 4999 "))
R=""
while N>=1000:
# Car M peut être écrit plusieurs fois consécutivement
R=R+"M"
N=N-1000
# Une fois tous les milliers épuisés, on regarde les centaines
if N>=900:
R=R+"CM"
N=N-900
if N>=500:
R=R+"D"
N=N-500
if N>=400:
R=R+"XC"
N=N-400
while N>=100:
R=R+"C"
N=N-100
# Car C peut être écrit plusieurs fois consécutivement
# Une fois les centaines épuisées, on regarde les dizaines
if N>=50:
R=R+"L"
N=N-50
if N>=40:
R=R+"XL"
N=N-40
while N>=10:
R=R+"X"
N=N-10
# Car X peut être écrit plusieurs fois consécutivement
# Une fois les dizaines épuisées, on regarde les unités
if N>=9:
R=R+"IX"
N=N-9
if N>=5:
R=R+"V"
N=N-5
if N>=4:
R=R+"IV"
N=N-4
while N>=1:
R=R+"I"
N=N-1
# Car I peut être écrit plusieurs fois consécutivement
print (N," s\ecrit ",R, "en chiffres romains")
Corrigé du projet n°5
# définition de la fonction estvalide
def estvalide(sequence):
global reponse
i=0
reponse=True
while i<len(sequence) and reponse==True:
if sequence[i]=='a' or sequence[i]=='t' or sequence[i]=='g' or sequence[i]=='c':
reponse=True
else:
reponse=False
break
i=i+1
return reponse
# définition de la fonction saisie
def saisie(sequence):
global seq
estvalide(sequence)
while reponse==False:
print("Saisie incorrecte ")
sequence=input("Saisir votre chaine ")
estvalide(sequence)
seq=sequence
return seq
# définition de la fonction proportion
def proportion(sequence,chaine):
n=len(chaine)
k=chaine.count(sequence)
return 100*k/n
# rechercher dans l'aide la commande count
# pour les chaines de caractères
# Programme principal
print("Saisie de la chaine d\'ADN ")
adn=input("Saisir votre chaine ")
saisie(adn)
print("Saisie de la séquence de chainons ")
s=input("Saisir votre liste de chainons ")
saisie(s)
print("Il y a ",proportion(s,adn),"% de ",s," dans votre chaine")
Corrigé du projet n°6
Étape 1 :
ANALYSE : on sera amené à distinguer les cas où après chaque tour du joueur humain, il reste soit
moins de 3 allumettes (0, 1, 2 ou 3), soit strictement plus de 3 allumettes. Dans le premier cas,
l'ordinateur adopte une stratégie gagnante dès que la situation lui est favorable. Le jeu s'arrête grâce
à la commande break. L'ordinateur décèle également les situations où il est perdant. Dans le second
cas, il prend un nombre aléatoire d'allumettes entre 1 et 3.
from random import *
# de manière à utiliser randint(a,b)
N=15
# on initialise N à 15
while N>0:
print("il y a ",N,"allumettes")
N1=int(input("prenez entre 1 et 3 allumettes "))
# N1 est le nombre d'allumettes prises
N=N-N1
# par le joueur humain
if N==0:
# N2 est le nombre d'allumettes prises
print("Vous avez perdu !")
# par l'ordinateur
break
elif N==1:
N2,N=1,0
print("J\'ai pris la dernière allumette. Vous avez gagné")
elif N==2:
N2=N-1
print("Je prends une allumette")
print("Il ne reste plus donc qu\'une allumette. Vous perdez au tour suivant")
break
elif N==3:
N2=N-2
print("Je prends deux allumettes")
print("Il ne reste donc plus qu\'une allumette. Vous perdez au tour suivant")
break
else:
N2=randint(1,3)
print("Je prends ",N2,"allumettes")
N=N-N2
Etape 2
ANALYSE : Le fait que l'ordinateur commence change la donne. On peut cependant partir du script
précédent et le modifier en conséquence. Une instruction conditionnelle du type Si... Sinon est
nécessaire de prime abord pour donner le choix du joueur qui commence : humain ou ordinateur.
On aura donc un script construit de la sorte :
écrire "Voulez-vous commencer ? O ou N ?"
lire réponse
Si réponse="O" faire
Bloc d'instructions établi à l'étape 1
Sinon faire
Blocs d'instructions où l'ordinateur débute.
C'est ce dernier bloc qu'il convient d'écrire en modifiant celui de l'étape 1. Là est la difficulté.
from random import *
N=int(input("Choisissez le nombre d'allumettes du jeu. N>3 "))
print("Voulez-vous commencer à jouer ? O ou N")
reponse=input()
if reponse=="O":
while N>0:
print("il y a ",N,"allumettes")
N1=int(input("prenez entre 1 et 3 allumettes "))
N=N-N1
if N==0:
print("Vous avez perdu !")
break
elif N==1:
N2,N=1,0
print("J\'ai pris la dernière allumette. Vous avez gagné")
elif N==2:
N2=N-1
print("Je prends une allumette")
print("Il ne reste donc plus qu\'une allumette. Vous perdez au tour suivant")
break
elif N==3:
N2=N-2
print("Je prends deux allumettes")
print("Il ne reste plus qu\'une allumette. Vous perdez au tour suivant")
break
else:
N2=randint(1,3)
print("Je prends ",N2,"allumettes")
N=N-N2
else:
# partie du script où l'ordinateur commence
while N>0:
print("il y a ",N,"allumettes")
if N>=1:
if N>=3:
# s'il reste un nombre supérieur ou égal à 3
N1=randint(1,3)
# d'allumettes, l'ordinateur en choisit un
print("Je prends ",N1,"allumettes")
# nombre aléatoire au hasard entre 1 et 3.
N=N-N1
print("il reste ",N,"allumettes")
if N>=3:
# on demande au joueur humain d'en faire de
print("Choisissez entre 1 et 3 allumettes ")
# même dans le même cas.
N2=int(input())
N=N-N2
elif N==2:
print("Choisissez entre 1 et 2 allumettes ")
N2=int(input())
N=N-N2
elif N==1:
print("Il ne reste plus qu\'une allumette que vous devez prendre. Vous avez perdu !")
break
else:
print("Arg ! J\'ai pris la dernière allumette. Vous avez gagné !")
break
elif N==2:
N1,N=1,0
print("Je prends une allumette")
print("Il ne reste plus qu\'une allumette que vous devez prendre. Vous avez perdu !")
break
elif N==1:
print("Il ne reste qu\'une allumette que je dois prendre. Vous avez gagné !")
break
else:
print("J\'ai pris la dernière allumette. Vous avez gagné !")
break
Remarquez bien l'indentation des blocs d'instructions. Analysons plus en détail la construction de
celui où l'ordinateur commence :
• Dès lors qu'il reste un nombre d'allumettes inférieur ou égal à 3, l'ordinateur adopte une
stratégie gagnante (on aurait pu la programmer dès le départ !). En conséquence :
* si après le tour du joueur humain il reste 3 allumettes, l'ordinateur en prendra deux.
* si après le tour du joueur humain, il reste deux allumettes, l'ordinateur n'en prendra qu'une.
* s'il n'en reste qu'une après le tour du joueur humain, il est obligé de la prendre et perd !
• Après le premier tour de l'ordinateur, on regarde si le joueur humain peut prendre entre 1 et
3 allumettes (si le nombre restant d'allumettes est supérieur ou égal à 3) ou pas. Cette action
se répétera tant que le nombre d'allumettes dépassera 3. S'il n'en reste qu'une l'ordinateur
annonce au joueur humain qu'il va perdre au tour suivant.
Étape 3
Le test ne pose pas de problèmes. Tant que l'utilisateur ne choisit pas un nombre d'allumettes correct
(entre 1 et 3 si le nombre d'allumettes restant est supérieur ou égal à 3, entre 1 et 2 s'il reste 2
allumettes et 1 s'il ne reste qu'une allumette), l'ordinateur lui intime de recommencer sa saisie. Pour
ce faire, on peut définir une fonction test(N) par :
# cas où l'utilisateur doit choisir entre 1 et 3 allumettes.
def test(nombre):
while nombre<1 or nombre>4:
print("Entrer un entier de 1 à 3 svp")
nombre=int(input())
Je laisse au soin du lecteur de la placer où il se doit.
Commentaire pédagogique : il est intéressant de traiter ce sujet à l'aide de fonctions : une dévolue
au cas où le joueur humain débute la partie, une où c'est l'ordinateur et une de test du nombre
d'allumettes prises par le joueur humain (s'adaptant au nombre d'allumettes restant). On peut par
ailleurs raccourcir le script notamment en offrant à l'ordinateur une stratégie gagnante dès lors qu'il
débute la partie. A vous de trouver comment faire !
Corrigé du projet n°7
def carre(taille,couleur):
i=0
while i<4:
color(couleur)
forward(taille)
left(90)
i=i+1
def triangle(taille,couleur):
i=0
while i<6:
color(couleur)
forward(taille)
left(120)
i=i+1
# programme principal
from turtle import *
i,taille1,taille2=1,50,35
abscisse,ordonnee=-100,-100
c=['blue','red']
while i<=3:
up()
goto(abscisse,ordonnee)
down()
if i%2= =1:
carre(taille1,c[0])
up()
forward(taille1+20)
down()
triangle(taille2,c[1])
up()
forward(taille2+35)
down()
carre(taille1,c[0])
else:
up()
ordonnee=ordonnee+taille1+20
goto(abscisse,ordonnee)
down()
triangle(taille2,c[1])
up()
forward(taille2+110)
down()
triangle(taille2,c[1])
up()
ordonnee=ordonnee+40
goto(abscisse,ordonnee)
down()
i=i+1
# motif des 1ère et 3ème ligne
# motif de la 2ème ligne
Corrigé du projet n°8
def koch(l,n):
if n==0:
forward(l)
else:
koch(l/3,n-1)
left(60)
koch(l/3,n-1)
right(120)
koch(l/3,n-1)
left(60)
koch(l/3,n-1)
# on donne le procédé général pour un segment quelconque
def flocon(l,n):
koch(l,n)
right(120)
koch(l,n)
right(120)
koch(l,n)
# on applique la fonction précédente à chaque segment
# l est la taille du segment du triangle initial
# programme principal
from turtle import *
etape=int(input("Entrez l\'ordre de l\'étape du flocon de Von Koch "))
taille1=float(input("Entrez la taille du côté du triangle initial "))
flocon(taille1,etape)
Commentaire pédagogique : la notion de récursivité avait été abordée en cours sur quelques
exemples calculatoires. Assez délicate à faire passer d'ailleurs. On peut également programmer le
flocon sans récursivité, à l'aide des coordonnées, mais cela est délicat au niveau seconde.
CHAPITRE 5 : CORRIGE DES EXERCICES
Corrigé des séances 2 à 6 du chapitre 3
Séance n°2
Exercice 2
Algorithme
i←0
Tant que i<7 faire
avancer de 150
tourner à gauche de 360/7°
i ← i+1
En Python
from turtle import *
i=0
while i<7:
forward(150)
left(360/7)
i=i+1
La figure tracée est un heptagone régulier.
Commentaire pédagogique : La difficulté est de trouver la mesure de l'angle duquel on va tourner :
ici 360/7°. Un « truc » peut être de remarquer que tout polygone régulier est inscrit dans un cercle...
Revenir sur le tracé d'un triangle équilatéral, d'un carré, d'un hexagone.
Exercice 3
Algorithme
En Python
i←0
Tant que i<6 faire
avancer de 50
tourner à gauche de 60°
i ← i+1
from turtle import *
i=0
while i<6:
forward(50)
left(60)
i=i+1
i←0
Tant que i<3 faire
avancer de 50
tourner à gauche de 120°
avancer de 100
tourner à gauche de 120°
i ← i+1
i=0
while i<3:
forward(50)
left(120)
forward(100)
left(120)
i=i+1
Commentaire pédagogique : la construction de l'hexagone ne pose pas de problème. Celle des
diagonales est plus délicate. Certains élèves pensent qu'on ne peut pas repasser par des traits déjà
tracés.
Exercice 4
Analyse : comme dans l'exemple phare du cours, on aura besoin de deux variables : S la somme à
calculer et un compteur i qui prendra successivement les valeurs : 5 ; 9 ; 13 … 101 ; 105. i varie
donc de 4 en 4. Remarque : 105 = 5 +25*4.
Algorithme
En Python
S←0
i←5
Tant que S<=105 faire
S ← S+i
i ← i+4
S=0
i=5
while S<=105:
S=S+i
i=i+4
Afficher S
print(S)
Séance n°3
Exercice 1
Question 1 : Script pour dessiner un carré de côté 10
L'algorithme a déjà été étudié lors de la première séance. On donne ici sa transcription en langage
Python.
from turtle import *
i=0
while i<4:
forward(10)
left(90)
i=i+1
Question 2 : On dessine ici une série de 10 carrés de côté 10 espacés entre eux de 10.
Même remarque que précédemment. On aura besoin de deux boucles while imbriquées, la première
servant pour le nombre de carrés à dessiner, la seconde pour dessiner un de ces carrés.
from turtle import *
j=0
while j<10:
i=0
while i<4:
forward(10)
left(90)
i=i+1
up()
forward(20)
down()
j=j+1
# Ce while sert à dessiner les 10 carrés
# Ce while sert à dessiner un carré
# pour ne pas dessiner entre les carrés
# car les carrés sont espacés de 10 entre eux
# pour redessiner à nouveau
Commentaire pédagogique : Cet exercice n'est pas évident de prime abord ; il convient de bien
expliquer la construction de l'algorithme. On pourra également insister sur la manière dont les blocs
d'instructions sont indentés.
Remarque : En utilisant des boucles for on obtient la même structure.
Question 3 : Cette fois-ci, la taille des carrés consécutifs varie ; on aura donc besoin d'une variable
supplémentaire. Appelons-là taille tout simplement !
from turtle import *
j,taille=0,10
while j<4:
i=0
while i<4:
forward(10)
left(90)
i=i+1
up()
forward(taille+10)
down()
taille=taille+15
j=j+1
# le côté du premier carré est de 10
# Ce while sert à dessiner les 4 carrés
# Ce while sert à dessiner un carré
# pour ne pas dessiner entre les carrés
# car les carrés sont espacés de 10 entre eux
# pour redessiner à nouveau
# la taille des carrés s'accroit de 15 à chaque itération
Exercice 2
Analyse : on doit dessiner une série de 6 hexagones alternés avec 6 carrés, tous de côté 20.
L'espacement est de 30 entre chaque figure. On doit donc répéter 3 fois le même motif : un
hexagone de côté 20 suivi d'un carré du même côté.
D'où la nécessité de 3 boucles : une pour la répétition du motif, une pour le dessin d'un hexagone
et une pour le dessin d'un carré.
from turtle import *
j=0
while j<3:
i=0
while i<6:
forward(20)
left(60)
i=i+1
up()
forward(50)
down()
i=0
while i<4:
forward(20)
left(90)
i=i+1
up()
forward(50)
down()
j=j+1
# Ce while sert à dessiner les 3 motifs
# Ce while sert à dessiner un hexagone
# pour ne pas dessiner entre les figures
# car les figures sont espacés de 30 entre elles
# pour redessiner à nouveau
# Ce while sert à dessiner un carré
Commentaire pédagogique : il est essentiel de bien décortiquer le problème : de quoi a-t-on besoin ?
Nombre de variables ? Quand doit-on lever le crayon, le rabaisser ? On voit par ailleurs apparaître
une difficulté : Et si le motif était plus compliqué, comment faire pour « réduire » la taille du
script ? Dans l'exercice 1 comme dans celui-ci, il a fallu à chaque fois réécrire un bout de
programme dessinant un carré. Ne pourrait-on pas conserver ce morceau de script pour l'utiliser à
loisir ? La notion de fonction pointe le bout de son nez...
Exercice 3
a=[20,3.5,44,37,151,28,15.5]
i,S=0,0
while i<len(a):
S=S+a[i]
i=i+1
# on parcourt la liste en entier
print("la somme des éléments de la liste vaut ",S)
Séance n°4
Exercice 1
i=0
while i<20:
if i%3==0:
print(7*i,"*")
else:
print(7*i)
i=i+1
Exercice 2
Analyse : on va avoir besoin de trois variables : la chaine de caractères elle-même, un compteur i
parcourant les éléments de la chaine et une autre variable nb comptant le nombre d'apparitions de la
lettre « g ».
a=input("Saisissez une chaîne de caractères ")
i,nb=0,0
while i<len(a):
if a[i]=="g":
nb=nb+1
# on incrément nb de 1 dès que g est décelé dans la chaine
# pas besoin de else, l'alternative étant de ne rien faire
i=i+1
print("Dans votre chaîne la lettre g apparaît ",nb,"fois")
Exercice 3
N=int(input("Saisissez un entier naturel "))
if N%5==0:
print("C\'est un multiple de 5")
else:
print("Ce n\'est pas un multiple de 5")
Exercice 4
Analyse : on aura besoin d'une instruction conditionnelle if...else ainsi que de deux boucles pour
dessiner soit un carré, soit un triangle équilatéral.
D'où le programme :
from turtle import *
N=int(input("Saisissez un entier naturel "))
if N%2==0:
i=0
while i<4:
forward(50)
left(90)
i=i+1
else:
i=0
while i<3:
forward(70)
left(120)
i=i+1
Exercice 5
A=input("Donnez votre avis : satisfait ? moyennement satisfait ? pas satisfait ? ")
if A=="satisfait":
print("Merci ! Very good")
elif A=="moyennement satisfait":
print("Ok ok")
else:
print("Snif !")
Séance n°5
Exercice 1
ch=input("Saisissez une chaîne de caractères ")
i,nb=0,0
while i<len(ch):
if ch[i]=="a":
nb=nb+1
# on incrément nb de 1 dès que a est décelé dans la chaine
# pas besoin de else, l'alternative étant de ne rien faire
i=i+1
if nb==0:
ch=ch+"a"
# si « a » n'apparait pas on le rajoute à la fin de la chaine
print(ch)
Exercice 2
phrase=input("Saisissez une chaîne de caractères ")
i,phrase_inv=len(phrase)-1,""
while i>=0:
phrase_inv=phrase_inv+phrase[i]
i=i-1
Commentaire pédagogique : on n'incrémente pas toujours i d'une valeur positive !
Exercice 3
a=[20,35,11,56,41,10]
i,max=1,a[0]
while i<len(a):
if a[i]>max:
max=a[i]
i=i+1
print("le max de la liste ",a,"est égal à ",max)
Exercice 4
liste1=['coucou','bonjour','ça va ?']
liste2=['Charles','Edouard','Au poil !']
liste3=[]
i=0
while i<len(liste1):
liste3.append(liste1[i])
liste3.append(liste2[i])
i=i+1
# on initialise la liste à construire par la liste vide
# les listes 1 et 2 sont de même longueur
# on ajoute d'abord un élément de liste1
# puis ensuite un élément de liste2
print(liste3)
Commentaire pédagogique : ceci demande aux élèves de bien avoir compris le principe de la
commande liste.append(objet), en lien étroit avec la notion de boucle dès lors qu'il s'agit de rajouter
plusieurs éléments.
Séance n°6
Exercice 4
# définition de la fonction carré
def carre(taille):
i=0
while i<4:
forward(taille)
left(90)
i=i+1
# programme principal
from turtle import *
j=0
while j<10:
carre(10)
up()
forward(20)
down()
j=j+1
# on aurait aussi pu reprendre i comme variable (globale)
# pourquoi ?
# utilisation de la fonction carre
Exercice 5
# définition de la fonction carré
def carre(taille):
i=0
while i<4:
forward(taille)
left(90)
i=i+1
# programme principal
from turtle import *
taille=10
j=0
while j<4:
carre(taille)
up()
forward(taille+10)
down()
taille=taille+15
j=j+1
Exercice 6
# définition des fonctions carre et hexagone
def carre(taille):
i=0
while i<4:
forward(taille)
left(90)
i=i+1
def hexagone(taille):
i=0
while i<6:
forward(taille)
left(60)
i=i+1
# programme principal
i=0
while i<3:
hexagone(20)
up()
forward(50)
down()
carre(20)
up()
forward(50)
down()
i=i+1
# utilisation de la fonction carre
Exercice 7
#création d'une fonction pentagone à deux arguments
def pentagone(taille,couleur):
i=0
color(couleur)
while i<5:
forward(taille)
left(72)
i=i+1
#création d'une fonction triangle à deux arguments
def triangle(taille,couleur):
i=0
color(couleur)
while i<3:
forward(taille)
right(120)
i=i+1
#programme principal
from turtle import *
taille1,couleur1=15,'blue'
taille2,couleur2=25,'red'
up()
goto(-100,0)
down()
i=0
while i<5:
pentagone(taille1,couleur1)
up()
forward(taille1+20)
down()
triangle(taille2,couleur2)
up()
forward(taille2+20)
down()
i=i+1
Commentaire pédagogique : on voit l'intérêt de la notion de fonction. On peut demander aux élèves
de créer un motif plus compliqué pour les en convaincre.
TP Géométrie n°1 : distance et coordonnées
Question 1 : Écrire un programme qui étant donné les coordonnées x A et y A d'un point A,
puis x B et y B d'un point B, renvoie les coordonnées du point I, milieu du segment [AB].
Sous Python vous créerez une fonction milieu(x_A,x_B,y_A,y_B)
réponse :
def milieu(x_A,x_B,y_A,y_B):
# création de la fonction milieu
global I
# I est déclarée comme variable globale pour utilisation dans le PP
I=[(x_A+x_B)/2,(y_A+y_B)/2]
# I est stocké sous la forme d'une liste
return I
# programme principal
x_A=float(input("saisir x_A "))
y_A=float(input("saisir y_A "))
x_B=float(input("saisir x_B "))
y_B=float(input("saisir y_B "))
milieu(x_A,x_B,y_A,y_B)
print("Le milieu de [AB] a pour coordonnées ",I)
Question 2 : Écrire un programme qui étant donné les coordonnées
puis x B et y B d'un point B, renvoie la distance AB.
xA
et
yA
d'un point A,
Sous Python la fonction racine carrée se note sqrt() : sqrt(x) est la racine carrée d'un réel positif x.
Vous créerez une fonction distance(x_A,x_B,y_A,y_B).
réponse :
def distance(x_A,x_B,y_A,y_B):
# création de la fonction distance
global dist
# de manière à se servir de dist dans le PP
dist=sqrt((x_B-x_A)**2+(y_B-y_A)**2)
# programme principal
from math import *
x_A=float(input("saisir x_A "))
y_A=float(input("saisir y_A "))
x_B=float(input("saisir x_B "))
y_B=float(input("saisir y_B "))
distance(x_A,x_B,y_A,y_B)
print("La distance AB est égale à ",dist)
Commentaire pédagogique : c'est l'occasion d'insister à nouveau sur la structure d'un programme.
D'abord la définition des fonctions, les « sous-programmes » et ensuite le programme principal.
Question 3 : Soit C le cercle de diamètre [AB]. Dans un repère orthonormé on se donne A(-2 ;2) et
B(3 ; -5). On cherche à savoir si un point M(x ; y) appartient ou non au cercle C.
1. Écrire un programme utilisant les deux fonctions précédentes qui réponde à la question.
−3  65
2. Le tester avec M( 1; 14) puis M 2 ;
2


réponse :
def milieu(x_A,x_B,y_A,y_B):
global I
I=[(x_A+x_B)/2,(y_A+y_B)/2]
return I
def distance(x_A,x_B,y_A,y_B):
global dist
dist=sqrt((x_B-x_A)**2+(y_B-y_A)**2)
# programme principal
from math import *
x_A=float(input("saisir x_A "))
y_A=float(input("saisir y_A "))
x_B=float(input("saisir x_B "))
y_B=float(input("saisir y_B "))
milieu(x_A,x_B,y_A,y_B)
# calcul des coordonnées du centre I du cercle
distance(x_A,x_B,y_A,y_B)
# calcul du diamètre du cercle
d=dist/2
# calcul du rayon du cercle
x_M=float(input("saisir x_M "))
y_M=float(input("saisir y_M "))
distance(I[0],x_M,I[1],y_M)
# dist a été réaffecté par la distance IM
if d==dist:
print("M appartient au cercle de diamètre [AB]")
else:
print("M n\'appartient pas à au cercle de diamètre [AB]")
# On compile avec Ctrl+F5
>>>
saisir x_A -2
saisir y_A 3
saisir x_B 2
saisir y_B -5
Le milieu de [AB] a pour coordonnées [0.0, -1.0]
Le vecteur AB a pour coordonnées [4.0, -8.0]
La distance AB est égale à 8.94427191
saisir x_M 1
saisir y_M 14
M n'appartient pas à C
Commentaire pédagogique : La grande difficulté est de savoir à quel moment on déclare une
variable comme globale. Ceci donne l'occasion de revenir sur les priorités entre variables. Ne pas
hésiter à y passer du temps. La question 3 est délicate.
TP Géométrie n°2 : vecteurs et parallélogrammes
Question 1 : On considère un repère O ; i ; j . On se donne deux points A, B repérés par
leurs coordonnées.
Écrire un programme qui étant donné les coordonnées x A et y A d'un point A, puis x B et
y B d'un point B, renvoie celles du vecteur 
AB sous la forme d'une liste.
Sous Python vous créerez une fonction vecteur(x_A,x_B,y_A,y_B)
Réponse :
def vecteur(x_A,x_B,y_A,y_B):
global vec
vec=[x_B-x_A,y_B-y_A]
return vec
# programme principal
from math import *
x_A=float(input("saisir x_A "))
y_A=float(input("saisir y_A "))
x_B=float(input("saisir x_B "))
y_B=float(input("saisir y_B "))
vecteur(x_A,x_B,y_A,y_B)
print("Le vecteur AB a pour coordonnées ",vec)
Question 2 : On se donne quatre points distincts du plan A, B, C et D repérés par leurs coordonnées.
1. Écrire un programme qui étant donné les coordonnées des points A,B,C et D affiche si le
quadrilatère ABCD est un parallélogramme.
2. Écrire un programme qui étant donné les coordonnées des points A,B,C et D affiche si le
quadrilatère ABCD est un trapèze.
Vous pourrez vous servir de la fonction créée à la question 1.
Les tester avec A(-1 ; 2), B (3 ; 4), C(1 ; 5) et D(9 ; 7)
2) 1)
# définition des fonctions
def vecteur(x_A,x_B,y_A,y_B):
global vec
vec=[x_B-x_A,y_B-y_A]
return vec
#programme principal
from math import *
x_A=float(input("saisir x_A "))
y_A=float(input("saisir y_A "))
# on définit les coordonnées de 
AB
x_B=float(input("saisir x_B "))
y_B=float(input("saisir y_B "))
x_C=float(input("Saisir x_C "))
y_C=float(input("Saisir y_C "))
x_D=float(input("Saisir x_D "))
y_D=float(input("Saisir y_D "))
vecteur(x_A,x_B,y_A,y_B)
# vec1 reçoit la première valeur de vec utilisant A et B
vec1=vec
vecteur(x_D,x_C,y_D,y_C)
# on affecte à vec une nouvelle valeur utilisant D et C
vec2=vec
# vec2 reçoit la seconde valeur affectée à vec
if vec1==vec2:
# on teste si 
AB = 
DC .
print("ABCD est un parallélogramme")
else:
print("ABCD n\'est pas un parallélogramme")
2) 2)
from math import *
x_A=float(input("saisir x_A "))
y_A=float(input("saisir y_A "))
x_B=float(input("saisir x_B "))
y_B=float(input("saisir y_B "))
x_C=float(input("Saisir x_C "))
y_C=float(input("Saisir y_C "))
x_D=float(input("Saisir x_D "))
y_D=float(input("Saisir y_D "))
# on écrit directement le script principal
if (x_B-x_A)*(y_D-y_C)-(x_D-x_C)*(y_B-y_A)==0:
print("ABCD est un trapèze")
else:
print("ABCD n\'est pas un trapèze")
Question 3 :
On se sert de la propriété fondamentale qui assure que ABCD est un parallélogramme si et
AB  x B −x A ; y B− y A  et 
DC  x C −x D ; y C − y D  .
seulement si 
AB = 
DC . On a 
xC −x D= x B −x A
x D =x C − x B x A
On cherche donc x_D et y_D tels que
soit
y C − y D= y B − y A
y D = y C − y B y A
Ceci permet de programmer facilement ce qui est demandé.
{
x_A=float(input("Saisir x_A "))
y_A=float(input("Saisir y_A "))
x_B=float(input("Saisir x_B "))
y_B=float(input("Saisir y_B "))
x_C=float(input("Saisir x_C "))
y_C=float(input("Saisir y_C "))
x_D=x_C-x_B+x_A
y_D=y_C-y_B+y_A
print("x_D= ",x_D)
print("y_D= ",y_D)
}
{
}
TP Fonction n°1 : tracé d'une courbe
>>> import matplotlib.pyplot as plt
>>> import numpy as np
>>> x=np.linspace(-4,8,100)
# on prendra 100 points entre - 4 et 8.
>>> plt.plot(x,x**2-3*x-10)
# tracé de C
[<matplotlib.lines.Line2D object at 0x03B4C910>]
>>> plt.plot(x,12*x**0)
# tracé de la droite d'équation y = 12
[<matplotlib.lines.Line2D object at 0x03D8BAB0>]
>>> plt.plot(x,-10*x**0)
# tracé de la droite d'équation y = -10
[<matplotlib.lines.Line2D object at 0x03D8B9F0>]
>>> plt.grid(True)
# tracé de la grille
>>> plt.show()
# Affichage des graphiques
Réponse aux questions :
•
Les solutions de l'équation f  x  = 0 sont les abscisses des points de la courbe C dont
l'ordonnée est nulle. On place le curseur de la souris sur les deux points de C vérifiant la
condition sus-indiquée. On trouve x 1 = −2 et x 2 = 5 .
•
•
De même les antécédents de 12 par f sont -3,4 et 6,4 à 0,1 près.
f  x 12 sur
On en déduit les solutions de l'inéquation
S = [−4 ;−3,4]∪[6,4 ;8]
[−4 ; 8] .
Pour déterminer les coordonnées du sommet S de C, on procède en deux étapes :
• on détermine les antécédents de – 10 par f : x 1 = 0 et x 2 = 3 .
x 1x 2
• L'abscisse x 0 du sommet S de C est égale à
, soit x 0 = 1,5 .
2
• On lit alors l'image de 1,5 par f grâce au curseur de la souris : f 1,5 = −12,3 .
Conclusion : S a pour coordonnées S 1,5 ;−12,3 .
TP PROBAS-STATS
Question 1 : Écrire un programme qui demande à un utilisateur de saisir N notes entre 0 et 20 (N
choisi par l'utilisateur) sous la forme d'une liste et N nombres entre 1 et 3 (les coefficients de ces
notes), puis qui renvoie la moyenne pondérée de ces N notes.
Réponse :
liste_notes,liste_coeff=[],[]
N=int(input("Entrez le nombre de notes à saisir "))
i=1
while i<=N:
print("Entrez la note n° ",i)
a=float(input())
liste_notes.append(a)
# on crée la liste des notes
b=print("Entrez le coefficient de la note n°",i," (de 1 à 3)")
b=float(input())
liste_coeff.append(b)
# on crée la liste des coefficients
i=i+1
i,c,S=0,0,0
while i<N:
S=S+liste_notes[i]*liste_coeff[i]
c=c+liste_coeff[i]
i=i+1
print("la moyenne de vos notes est de ",S/c)
Question 2 : On considère un dé parfait à 6 faces et trois urnes numérotées de 1 à 3.
L'urne 1 contient 3 boules blanches, 4 boules noires et 3 boules vertes.
L'urne 2 contient 2 boules blanches, 2 boules noires et 6 boules vertes.
L'urne 3 contient 4 boules blanches, 4 boules noires et 2 boules vertes.
Toutes ces boules sont indiscernables au toucher.
On considère l'expérience aléatoire qui consiste à lancer le dé :
• Si le numéro est 1 ou 2, on tire une boule dans l'urne n°1
• Si le numéro est 3, 4 ou 5 on tire une boule dans l'urne n°2
• Sinon, on tire une boule dans l'urne n°3.
Nous allons écrire un algorithme modélisant ceci. La notion d'instruction conditionnelle sera
omniprésente, sous forme de « if » imbriqués. Ceci tient à la nature même du problème. Prenons un
exemple : pour calculer la probabilité de tomber sur une boule verte, on doit additionner les
probabilités de toutes les branches de l'arbre se terminant par V.
Les variables nécessaires seront :
n : le nombre d'essais effectués
i : un compteur variant de 1 à n
nb_blanc, nb_noir, nb_vert comptant le nombre d'apparitions d'une boule blanche, noire, verte.
numde : le numéro affiché par le dé
numboule : le numéro de la boule tirée dans l'urne n°i (i=1, 2, 3)
Réponse :
from random import *
n=int(input("Combien d\'expériences souhaitez-vous réaliser ? "))
i=1
nb_blanc,nb_noir,nb_vert=0,0,0
while i<=n:
numde=randint(1,6)
# on tire un entier aléatoire entre 1 et 6 (le dé)
if numde<=2:
# condition pour tirer une boule dans l'urne 1
numboule=randint(1,10)
# l'urne 1 contient 10 boules
if numboule<=3:
nb_blanc=nb_blanc+1
elif numboule<=7:
nb_noir=nb_noir+1
else:
nb_vert=nb_vert+1
elif numde<=5:
# condition pour tirer une boule dans l'urne 2
numboule=randint(1,10)
# l'urne 2 contient 10 boules
if numboule<=2:
nb_blanc=nb_blanc+1
elif numboule<=4:
nb_noir=nb_noir+1
else:
nb_vert=nb_vert+1
else:
# sinon on tire une boule dans l'urne 3
numboule=randint(1,10)
# l'urne 3 contient 10 boules
if numboule<=4:
nb_blanc=nb_blanc+1
elif numboule<=8:
nb_noir=nb_noir+1
else:
nb_vert=nb_vert+1
i=i+1
print("La fréquence d\'apparition d\'une boule blanche est de ",nb_blanc/n)
print("La fréquence d\'apparition d\'une boule noire est de ",nb_noir/n)
print("La fréquence d\'apparition d\'une boule verte est de ",nb_vert/n)
TP Équations de droites
Question 1 : Écrire une fonction estverticale(x_A,y_A,x_B,y_B) qui étant donné deux points
A x A ; y A  et B  x B ; y B  détermine si la droite (AB) est verticale ou pas. La valeur
renvoyée par cette fonction sera un booléen : True pour vertical et False dans le cas contraire.
Réponse :
def estverticale(x_A,y_A,x_B,y_B):
global reponse
# la variable reponse est globale pour la réutiliser à l'intérieur
reponse=True
# d'autres fonctions
if x_A==x_B:
reponse=True
else:
reponse=False
Question 2 : Dans le cas où la droite (AB) ne soit pas verticale, écrire une fonction
equation(x_A,y_A,x_B,y_B) qui :
• calcule le coefficient directeur m
• calcule l'ordonnée à l'origine p
• affiche le résultat sous la forme : "La droite (AB) a pour équation y = ",m,"x+",p
On stockera le couple (m,p) dans une liste.
Réponse :
def estverticale(x_A,y_A,x_B,y_B):
global reponse
# la variable reponse est globale
reponse=True
# de manière à la réutiliser dans d'autres
if x_A==x_B:
# fonctions
reponse=True
else:
reponse=False
def equation(x_A,y_A,x_B,y_B):
global m,p
couple=[]
m=(y_B-y_A)/(x_B-x_A)
couple.append(m)
p=y_A-m*x_A
couple.append(p)
# les variables m et p sont globales
print("le coefficient directeur m est égal à ",m)
print("l\'ordonnée à l\'origine est égale à ",p)
print("la droite (AB) a pour équation y=",m,"x+",p)
# programme principal pour répondre à la question 2
x_A=float(input("Saisir x_A "))
y_A=float(input("Saisir y_A "))
x_B=float(input("Saisir x_B "))
y_B=float(input("Saisir y_B "))
estverticale(x_A,y_A,x_B,y_B)
if reponse==True:
print("Cette droite est verticale ")
print("la droite a pour équation x= ",x_A)
else:
equation(x_A,y_A,x_B,y_B)
Question 3 : Écrire un programme qui détermine si deux droites (AB) et (CD) sont parallèles ou
pas. Le cas où ces deux droites sont verticales sera considéré.
Réponse :
x_A=float(input("Saisir x_A "))
y_A=float(input("Saisir y_A "))
x_B=float(input("Saisir x_B "))
y_B=float(input("Saisir y_B "))
x_C=float(input("Saisir x_C "))
y_C=float(input("Saisir y_C "))
x_D=float(input("Saisir x_D "))
y_D=float(input("Saisir y_D "))
if (x_A==x_B) and (x_C==x_D):
print(" Ces deux droites sont des droites verticales parallèles")
elif ((x_A!=x_B) and (x_C!=x_D)) and (y_B-y_A)/(x_B-x_A)==(y_D-y_C)/(x_D-x_C):
print("Ces deux droites sont parallèles")
else:
print("Ces deux droites ne sont pas parallèles")
Commentaire pédagogique : la condition du elif est assez compliquée à faire comprendre. Ne pas
hésiter à faire un dessin pour représenter les différents cas possibles.
CHAPITRE 6 : TP EN FILIERE S ou ES
Objectifs et mise en œuvre
La liste de TP qui suit est encore en construction et sera remaniée puis s'étoffera par la suite. On
propose des exercices, voire des problèmes dans certains cas où l'algorithmique intervient là où la
seule intuition ne suffit plus. J'aimerais développer certains problèmes dans leur contexte naturel
pour aboutir naturellement à l'utilisation d'un logiciel de programmation, mais cela demande du
temps et n'est pas encore achevé à l'heure où j'écris ces lignes.
Les thèmes choisis sont conformes aux nouveaux programmes :
•
Étude de suites.
•
Étude de fonctions et résolution d'équations.
•
Probabilités.
A venir :
•
Géométrie
•
Arithmétique
•
Optimisation et théorie des graphes
TP Suites
Exercice 1
(niveau 1ère S)
On définit la suite de Collatz de la manière suivante :
● On se donne un entier u 0 strictement positif.
● Pour tout entier n1 , on calcule u n1 en fonction de u n de la manière suivante :
u
a) Si u n est pair, on a u n1 = n
2
b) Si u n est impair, on a u n1 = 3 u n1
On donne ci-dessous un exemple traité avec le tableur. On a choisi comme valeur initiale
u 0 = 5 et il est affiché les 21 premiers termes de cette suite.
n
0
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
un
5
16
8
4
2
1
4
2
1
4
2
1
4
2
1
4
2
1
4
2
1
1. Que remarquez-vous ?
2. Écrire à l'aide du logiciel Algobox ou Python un programme demandant à l'utilisateur de :
a) saisir à l'écran un entier u 0 strictement positif,
b) de saisir un entier n (l'indice maximum de calcul des u k )
c) et qui affiche tous les termes de u 0 à u n .
3. Tester votre programme avec u 0 = 3 puis u 0 = 7 . (faire varier n également)
4. Que remarquez-vous ?
Remarques : 1) La suite u n  définie de la manière précédente est dite définie par récurrence.
On calcule chacun de ses termes de proche en proche.
2) On ne sait toujours pas prouver ce que vous avez constaté ! C'est un problème ouvert.
Exercice 2
(niveau 1ère S)
 x0 et pour tout entier naturel n
On se donne une suite définie par récurrence par u 0=x
2
u
par u n1= n .
n1
1. Écrire un programme à l'aide du logiciel Algobox ou de Python qui :
• demande à l'utilisateur de saisir la valeur x du terme initial
• de saisir n
• renvoie la valeur de u n .
2. Tester ce programme avec x= 1,65 puis n=5, 10, 12, 15. Quelle semble être la limite de la
suite u ?
3. Tester ce programme avec x = 1,67 puis n=5, 10, 12, 15. Quelle semble être la limite de la
suite u ?
Exercice 3
(niveau Terminale S)
Le but de cet exercice est de tester pour différentes valeurs de  réel le comportement de la suite
n
1
définie pour tout entier naturel n1 par u n = ∑  .
k=1 k
1. Écrire un algorithme demandant à l'utilisateur de saisir un réel  et un entier naturel n
non nul et affichant la valeur de u n .
2. Implémentez cet algorithme à l'aide de Python. Testez le programme pour =2 et
n=1000, 10000, 106 .
3. Testez le programme pour =1 puis pour =1,5 avec les mêmes valeurs de n qu'à la
question précédente.
5. Que remarquez-vous au niveau du temps de calcul lorsque n augmente ? Pour avoir une idée
du temps de calcul, cherchez dans l'aide de Python une fonction appropriée.
6. Modifiez le programme précédent de sorte que :
• on demande à l'utilisateur la valeur de  à tester.
• Le nombre de valeurs de n à tester
• on affiche la valeur de S pour chacune des valeurs de n saisies.
7. Complétez ensuite le tableau suivant :
n
alpha
100
10000
106
107
108
109
1010
0,9
1
1,5
PS : le coût en terme de temps de calcul est une composante de ce qu'on appelle la « complexité »
de l'algorithme. Il est possible dans certains cas de le réduire en trouvant un algorithme plus efficace
aboutissant au même résultat. Mais gare à la place mémoire que cela nécessite en contrepartie !
Problème
(niveau terminale S)
Soit la fonction f définie sur [0 ; +∞[ par f  x  = x 2 – a où a est un réel strictement positif
donné. Le but de cet exercice est de trouver une « bonne approximation » de la solution x * de
l'équation f  x  = 0 .
Partie 1
On choisit a = 2.
Soit . A le point de C d'abscisse 1.
1. Donner une équation de la tangente T à C au point A. Cette dernière coupe l'axe des
abscisses en un point d'abscisse x 0 .
2. Après avoir calculé x 0 , donner une équation de la tangente T 0 à C au point d'abscisse
x 0 . Cette dernière coupe l'axe des abscisses en un point d'abscisse x 1 . Calculer x 1
et comparer x 1 à x 0 .
3. On définit ainsi une suite  x n n0 de réels de proche en proche. (on justifiera proprement
son existence un peu plus loin) Soit n un entier naturel quelconque. Donner l'expression
littérale de x n1 en fonction de x n .
4. Écrire un programme à l'aide du logiciel Python qui demande à l'utilisateur :
• de saisir la valeur de l'entier n
• renvoie la valeur de x n défini précédemment.
5. Le tester avec n=2, n=3, n=10.
Partie 2
On souhaite répondre à deux questions :
• La suite  x n n0 converge-t-elle ? Si oui, est-ce bien vers x * ?
• Évaluer la qualité de l'approximation de x * par x n , autrement dit, pour une précision
arbitraire p>0 fixée par l'utilisateur, combien nous faut-il d'itérations pour avoir
∣x* −x n∣ p ? On restreint désormais f à l'intervalle I = [1 ; 2].
Sous-partie A)
1. Quelle est la valeur exacte de x * ? Justifier que x * ∈[ 1; 2] .
2. En se servant du résultat du I)3) démontrer que pour tout entier naturel n
1
2
1
2
x n1= x n
. On posera g  x=  x  .
2
xn
2
x
3. Démontrer que g  x=x si et seulement si f  x =0 . (on s'est ramené à un problème
de point fixe).
4. On admet le résultat suivant : Soit u nn 0 une suite d'éléments d'un intervalle fermé I
telle que pour tout entier naturel n, u n1=g u n . On suppose que :
u nn 0 converge vers un réel l
•
• g est continue sur I
• ALORS on a l=g l .
a) Étudier les variations de g sur l'intervalle [1 ; 2].
b) Justifier que tous les termes de la suite  x n n0 sont bien définis et appartiennent à
I =[1 ; 2 ] (le prouver par récurrence).
c) Prouver que la suite  x n n0 est décroissante. En déduire que  x n n0 converge, et ce
vers x * .


Sous-partie B)
On pose pour tout entier naturel n, e n= x n – x * .
1 2
e puis que e n1 1 e 2n .
2 xn n
2
* 2
 x  =2 , démontrer par récurrence que pour tout entier naturel n,
5. Démontrer que e n1=
6. En remarquant que
2
 
e0
n

2
n
1
. En déduire que e n
0e n *
2
x
7. Soit p>0 la précision recherchée.. On supposera p<1. Déterminer un entier naturel N tel que
si n>N, alors e n p .
8. Écrire un programme à l'aide du logiciel Python qui demande à l'utilisateur :
• de saisir la précision recherchée p
• renvoie la valeur de x * à p près.
Remarque : Les résultats de la sous-partie B justifient à nouveau la convergence de la suite
 x n n0 vers x * .
TP Fonctions
Exercice 1
(niveau 1ère S)
Le but de cet exercice est de déterminer le nombre et une valeur approchée des solutions de
l'équation du second degré a x 2b xc=0 .
Écrire un programme à l'aide de Python qui :
1. demande à l'utilisateur de saisir les coefficients a,b et c
2. détermine le nombre de solutions de a x 2b xc=0
3. dans le cas où elles existent, écrive ces solutions.
Exercice 2
(niveau 1ère S)
Soit f une fonction dérivable sur [0 ; 2] vérifiant : pour tout réel x f '  x= f  x et f 0=1 .
On souhaite tracer la courbe représentative de f à l'aide de la méthode d'Euler.
Écrire un programme à l'aide du logiciel Python qui :
1. demande à l'utilisateur de saisir le pas h de la méthode (0<h<1).
2. découpe l'intervalle [0 ; 2] en N (à déterminer) intervalles égaux [ xi ; x i1 ] et évalue
l'image de x i par f par approximation affine. On notera y i cette évaluation.
3. trace la ligne polygonale reliant les points de coordonnées  x i ; y i  .
4. Tester ce programme avec h=0,2 ; h=0,1 ; h=0,05.
Exercice 3
(niveau Terminale S)
Données : nous disposons d'une fonction f définie sur un intervalle [a ; b] à valeurs dans
que :
• f est strictement monotone sur [a; b]
• f est continue sur [a ; b]
f a  f b0
•
ℝ telle
Alors (théorème des valeurs intermédiaires) il existe un unique réel c appartenant à ]a; b[ tel que
f c  = 0 .
Principe de la dichotomie : Supposons que l'on sache qu'il y a une racine x 0 dans l'intervalle
[a ; b]. Pour préciser sa valeur, nous allons découper [a ; b] de manière plus fine de sorte à encadrer
avec la précision voulue le réel x 0 .
ab
Posons m =
.
2
• Si f a  f m0 alors x 0 ∈[a ; m] . On pose alors a 1=a et b1=m .
• Si f a  f  m0 alors x 0 ∈[m ; b ] . On pose alors a 1=m et b1=b
On recommence en prenant l'intervalle [a1 ; b 1 ] et ainsi de suite. On obtient alors des intervalles
a nb n
∣b n−a n∣
[a 2 ; b2 ] ,..., [a n ; bn ] . Lorsque
 p , on a
= x 0 à p près.
2
2
1. Écrire un programme en Python qui étant donnés deux réels a et b (a<b) et une fonction f
continue et strictement monotone sur [a ; b], donne une approximation de x 0 à une
précision p près (p choisie par l'utilisateur). Pour simplifier on supposera f strictement
croissante sur [a ; b].
2. Testez ce programme pour les fonctions suivantes :
a) f est définie sur [-5 ; 10] par f  x  = x 32 x1
b) f est définie sur [-0,5 ; 1] par f  x  = x−cos x
Exercice 4
(niveau Terminale S)
Méthode des rectangles
Données : nous disposons d'une fonction f définie sur un intervalle [a ; b] à valeurs dans ℝ telle
que :
• f est strictement monotone sur [a; b]. Pour simplifier, on supposera f strictement croissante.
• f est continue et positive sur [a ; b]
1. Écrire une fonction subdivision(a,b,n) qui partage l'intervalle [a ; b] en n intervalles
[a k ; a k1] de longueurs égales. (on pourra conserver les a k
0k n dans une
liste).
2. Écrire une fonction aire_moins(f,subdi) qui calcule l'aire des n rectangles de base
[a k ; a k1] 0k n et de hauteur f a k  .
3. Écrire une fonction aire_plus(f,subdi) qui calcule l'aire des n rectangles de base [a k ; a k1]
0k n et de hauteur f a k 1 .
b
4. A l'aide des fonctions précédentes en déduire un encadrement de
∫ f  x  dx
selon la
a
valeur de n choisie par l'utilisateur.
5
5. Application : évaluer
∫  x 32 x 1 dx
avec n=100,400 puis n=1000.
0
Exercice 5
(Terminale S)
Méthode des trapèzes
Données : nous disposons d'une fonction f définie sur un intervalle [a ; b] à valeurs dans ℝ telle
que :
• f est strictement monotone sur [a; b]. Pour simplifier, on supposera f strictement croissante.
• f est continue et positive sur [a ; b]
1. Écrire une fonction subdivision(a,b,n) qui partage l'intervalle [a ; b] en n intervalles
[a k ; a k1] de longueurs égales. (on pourra conserver les a k
0k n dans une
liste).
2. Écrire le script principal qui calcule la somme des aires des trapèzes reliant les points de
a k ; 0  ; a k ; f a k  ;  a k1 ; 0 ; a k1 ; f a k 1  ,
0k n−1 .
coordonnées
L'utilisateur décidera de la valeur de n.
5
3. Tester le programme avec n=50, 100, 500 pour évaluer
∫  x 32 x 1 dx
0
.
TP Statistiques-Probabilités
Exercice 1
(niveau 1ère S)
On considère le jeu suivant dont la mise est de 2€ : on lance deux dés parfaits à 6 faces et on
s'intéresse à la somme obtenue.
• Si la somme est entre 6 et 8 (compris) on perd sa mise.
• Si la somme est 5 ou 9 on gagne 2€.
• Si la somme est 4 ou 10 on gagne 5€.
• Si la somme est 3 ou 11 on gagne 10€.
• Si la somme est 2 ou 12 on gagne 50€.
1. Intéressons-nous pour le moment de manière théorique à la somme des nombres obtenus
sur la face supérieure de chacun des 2 dés.
a. Compléter le tableau suivant par la valeur de la somme des deux dés.
Dé 1
Dé 2
1
2
3
4
5
6
1
2
3
4
5
6
b. Quelles sont les différentes valeurs possibles pour cette somme ?
Compléter le tableau suivant :
Somme
Total
Fréquence
théorique
d’apparition
2. Soit X la variable aléatoire égale au gain (algébrique) du joueur : on tient donc compte de la
mise !!
a) Compléter le tableau suivant :
xi
-2
0
3
8
48
P  X =x i 
Valeur
approchée à
0,01 près
b) Calculer l'espérance de X (valeur exacte puis à 0,01 près). Que représente ce nombre
c) Calculer la variance de X puis l'écart-type  X  . Interpréter ces nombres.
3. Simulation informatique.
simulation avec un lancer de n dés
Écrire un programme avec Python qui :
• demande à l'utilisateur le nombre n de lancers
• calcule sur ces n lancers le gain moyen de l'utilisateur.
4. Comparer avec le résultat de la question b pour n = 50, 200 puis 5000 lancers.
Exercice 2
(niveau Terminale S)
On souhaite répondre au problème suivant : Une urne U1 contient 2 boules rouges, 3 boules bleues
et 5 boules vertes ; une urne U2 contient 4 boules rouges et 5 boules bleues, tandis qu'une troisième
urne U3 contient 3 boules bleues et 6 boules vertes. On procède alors à l'expérience suivante :
on tire au hasard une boule de l'urne U 1 que l'on place dans l'urne U 2, puis on tire au hasard une
boule de l'urne U2 que l'on place dans U3. Enfin, on tire au hasard une boule de U 3 que l'on place
dans U1.
Quelle est la probabilité que la composition de l'urne U1 n'ait pas changé à l'issue de ces 3
manipulations ?
1. Nous allons d'abord modéliser le problème par un programme utilisant l'approche
fréquentiste des probabilités. Pour cela, on demandera à l'utilisateur de saisir le nombre n
d'expériences aléatoires à reproduire, puis on simulera le tirage d'une boule dans l'urne
U 1 , puis ceux dans U 2 et U 3 et enfin la dernière composition acquise par U 1 .
On comptera alors les cas où la composition de U 1 n'a pas varié.
Variables à utiliser : nb_rouges1, nb_bleues1, nb_vertes1, nb_rouges2, nb_bleues2, nb_vertes2,
nb_rouges3, nb_bleues3, nb_vertes3 à initialiser dans chaque cas ; a qui simulera le numéro de la
boule tirée dans les urnes 1, 2 et 3 et enfin i (un compteur), cas_favorables (un autre compteur) et n.
Pour simuler le tirage au hasard, on pourra supposer numérotées les boules présentes dans chaque
urne (à vous de voir comment procéder) et utiliser la fonction randint.
2. En utilisant la formule des probabilités totales, répondre à la question de manière théorique.
On pourra noter Bi , V i , Ri les événements : « Au ième tirage la boule est
respectivement bleue, verte, rouge » (i=1, 2, 3).
3. Tester le programme avec n=100, n=1000, n=5000 et comparer avec le résultat précédent.
Analyse et corrigé des TP
TP Suites
Exercice 1
(niveau 1ère S)
On définit la suite de Collatz de la manière suivante :
● On se donne un entier u 0 strictement positif.
● Pour tout entier n1 , on calcule u n1 en fonction de u n de la manière suivante :
u
a) Si u n est pair, on a u n1 = n
2
b) Si u n est impair, on a u n1 = 3 u n1
Réponse :
N'oublions pas l'opérateur modulo % qui sert à déterminer si un entier est divisible par un autre. Par
exemple si a%b = 0 ceci signifie que a est divisible par b. Partant de cette remarque, on peut définir
parfaitement la suite de Collatz.
Algorithme
écrire "saisir un entier positif u"
saisir u
écrire "Combien de termes à calculer ? "
lire n
i←0
Tant que i<n faire
Si u est divisible par 2 faire
u ← u/2
Afficher u
Sinon faire
u ← 3*u+2
Afficher u
i ← i+1
Avec Python
u=int(input("Saisir le premier terme de la suite
(entier positif) "))
n=int(input("Combien de termes de la suite
voulez-vous calculer ?"))
i=0
while i<n:
if u%2==0:
u=u/2
print(int(u))
# pourquoi int(u) ?
else:
u=3*u+1
print(int(u))
i=i+1
Exercice 2
(niveau 1ère S)
On se donne une suite définie par récurrence par u 0=x ,  x0 et pour tout entier naturel n
u2
par u n1= n .
n1
2. Écrire un programme à l'aide de Python qui demande à l'utilisateur :
• de saisir la valeur x du terme initial
• de saisir n
• renvoie la valeur de u n .
On aura besoin de trois variables : u, n et i (un compteur car la suite est définie par récurrence donc
les termes se calculent de proche en proche).
Algorithme
Avec Python
écrire "saisir un réel positif u (valeur initiale) "
lire u
écrire "saisir un entier positif n "
lire n
i←0
Tant que i<n faire
u ← u²/(n+1)
i ← i+1
u=float(input("Saisir le premier terme de la suite
(réel positif) "))
n=int(input("Saisir n "))
i=0
while i<n:
u=u**2/(i+1)
i=i+1
print(u)
Afficher u
Remarque : on peut fabriquer un tableau en faisant varier le terme initial u et n. Que remarquezvous ?
Exercice 3
(niveau Terminale S)
Le but de cet exercice est de tester pour différentes valeurs de  réel le comportement de la suite
n
1
définie pour tout entier naturel n1 par u n = ∑  .
k =1 k
1. Écrire un algorithme demandant à l'utilisateur de saisir un réel  et un entier naturel n
non nul et affichant la valeur de u n .
2. Implémentez cet algorithme à l'aide de Python. Testez le programme pour =2 et
n=1000, 10000, 106 .
3. Testez le programme pour =1 puis pour =1,5 avec les mêmes valeurs de n qu'à la
question précédente.
4. Que remarquez-vous au niveau du temps de calcul lorsque n augmente ? Pour avoir une idée
du temps de calcul, cherchez dans l'aide de Python une fonction appropriée.
5. Modifiez le programme précédent de sorte que :
• on demande à l'utilisateur la valeur de  à tester.
• Le nombre de valeurs de n à tester
• on affiche la valeur de S pour chacune des valeurs de n saisies.
6. Complétez ensuite le tableau suivant :
n
alpha
100
10000
106
107
108
109
1010
0,9
1
1,5
Réponse :
Question 1 et 2 : Nous allons avoir besoin de plusieurs variables :  (paramètre), n, k un
compteur destiné à varier entre 1 et n, et enfin u.
L'algorithme est très proche de l'exemple phare du cours servant à calculer
S=12…99100 .
Algorithme
écrire "saisir un réel positif  "
lire 
écrire "saisir un entier positif n "
lire n
k←1
u←0
Tant que k<=n faire
u ← u1/ k 
k ← k+1
Avec Python
alpha=float(input("Saisir un réel positif alpha "))
n=int(input("Saisir un entier positif n "))
k=1
u=0
while k<=n:
u=u+1/(k**alpha)
k=k+1
print(u)
afficher u
Question 4 : Le temps de calcul augmente énormément lorsque n grandit.
Question 5 : il suffit de rajouter une boucle permettant d'afficher tous les u n demandés. Ceci
nécessite l'utilisation d'une autre variable que l'on appellera nb_de_n et d'un autre compteur variant
de 1 à nb_de_n que l'on appellera i. Notons que ce programme permettra de remplir le tableau de la
question 6 assez rapidement.
Algorithme
écrire "saisir un réel positif  "
lire 
écrire "combien de valeurs u n à calculer ? "
lire nb_de_n
i←1
Tant que i<=nb_de_n faire
écrire "saisir l\'entier n choisi "
lire n
k←1
u←0
Tant que k<=n faire
u ← u1/ k 
k ← k+1
Avec Python
alpha=float(input("Saisir un réel positif alpha "))
nb_de_n=int(input("Combien de valeurs de u_n
à calculer ? "))
i=1
while i<=nb_de_n:
n=int(input("Saisir l\'entier n choisi "))
k=1
u=0
while k<=n:
u=u+1/k**alpha
k=k+1
print("u_",n,"est égal à ",u)
i=i+1
écrire "u_n est égal à "
afficher u
i=i+1
Problème (niveau Terminale S)
Partie 1
Question 1 : f est une fonction polynôme donc est dérivable sur ℝ et pour tout réel x,
f '  x = 2 x . T a pour équation y= f ' 1 x −1 f 1 , soit après calculs y = 2 x −3 .
3
3
. Donc x 0= . Pour déterminer
2
2
x
, on cherche l'équation de la tangente à C au point d'abscisse
0 . C a pour équation :
Question 2 : T coupe l'axe des abscisses au point d'abscisse
x1
y= f '
x 1=
    
3
2
x–
17
. On a
12
3
3
f
2
2
, soit après calculs :
y=3 x –
17
. On en déduit immédiatement
4
x 1x 0 .
Question 3 : L'existence de chacun des termes de la suite  x n n0 est assurée par la dérivabilité de
f sur ℝ et du fait que aucun x n n'est nul (justifié plus loin). T n la tangente à C au point
d'abscisse x n a pour équation : y= f '  x n  x−x n  f  x n  , soit y=2 x n  x−x n x 2n – 2 .
Cette dernière coupe l'axe des abscisses au point d'abscisse x n1 (par définition). D'où
x
1
x n1= n 
.
2 xn
x n et le programme en Python.
Question 4 : On donne l'algorithme de construction des
Algorithme
Avec Python
écrire "saisir le terme initial de la suite "
lire x
écrire "saisir n "
lire n
i←0
Tant que i<=n faire
x 1
x← 
2 x
i ← i+1
x=float(input("saisir le terme initial de la suite "))
n=int(input("saisir n "))
i=0
while i<=n:
x=x/2 + 1/x
i=i+1
print(x)
Afficher x
Question 5 : do it alone !
Partie 2
Sous-partie A
Question 1 : Par définition de x * on a  x *2=2 et x *0 donc x *= 2 .
f 20 donc d'après le théorème des valeurs intermédiaires, x * ∈[1; 2]
Question 2 : Soit n∈ℕ .
Question 3 : Soit
x n1=
x ∈[1 ; 2] .
xn 1 1
2
 = x n
2 xn 2
xn


, soit
f 10
et
x n1= g  x n  .
1
2
2
g  x= x ⇔  x  =x ⇔ = x ⇔ x 2=2 ⇐ f  x=0 .
2
x
x
Question 4 :
x ∈[1 ; 2]
a) g est dérivable sur [1 ; 2] (théorèmes généraux) et pour tout
2
1
2
x –2
g '  x = 1 – 2 =
g ' x
.
est du signe de
x 2 – 2 . On en déduit que
2
x
2 x2
*
*
g '  x 0 sur [1 ; x ] et g '  x 0 sur [ x ; 2 ] .
En vertu d'un théorème du cours g est décroissante sur [1 ; x* ] et croissante sur [ x* ; 2] .
De plus g  x* =x * . D'où le tableau de variations :
 
x
Signe de
x*
1
g ' x
−
2
+
0
1,5
1,5
Variations de g
g 1=1,5 ;
x*
g  2=1,5
b) Posons pour tout n entier naturel (HRn) :
x n existe et
x n ∈[1 ; 2] .
x 0=1,5 donc (HR0) est vraie.
Soit n un entier naturel quelconque. Supposons (HRn) vraie.
Comme x n ∈[ 1 ;2 ] on peut définir g  x n . Or x n1= g  x n  . En vertu du tableau de
variations de g, x n1 ∈[ x * ;1,5]⊂[1 ;2] . Donc (HRn+1) est vraie.
On en déduit que (HRn) est vraie pour toutes les valeurs de n.
•
•
•
Remarque : pour tout n0 on a
*
x n ∈[x ;1,5] . Ceci sert notamment pour ce qui suit.
c)
De ce qui précède on déduit que la suite x est minorée par 1. Soit n entier naturel
2
* 2
2
−1
1 2 – xn  x  − xn
quelconque. x n1− x n=
x n =
=
. On en déduit que x n1− x n est du
2
xn 2 xn
2 xn
signe de x *−x n , quantité négative en vertu de la remarque précédente. La suite x est donc
décroissante. Étant décroissant et minorée, la suite x converge, notons vers l. l0
De x n1= g  x n  et de la continuité de g on a en vertu du résultat admis, l=g l . Soit
f l=0 . Or x * est l'unique racine de f sur [1 ; 2] donc l=x * .
Sous partie 2
Question 5 : Commençons par remarquer que pour tout entier naturel n e n0 . Soit n un entier
2
* 2
2
2−x n
1
2
*
*
*
*  x  −x n
− x =x n1− x nx n −x =
x n −x =
 x n− x*
naturel. e n1= x n1−x = x n
2
xn
2 xn
2 xn


*
x  x n  x n−x * 2 e 2n
=
=
D'où e n1= x n− x 1−
.
2 xn
2 xn
2 xn
1
1
 . On en déduit immédiatement que
Or pour tout entier naturel n x n 1 donc
2 xn 2
1 2
e n1 e n .
2
*
2
 
Question 6 : Posons pour tout entier naturel n, (HRn) : 0e n
2

e0
e0
x*
3
*
*
=1 . Or e 0= x 0−x = − x . Comme
2
Quand n=0 ,
•
(HR0) est vraie.
Soit n un entier naturel quelconque. Supposons (HRn) vraie.
x
.
n
•
*
n
1
x *1 , e 0 2 . donc
1 2
e n1 e n . Or par hypothèse de récurrence (et croissance de la
2
2
2
e0
1 e0
2
fonction carré sur [0 ; +∞[ ), 0e n *
, d'où e n1
. Donc (HRn+1) est
2 x*
x
vraie.
2
e
On en déduit que pour tout entier naturel n, 0e n 0*
.
x
e0 1
1
 . Donc pour tout entier naturel n, on a :
Comme e 0
et x *1 , on en déduit que
2
x* 2
D'après la question 5
•
 
n1

 

1
0e n
2
2
n1
n
n
.
Question 7 : Soit p ∈] 0 ; 1 [ . Alors :
2
2
1
1
1
ln p
ln p
 p ⇔ln
ln p ⇔ 2n ln
ln p ⇔2 n
⇔n ln 2ln
2
2
2
1
1
ln
ln
2
2

n
=ln

  
ln p
1
ln
2
supérieur à
n
, on a

2

1
2

  
.
En
posant
n
 p ⇔n

. On choisit pour N le plus petit entier naturel
ln 2

.
ln 2
Question 8 :
Algorithme
écrire "saisir le terme initial de la suite "
lire x
écrire "saisir la précision p"
lire p
n←0
Tant que (1/2)**(2**n)>p faire
x 1
x← 
2 x
n ← n1
écrire "une valeur approchée de la racine est"
Afficher x
Avec Python
x=float(input("saisir le terme initial de la suite "))
p=float(input("saisir la précision p"))
n=0
while (1/2)**(2**n)>p:
x=x/2 + 1/x
n=n+1
print("une valeur approchée de la racine est",x)
TP Fonctions
Exercice 1
(niveau 1ère S)
Le but de cet exercice est de déterminer le nombre et une valeur approchée des solutions de
l'équation du second degré a x 2b xc=0 .
Écrire un programme à l'aide du logiciel Python qui :
1. demande à l'utilisateur de saisir les coefficients a,b et c
2. détermine le nombre de solutions de a x 2b xc=0
3. dans le cas où elles existent, écrive ces solutions.
Réponse :
Algorithme
écrire "saisir les coefficients de l'équation"
lire a
lire b
lire c
delta ← b^2-4*a*c
Si delta>0 faire
écrire "il y a deux solutions"
−b− delta
afficher
2a
−b delta
afficher
2a
Sinon si delta=0 faire
écrire "il y a une solution"
−b
afficher
2a
Sinon faire
écrire "pas de solution"
Avec Python
from math import sqrt
print("saisir les coefficients de l\'équation")
a=float(input("a ? "))
b=float(input("b ? "))
c=float(input("c ? "))
delta=b**2-4*a*c
if delta>0:
print("il y a deux solutions ")
print("x_1 = ",(-b-sqrt(delta))/(2*a))
print("x_2 = ",(-b+sqrt(delta))/(2*a))
elif delta==0:
print("il y a une solution ")
print("x_0 = ",-b/(2*a))
else:
print("pas de solution")
Exercice 3
(niveau Terminale S)
Données : nous disposons d'une fonction f définie sur un intervalle [a ; b] à valeurs dans ℝ telle
que :
• f est strictement monotone sur [a; b]
• f est continue sur [a ; b]
f a  f b0
•
•
Alors (théorème des valeurs intermédiaires) il existe un unique réel c appartenant à ]a; b[ tel que
f c  = 0 .
1. Écrire un programme en Python qui étant donnés deux réels a et b (a<b) et une fonction f
continue et strictement monotone sur [a ; b], donne une approximation de x 0 à une
précision p près (p choisie par l'utilisateur). Pour simplifier on supposera f strictement
croissante sur [a ; b].
2. Testez ce programme pour les fonctions suivantes :
a) f est définie sur [-5 ; 10] par f  x  = x 32 x 1
b) f est définie sur [-0,5 ; 1] par f  x  = x−cos x
Réponse : on ne donne la correction que pour la fonction polynôme du 2)a) avec Python et
l'algorithme général quelle que soit la fonction f choisie.
Algorithme
écrire "saisir la borne inférieure a "
lire a
écrire "saisir la borne supérieure a "
lire b
Tant que (b-a)>2p faire
c ← (a+b)/2
Si f(a)f(c)<0 faire
b←c
Sinon faire
a←c
x ← (a+b)/2
Avec Python
def f(x):
return x**3+2*x+1
def dico(y,a,b,p):
global x
while (b-a)>2*p:
c=(a+b)/2
if f(a)*f(c)<0:
b=c
else:
a=c
x=(a+b)/2
print("la solution de f(x)=0 est dans [",x-p";",x+p,"]")
écrire "la solution de f(x) = 0 est à p
près"
# programme principal
Afficher x
from math import *
a=float(input("saisir la borne inf de l\'intervalle "))
b=float(input("saisir la borne sup de l\'intervalle "))
p=float(input("saisir la précision p "))
dico(f,a,b,p)
Exercice 4 : méthode des rectangles. (niveau Terminale S)
Réponse :
#subdivision d'une intervalle fermé borné
def subdivision(a,b,n):
global subdi
subdi=[]
i,c=0,0
while i<=n:
c=a+i*(b-a)/n
subdi.append(c)
i=i+1
return subdi
#définition de la fonction f
def f(x):
return x**3 + 2*x+1
# création des points de la subdivision
#aire des rectangles inférieurs
def aire_moins(f,subdi):
global aire1
i,aire1=0,0
while i<n:
aire1=aire1+(subdi[i+1]-subdi[i])*f(subdi[i])
i=i+1
return aire1
#aire des rectangles supérieurs
def aire_plus(f,subdi):
global aire2
i,aire2=0,0
while i<n:
aire2=aire2+(subdi[i+1]-subdi[i])*f(subdi[i+1])
i=i+1
return aire2
#programme principal
a=float(input("Entrer la borne inférieure de l\'intervalle "))
b=float(input("Entrer la borne supérieure de l\'intervalle "))
n=int(input("Saisir n "))
subdivision(a,b,n)
aire_moins(f,subdi)
aire_plus(f,subdi)
print("La valeur de l\'intégrale de ",a," à ",b," de f appartient à [", aire1," ; ",aire2,"]")
Exercice 5 : méthode des trapèzes. (niveau Terminale S)
Réponse :
#subdivision d'une intervalle fermé borné
def subdivision(a,b,n):
global subdi
subdi=[]
i,c=0,0
while i<=n:
c=a+i*(b-a)/n
subdi.append(c)
i=i+1
return subdi
# création des points de la subdivision
#définition de la fonction f
def f(x):
return x**3 + 2*x+1
# programme principal
a=float(input("Entrer la borne inférieure de l\'intervalle "))
b=float(input("Entrer la borne supérieure de l\'intervalle "))
n=int(input("Saisir n "))
subdivision(a,b,n)
i,aire=0,0
while i<n:
aire=aire+(f(subdi[i+1]+f(subdi[i]))*(subdi[i+1]-subdi[i])/2
i=i+1
print("La valeur de l\'intégrale de ",a," à ",b," de f est environ ",aire)
Prolongement des exercices 4 et 5 : estimation de l'erreur (conformément au programme, on
n'exposera pas de méthode générale, mais on répondra uniquement avec les fonctions proposées).
TP Statistiques-Probabilités
Exercice 1
(niveau 1ère S)
On considère le jeu suivant dont la mise est de 2€ : on lance deux dés parfaits à 6 faces et on
s'intéresse à la somme obtenue.
• Si la somme est entre 6 et 8 (compris) on perd sa mise.
• Si la somme est 5 ou 9 on gagne 2€.
• Si la somme est 4 ou 10 on gagne 5€.
• Si la somme est 3 ou 11 on gagne 10€.
• Si la somme est 2 ou 12 on gagne 50€.
1. Intéressons-nous pour le moment de manière théorique à la somme des nombres obtenus
sur la face supérieure de chacun des 2 dés.
a) Compléter le tableau suivant par la valeur de la somme des deux dés.
Dé 1
Dé 2
1
2
3
4
5
6
1
2
3
4
5
6
2
3
4
5
6
7
3
4
5
6
7
8
4
5
6
7
8
9
5
6
7
8
9
10
6
7
8
9
10
11
7
8
9
10
11
12
b) Quelles sont les différentes valeurs possibles pour cette somme ? Il y en a 11
Compléter le tableau suivant :
Somme
2
3
4
5
6
7
8
9
Fréquence
théorique
d’apparition
1
36
2
36
3
36
4
36
5
36
6
36
5
36
4
36
10
11
3
36
2
36
12
Total
1
36
1
2. Soit X la variable aléatoire égale au gain (algébrique) du joueur : on tient donc compte de la
mise !!
a) Compléter le tableau suivant :
xi
-2
0
3
8
48
P  X =x i 
16
36
8
36
6
36
4
36
2
36
Valeur
approchée à
0,01 près
0,44
0,22
0,17
0,11
0,06
b)
EX  = −
2×16 0×8 3×6 8×4 48×2
114




=
, soit E(X) ≈ 3,17€.
36
36
36
36
36
36
Ce nombre représente le gain moyen. À ce jeu. Si l'utilisateur jouait un très grand nombre de
parties, il gagnerait en moyenne 3,17€ par partie.
c)
V  X  = E  X 2  – E  X 2 .
Soit
en
détaillant
les
calculs
2
2
4×16 9×6 64×4 48 ×2 114
166356
, soit V(X) ≈ 128,36. On a
VX  =



−
=
36
36
36
36
36
1296
  X =  E  X  , soit  X ≈11,33 . Ces nombres servent à mesurer les écarts des gains à la
moyenne.
 
3. Simulation pour un lancer de n dés
Analyse : on simulera le lancer d'un dé avec la commande randint(1,6), après l'avoir apportée via la
bibliothèque random. On aura besoin des variables n (nombres d'essais), i (compteur variant de 1 à
n), gain et somme.
Algorithme
Avec Python
from random import randint
écrire "Combien de parties voulez-vous jouer ?"
lire n
i←1
gain ← 0
Tant que i<=n faire
somme=entier_aléatoire_entre1_et_6+entier_
aléatoire_entre1_et_6
Si somme>=6 et somme<=8 faire
gain ← gain – 2
Sinon si somme=4 ou somme=10 faire
gain ← gain + 3
Sinon si somme=3 ou somme=11 faire
gain ← gain + 8
Sinon si somme=2 ou somme=12 faire
gain ← gain + 48
i ← i+1
Afficher gain/n
n=int(input("Combien de parties voulez-vous
jouer ? "))
i=1
gain=0
while i<=n:
somme=randint(1,6)+randint(1,6)
if somme>=6 and somme<=8:
gain=gain-2
elif somme==4 or somme==10:
gain=gain+3
elif somme==3 or somme==11:
gain=gain+8
elif somme==2 or somme==12:
gain=gain+48
i=i+1
print("Le gain moyen est de ",gain/n)
Commentaire pédagogique : Pas besoin de else à la fin car l'alternative au cas où la somme des deux
dés est 5 ou 9 est de ne pas incrémenter le gain.
Exercice 2
(niveau Terminale S)
On souhaite répondre au problème suivant : Une urne U1 contient 2 boules rouges, 3 boules bleues
et 5 boules vertes ; une urne U2 contient 4 boules rouges et 5 boules bleues, tandis qu'une troisième
urne U3 contient 3 boules bleues et 6 boules vertes. On procède alors à l'expérience suivante :
on tire au hasard une boule de l'urne U 1 que l'on place dans l'urne U 2, puis on tire au hasard une
boule de l'urne U2 que l'on place dans U3. Enfin, on tire au hasard une boule de U 3 que l'on place
dans U1.
Quelle est la probabilité que la composition de l'urne U1 n'ait pas changé à l'issue de ces 3
manipulations ?
Réponse : on ne donne que le programme en Python. L'algorithme se déduit du texte.
from random import randint
n=int(input("saisir le nombre d\'essais "))
i=1
cas_favorables=0
while i<=n:
nb_rouges1,nb_bleues1,nb_vertes1=2,3,5
nb_rouges2,nb_bleues2,nb_vertes2=4,5,0
nb_rouges3,nb_bleues3,nb_vertes3=0,3,6
a=randint(1,10)
if a<=2:
nb_rouges2=nb_rouges2+1
nb_rouges1=nb_rouges1-1
elif a<=5:
nb_bleues2=nb_bleues2+1
nb_bleues1=nb_bleues1-1
else:
nb_vertes2=nb_vertes2+1
nb_vertes1=nb_vertes1-1
a=randint(1,10)
if a<=nb_rouges2:
nb_rouges3=nb_rouges3+1
elif a<=nb_rouges2+nb_bleues2:
nb_bleues3=nb_bleues3+1
else:
# quand bien même aucune boule verte ne provient de
nb_vertes3=nb_vertes3+1
# l'urne 2 : cas où nb_rouges2+nb_bleues2 = 10
a=randint(1,10)
if a<=nb_rouges3:
nb_rouges1=nb_rouges1+1
elif a<=nb_rouges3+nb_bleues3:
nb_bleues1=nb_bleues1+1
else:
nb_vertes1=nb_vertes1+1
# idem avec les urnes 3 et 1
if nb_rouges1==2 and nb_bleues1==3 and nb_vertes1==5:
cas_favorables=cas_favorables+1
i=i+1
print("Sur ces ",n,"essais la composition de l\'urne n\'a pas changé en proportion de
",cas_favorables/n)
Bibliographie
Gérard Swinnen : Apprendre à programmer avec Python 3 – aux éditions
Eyrolles
Bob Cordeau : Introduction à Python – notes de cours et TP à l'IUT de mesures
physiques d'Orsay