2nd-Python CNED 2021-2022

ACTIVITÉ 1.
Algorithmique
Objectifs
• Revoir les notions d’algorithme, de programme et de variable,
• Résumer les principales instructions et notations utilisées en algorithmique,
• Apprendre à tester un algorithme,
• À partir d’un algorithme donné, déterminer le problème qu’il permet de résoudre,
• Au travers des exemples choisis, travailler vos savoirs sur les nombres.
L’INRIA (Institut National de Recherche en Informatique et Automatisme), propose la définition suivante

d’un algorithme :
« Un algorithme, c’est une suite de tâches élémentaires qui s’enchaînent selon des règles précises, sans
place pour l’interprétation personnelle. “Additionner deux chiffres, écrire la somme au-dessous et la
retenue à gauche” peut faire partie d’un algorithme ; mais “faire cuire à point, saler à votre goût”, c’est
juste une recette !
On peut décrire un algorithme en français, en chinois ou dans toute autre langue... Traduit dans un
langage de programmation, il devient un programme informatique exécutable par un ordinateur (PC,
téléphone, automate,…). »
Source : l’informatique de A à Z – INRIA
Historiquement, le mot algorithme est une déformation du nom du mathématicien
arabe, ou plus exactement persan, Al Khwarizmi (788-850) latinisé au Moyen-Âge
en Algoritmi. Le « z » est devenu « t » sous l›influence du mot grec arithmos (qu’on
retrouve aujourd’hui dans arithmétique) parce que le mot ainsi créé avait une
consonnance plus mathématique !
Al Khwarizmi fut l’un des premiers à décrire les règles de manipulations sur les
nombres entiers.
Exemple.
Lorsque l’on cherche un mot dans un dictionnaire, on applique généralement l’algorithme suivant.
On ouvre le dictionnaire au hasard.
On compare la première lettre du mot avec celle du premier mot de la page où le dictionnaire
est ouvert. Suivant les positions relatives dans l’ordre alphabétique de ces deux lettres, on
tourne les pages en avant ou en arrière. On recommence avec les deuxièmes, troisièmes, …
lettres jusqu’à trouver la page contenant le mot.
On recommence à comparer les lettres dans l’ordre d’apparition du mot avec celles des mots de
la page jusqu’à trouver le mot.
L’objet obtenu à partir de cet algorithme est la définition du mot cherché.
CNED – SECONDE – MATHÉMATIQUES 1

En bref, un algorithme sert à résoudre un problème, c’est-à-dire à répondre à une question ou plusieurs
questions plus ou moins complexes. Dans l’exemple précédent, nous répondons à la question
« comment trouver un mot dans un dictionnaire ? ».
Les algorithmes permettent de répondre à des problèmes très variés et complexes : simuler
l’évolution du climat, sécuriser des données, créer des moteurs de recherche, prouver des théorèmes
mathématiques…
Définitions et notations en algorithmique

Les variables permettent d’associer un nom à une valeur, généralement la valeur d’une variable change
lors de l’exécution du programme. Une variable est l’association d’une étiquette et d’une boîte pouvant
contenir une donnée.
Donnée
Étiquette
Variable
Image modifiée illustrative de la notion de variable
Crédits : Murata Yuki
Collection : iStock / Getty Images Plus
Instructions Notation algorithmique Exemple

Affectation Nom de la variable ← Valeur A←4
Entrée Saisir Variable Saisir X
Sortie Afficher Variable Afficher X
Conditionnelle Si Condition Alors Si X<=4 Alors
Traitement 1 Y = 2*X
Sinon Sinon
Traitement 2 Y=0
Fin Si Fin Si
Boucle bornée Pour Variable variant de Début à Fin faire Pour i variant de 1 à 5 faire
Traitement S ← S+ i
Fin Pour Fin Pour
Boucle non Tant que Condition faire Tant que r ≥ 42 faire
bornée
Traitement q ← q+1
Fin Tant que r ← r − 42
Fin Tant que
Tester un algorithme et suivre les variables

Pour tester nos algorithmes, nous utiliserons des tableaux de suivi des variables et des conditions. À
chaque ligne d’exécution de l’algorithme, correspond une ligne dans le tableau de suivi avec les valeurs
des variables et des conditions après exécution de cette ligne d’algorithme.
2 CNED – SECONDE – MATHÉMATIQUES

Algorithme 1 Test et suivi
Ligne de Ligne de l’algorithme exécutée i S

Instruction
l’algorithme
L1 0
L1 S←0 L2 1
L2 Pour i variant de 1 à 5 L3 1
faire
L2 2
L3 S ← S+ i
L3 3
L4 Fin Pour
L2 3
L3 6
L2 4
L3 10
L2 5
L3 15
L4
Algorithme 2 Test et suivi
Ligne de Ligne de
Instruction
l’algorithme l’algorithme r ≥ 42 ? q r
exécutée
L1 r ← 100
L2 q←0 L1 100
L3 Tant que r ≥ 42 faire L2 0
L4 q ← q+1 L3 True
L5 r ← r − 42 L4 1
L6 Fin Tant que L5 58
L3 True
L4 2
L5 16
L3 False
L6
Pour simplifier, on peut regrouper les lignes d’initialisation des variables (L1 et L2) lorsque celles-ci sont
indépendantes. On peut aussi regrouper la ligne associée à l’instruction Tant que (L3) avec les lignes de
traitement (ici L4 et L5). On obtient le tableau suivant.
r ≥ 42 ? q r
Initialisation 0 100
True 1 58
Traitement True 2 16
False
Le quotient de la division entière (ou euclidienne) de100 par 42, est 2 car 100 = 2 × 42 + 16. Notre
algorithme permet de calculer ce quotient et le reste, il s’agit respectivement de la valeur de q et de r.
Exercice A. On se donne deux entiers a et b avec a > b. Écrire un algorithme qui calcule le quotient et le
reste de la division entière de a par b.
Tester votre algorithme pour a = 100 et b = 42, puis pour a = 100 et b = 25.

Solution. On adapte l’algorithme 2.
r←a
q←0
Tant que r ≥ b faire
q ← q+1
r ← r−b
Fin Tant que
Pour a = 100 et b = 42, on retrouve notre algorithme précédent que nous avons déjà testé et suivi.
Testons pour a = 100 et b = 25.
r ≥ 25 ? q r
Initialisation 0 100
True 1 75
True 2 50
Traitement True 3 25
True 4 0
False
Remarque. Si on remplace la condition r ≥ b par r > b, l’algorithme ne fonctionne pas dans le cas où a est
un multiple de b.
Exercice B. Approximation de 2
On trouve, dans les anciens livres indiens dénommés Sullasutras (800-200av.J. C.), une approximation de
2 définie par ces mots: « On augmente la longueur du côté par un tiers et ce tiers par son quart et on
retranche le trente-quatrième de ce quart ».
On obtient A = 1 + 1 + 1 − 1 .
3 3 × 4 3 × 4 × 34
p
1. Mettre A sous forme d’une fraction irréductible.
q
Solution. A = 577 avec 577 qui est un nombre premier.
408
2. Peut-on avoir A = 2 ? Expliquer votre réponse sans utiliser de calculatrice.
Solution. Si A = 2 alors A2 = 2 et donc 5772 = 2 × 4082 or 5772 = 332929 est impair et 2 × 4082
est pair donc l’égalité est impossible.
3. Calculer la différence entre 2 et A, cette différence s’appelle l’erreur commise en approchant 2 par
le nombre A.
Solution. Avec la calculatrice, on obtient une approximation de A = 577 ≈ 1, 4142568 puis de

408
2 − A ≈ −0,000002 soit 2 − A ≈ −2 × 10−6.
4. Encadrons cette différence entre −10− p et 10− p où p est le plus grand entier naturel possible.
Pour cela, on va compléter le tableau suivant :
Valeur de p Encadrement Vrai ou faux ?
1 −0,1 ≤ 2 − A ≤ 0,1 Vrai
2 −0,01 ≤ 2 − A ≤ 0,01 …
…

Solution.
Valeur de p Encadrement Vrai ou faux ?
1 −0,1 ≤ 2 − A ≤ 0,1 Vrai
2 −0,01 ≤ 2 − A ≤ 0,01 Vrai
3 −0,001 ≤ 2 − A ≤ 0,001 Vrai
4 −0,0001 ≤ 2 − A ≤ 0,0001 Vrai
5 −0,00001 ≤ 2 − A ≤ 0,00001 Vrai
6 −0,000001 ≤ 2 − A ≤ 0,000001 Faux
L’entier cherché est donc p = 5 et on a l’encadrement −10−5 ≤ 2 − A ≤ 10−5. On dit que l’on a un
encadrement à 10−5 près de l’erreur.
5. On considère les nombres de la forme F = 1 + 1 + 1 − 1 où n est un entier naturel non nul.

3 3×4 3×4×n
Le nombre A est de cette forme avec n = 34.
On considère l’algorithme suivant :
n←1
erreur ← 2 − ⎛⎜1 + 1 ⎞⎟
⎝ 3⎠
Tant que erreur ≥ 10−5 ou erreur ≤ −10−5 faire
n ← n+ 1
F ←1 + 1 + 1 − 1
3 3×4 3×4×n
erreur ← 2 − F
Fin Tant que
Que fait cet algorithme ?
Solution. Cet algorithme permet de trouver le plus petit entier n tel que le nombre F soit une approxi-
mation de 2 avec une erreur comprise entre −10−5 et10−5.
En programmant cet algorithme, on obtient n = 34.

SEQUENCE 2 – CALCUL LITTÉRAL
CHAPITRE 4
TP2. Variables, entrées et sorties en Python
1. Objectifs
• Utiliser les variables, les types et faire des affections en Python. En particulier, introduire les types de
nombres (entier, flottant), le type chaîne de caractères et le type booléen.
• Faire des entrées-sorties en Python.
2. Variables et affectation
Exercice A. Variables, types et affectation

Entrer les instructions suivantes dans l’interpréteur et observer les résultats obtenus.
>>> a = 2
>>> type(a)
>>> b = 3.7
>>> c = a + b
>>> c
>>> c = c + 1
>>> type(c)
>>> nom = ’’Eddy’’
>>> verbe = ’’ joue’’
>>> nom + verbe
>>> type(nom)
>>> E = c == 6.7
>>> E
>>> type(E)
Nous mettrons entre <> les noms des variables et parfois les instructions pour bien les séparer du texte
explicatif.

Solution
Exécution dans l’interpréteur Commentaires
Une variable est une « case » dans la mémoire où l’on

place une valeur.
En python, les variables sont typées. Ici, la variable <a>
est de type « nombre entier » (int), les variables <b> et
<c> sont de type « nombre flottant » (float), les variables
<nom> et <verbe> sont de type « chaîne de caractères »
(string), la variable <E> est de type « booléen » (bool). Un
booléen ne peut prendre que deux valeurs : vrai ou faux
(True et False en Python).
L’affectation d’une variable s’effectue par l’instruction <
= >.
Notez bien la différence entre l’affectation et l’égalité. Une
égalité est un objet de la forme <expression1 == expres-
sion2>. Cet objet de type booléen vaut vrai si les deux
expressions sont égales et faux sinon.
Enfin, remarquez que l’on peut « ajouter » des chaînes de
caractères, cette opération d’addition s’appelle la conca-
ténation.
––
L’instruction d’affection <var = valeur> a pour effet de

• créer et mémoriser un nom de variable <var>;
• lui attribuer un type qui dépend de l’objet <valeur> entré;
• créer et mémoriser l’objet <valeur>;
• établir un lien entre le nom de la variable <var> et l’emplacement mémoire de l’objet <valeur>.
Mémoire
Espace des noms

!
@ adresse
var valeur
Exercice B. Affectation multiple

>>> a , b = 2 , 3
>>>print(‘’a = ‘’, a, ‘‘et b =’’, b)
>>>a , b = b , a
>>>print(‘’a = ‘‘, a, ‘‘et b =’’, b)

Solution
Le Python permet l’affectation multiple : on

peut affecter plusieurs variables en même
temps.
L’instruction <a , b= b , a> permet de
permuter les valeurs de a et b.
3. Éditeur Python
Lorsque vous avez plusieurs instructions à exécuter, vous pouvez ouvrir un fichier à partir du menu File/
New file, comme indiquer ci-dessous.
Une nouvelle fenêtre apparait que l’on appelle l’éditeur. Vous pouvez taper dans cette fenêtre une série
d’instructions. Il s’agit d’un éditeur de texte, comme Open Office par exemple, mais adapté à Python. Pour
exécuter les instructions, il faut
• sauvegarder le fichier où vous avez tapé vos instructions : dans le menu File de l’éditeur, sélectionner
Save As pour une première sauvegarde ou Save pour les sauvegardes suivantes,
• puis aller dans le menu Run de l’éditeur et sélectionner Run Module (voir ci-dessous).

Prenons un exemple.
1. On entre des instructions et on les sauvegarde dans un fichier de l’éditeur.
2. On demande l’exécution avec la commande Run de l’éditeur.
3. L’exécution se fait dans l’interpréteur.
Le programme IDLE est un environnement de développement (IDE) intégré dans Python. Quel que soit
l’IDE, il comportera toujours un interpréteur et un éditeur plus ou moins complexe. Le but d’un IDE étant
de faciliter le travail des programmeurs, l’éditeur met généralement en couleur les éléments du langage
et propose des complétions automatiques (et bien d’autres facilités…).
Il existe beaucoup d’environnements de développement (IDE) pour Python. Nous avons choisi celui-ci
car il est intégré à toutes les distributions Python, donc il ne nécessite pas d’installation spécifique, il
fonctionne sur tout système d’exploitation et il suffit à nos besoins.

4. Les entrées - sorties
Exercice C. Entrées et sorties

1. Ouvrir un fichier à partir de l’interpréteur et le sauver sous le nom « TPEntrées_Sorties». Entrer le
programme suivant dans votre fichier.
On a mis des commentaires après le symbole #. Ce qui suit ce symbole, n’est alors pas interprété.
n = int(input("Donner un entier n, n = ")) #On demande d’entrer un entier.

est_pair = n%2==0 #On teste si cet entier est pair (si oui, le reste de sa division euclidienne par 2 est 0)
print("L’entier ",n," est pair, est une affirmation : ",est_pair,".") #On affiche le résultat.
m = input("Donner un nombre m, m = ")

print("La variable m est de type : ",type(m))
print("Attention ! m n’est pas de type number mais de type string.")
reponse = input("Répondre par oui ou non, n est un multiple de trois ? ")

print("Votre réponse est ",reponse,". Vérifions.")
est_multiple_de_3 = n%3==0
print("L’entier ",n," est un multiple de 3, est une affirmation : ",est_multiple_de_3,".")
2. Exécuter ce programme dans l’interpréteur.

3. Dans l’éditeur, ajouter des commentaires pour expliquer chaque ligne du programme.
Solution
2. Voici un exemple d’exécution.
3. Voici un exemple de fichier commenté.
n = int(input("Donner un entier n, n = ")) #On demande d’entrer un entier que l’on affecte à n.
est_pair = n%2==0
#On teste si cet entier n est pair (si oui, le reste de sa division euclidienne par 2 est 0).
#La variable <est_pair> est un booléen.
print("L’entier ",n," est pair, est une affirmation : ",est_pair,".") #On affiche le résultat.
m = input(‘Donner un nombre m, m = ‘) #On demande d’entrer un nombre que l’on affecte à m.
print("La variable m est de type : ",type(m)) #On affiche le type de m.
print("Attention ! m n’est pas de type number mais de type string.")
#On affiche un message, notez bien que le type d’une variable affectée avec une saisie clavier
#par la commande <input()> est une chaîne de caractères.

reponse = input("Répondre par oui ou non, n est un multiple de trois ? ")
#On demande de répondre par oui ou par non, cette chaîne de caractères est affectée à reponse.
print("Votre réponse est ",reponse,". Vérifions.")
est_multiple_de_3 = n%3 == 0
#On teste si l’entier n est un multiple de 3 (si oui, le reste de sa division euclidienne par 3 est 0).
#La variable est_multiple_de_3 est un booléen.
print("L’entier ",n," est un multiple de 3, est une affirmation : ",est_multiple_de_3,".") #On affiche le
résultat.
Remarques.
• La fonction input() donne toujours une chaîne de caractère, la fonction int(<chaîne>) convertit <chaîne>
en un entier, de même float(<chaîne>) convertit <chaîne> en un nombre flottant. Attention, la fonction
bool(<n’importe quoi>) donne toujours True (sauf si <n’importe quoi> est une liste ou un ensemble
vide).
• Pour faciliter la relecture et la compréhension d’un programme, il faut essayer de donner des noms
significatifs aux différentes variables.
Exercice D.
On veut affecter le nombre 1 + 2 à la variable <x>.
3
1. Taper l’instruction suivante, saisir 1+2/3 et observer.
>>> x=float(input(‘Donner un réel x :’))
>>> x
2. Taper l’instruction suivante, saisir 1+2/3 et observer.

>>> x=eval(input(‘Donner un réel x :’))
>>> x
Solution
1. On obtient une erreur :
>>> x=float(input(‘Donner un réel x :’))
Donner un réel x :1+2/3
Traceback (most recent call last):
File “<pyshell#119>”, line 1, in <module>
x=float(input(‘Donner un réel x :’))
ValueError: could not convert string to float: ‘1+2/3’
>>> x

NameError: name ‘x’ is not defined
>>>
2. On obtient le résultat souhaité :
>>> x=eval(input(‘Donner un réel x :’))
Donner un réel x :1+2/3
>>> x
1.6666666666666665
>>>
Remarque
Pour saisir en entrée, un nombre défini par une expression mathématique, comme par exemple 1 + 2 , on
utilise l’instruction eval(input (« <texte> »)). 3
L’instruction input(« <texte > ») permet

• d’afficher le texte <texte>,
• et de saisir une chaîne de caractères.
L’instruction eval(<objet>) évalue l <objet> comme une expression Python.
5. Synthèse du TP
L’affectation s’effectue par le symbole < = >.
Nous avons rencontré le type int, pour « entier », le type float, pour « réel » (ou plus exactement les
nombres flottants qui sont une représentation informatique des nombres réels), le type str, abréviation de
string, pour « chaîne de caractères » et le type bool, pour « booléen ».
La fonction type(<var>) donne le type de la variable <var>.
Voici un résumé des principales instructions d’entrées-sorties en Python.
Fonction Description
NoneType -> str

input() Prend pour valeur la chaîne de caractère saisie au
clavier.
str -> str
input(''<texte>'') Affiche le texte <texte> et prend pour valeur la
chaîne de caractère saisie au clavier.
Affiche le texte <texte> et prend pour valeur l’entier
int(input(''<texte>'')
saisi au clavier.
Affiche le texte <texte> et prend pour valeur le
float(input(''<texte>'')
nombre flottant saisi au clavier.

Affiche le texte <texte> et évalue la chaîne de
eval(input(''<texte>'') caractère saisie au clavier comme une expression
Python.
Type <variable> -> NoneType
print(<variable>) Affiche la valeur de la variable <variable> puis
passe à la ligne
Str -> NoneType
print(''<texte>'')
Affiche le texte <texte> puis passe à la ligne
Str -> NoneType
print(<objet>, end='' '')
Affiche l’objet et un espace sans passer à la ligne

SÉQUENCE 2 – CALCUL LITTÉRAL
CHAPITRE 4
TP3. Instructions élémentaires en Python
1. Objectifs
• Se familiariser avec les connecteurs logiques.
• Utiliser des instructions conditionnelles en Python.
• Utiliser les boucles « Pour » et « Tant que » en Python.
2. Un peu de logique
Exercice A. Les connecteurs logiques

>>> x = 5 #Instruction 1
>>> x == 5 #Instruction 2
>>> x !=4 #Instruction 3
>>> x !=5 #Instruction 4
>>> x > 4 #Instruction 5
>>> x <= 5 #Instruction 6
>>> x > 2 and x < 4 #Instruction 7
>>> x < 2 or x > 4 #Instruction 8
Solution
>>> x = 5 Instruction 1 : on affecte la valeur 5 à la variable <x>.
>>> x == 5 Instruction 2 : elle vaut Vrai si <x> est égal à 5 et

True Faux sinon.
>>> x !=4 Instruction 3 : Elle vaut Vrai si <x> est différent de 4
True et Faux sinon.

>>> x !=5 Instruction 4 : Elle vaut Vrai si <x> est différent de 5
False et Faux sinon.
>>> x > 4 Instruction 5 : Elle vaut Vrai si <x> est strictement

True supérieur à 4 (si x ∈ ⎤⎦4 ; + ∞ ⎡⎣ ) et Faux sinon.
>>> x <= 5 Instruction 6 : Elle vaut Vrai si <x> est inférieur ou
True égale à 5 (si x ∈ ⎦⎤−∞ ; 5⎤⎦ ) et Faux sinon.
Instruction 7 : Elle vaut Vrai si <x> est stricte-

>>> x > 2 and x < 4
ment supérieur à 2 et strictement inférieur à 4 (si
False
x ∈ ⎦⎤2 ; 4⎡⎣ ) et Faux sinon.
>>> x < 2 or x > 4 Instruction 8 : Elle vaut Vrai si <x> est strictement
True supérieur à 2 ou strictement supérieur à 4 (si
>>> x ∈ ⎦⎤−∞ ; 2⎡⎣ ∪ ⎤⎦4 ; + ∞ ⎡⎣ , et Faux sinon.
Le <and> et le <or> correspondent aux « et » et « ou » en logique.
3. Les instructions conditionnelles

Prenons un exemple.
Le riz complet est à 10 € le kilogramme. Lorsque le poids de riz dépasse 2 kg, le riz supplémentaire
acheté est au prix de 5 € le kg. On représente le prix y en euros à payer en fonction du poids x (en kg) de
riz complet acheté.

Le programme ci-dessous
• demande le poids de riz en kg que l’on souhaite acheter ;
• calcule le prix en euros à payer ;
• affiche ce prix à payer en arrondissant au centime d’euros
#Entrées
poids = float(input("Entrer le poids en kg de riz à acheter : "))
#Traitement: calcul du prix à payer en euros
if poids <= 2:
prix = 10 * poids
else:
prix = 5 * poids + 10
#Sorties
print("Le prix à payer en euros est :", round(prix,2))
Remarques
• On appelle <test> une instruction dont le résultat est un booléen, c’est-à-dire une variable qui ne
peut prendre que 2 valeurs : Vrai et Faux. Par exemple, prenons l’instruction < a == b>. On se pose la
question « Est-ce que a est égal à b ? », le résultat de l’instruction est la réponse à notre question : Vrai
si a et b sont égaux et Faux sinon, en Python, <True> ou <False>.
À ne pas confondre avec l’instruction <a = b> qui signifie « affecter la valeur de b à la variable a ».
• Le début de la suite des instructions dans une conditionnelle se signale par une indentation de
4 espaces. La fin de l’indentation marque la fin de la suite des instructions à effectuer dans la
conditionnelle.
4. Les boucles
En algorithmique, on utilise les boucles pour répéter une suite d’instructions ; on distingue deux types de
boucles :
• les boucles bornées : boucle « Pour », lorsque l’on connaît le nombre de fois où l’on va répéter la suite
d’instructions,
• les boucles non bornées : boucle « Tant que », lorsque l’on ne sait pas combien de fois, il va falloir
répéter les instructions. On répète les instructions tant qu’une condition n’est pas satisfaite. Il est alors
important de vérifier que cette condition d’arrêt sera bien atteinte en un nombre fini de répétitions.

Exercice B. Programme mystère
1. Ouvrir un fichier à partir de l’interpréteur et le sauver sous le nom « TPBouclePour». Entrer le
programme suivant dans votre fichier.
#Entrées
N = int(input("Donner un entier naturel : N = "))
#Traitement
S = 0
for n in range(1, N+1):
S = S + n
#Sorties
print("Le résultat est :", S)
2. Exécuter ce programme dans l’interpréteur.

3. Expliquer ce que fait ce programme.
Solution
2. Voici deux exemples d’exécution
Donner un entier naturel: N = 4
Le résultat est : 10
Donner un entier naturel: N = 5
Le résultat est : 15
3. Ce programme calcule la somme des N premiers entiers où N est un entier naturel saisie au clavier.
Remarques.
• La commande <range(1, N+1)> crée la liste des N premiers entiers : [1, 2, 3, …,N-1, N].
Plus généralement, la commande <range(d, f, pas )> crée la liste des entiers de d inclus à f exclu en
augmentant de <pas>. Voici un exemple exécuté dans l’interpréteur.
On demande d’afficher les éléments de la liste créée par la
commande <range(4, 10, 2 )>.
Cette liste est constituée des entiers de 2 en 2 compris entre 4
inclus et 10 exclu : [4, 6, 8].
• Comme pour les conditionnelles, le début de la suite des instructions dans une boucle se signale par
une indentation de 4 espaces. La fin de l’indentation marque la fin de la suite des instructions à répéter
dans la boucle.

Exercice C. Première puissance
L’algorithme ci-dessous détermine et affiche le plus petit entier naturel n tel que 2n ≥ 1000.
n←0
u←1
Tant que u<1000 faire
n←n+1
u←2×u
Fin Tant que
Afficher n
1. On programme en Python cet algorithme. Ouvrir un fichier à partir de l’interpréteur et le sauver sous
le nom « TPBoucleTantQue». Entrer le programme suivant dans votre fichier.
#Traitement
n = 0
u = 1
while u < 1000:
n = n + 1
u = 2 * u
#Sorties
print("La puissance cherchée est :", n)
2. Exécuter ce programme. Qu’obtenez-vous ?

3. Modifier le programme précédent pour qu’il affiche la première puissance de 0,8 inférieure ou égale
à une valeur donnée <seuil> que l’on saisira au clavier. Quelles sont les valeurs acceptables pour le
<seuil> ?
4. Exécuter votre programme et vérifier votre résultat.
Solution
2. On obtient n = 10. On vérifie bien que 210 = 1024 est supérieur ou égal à 1000 et 10 est bien la
première puissance cherchée car 29 = 512.
3. Comme 0 < 0, 8 < 1, les puissances de 0,8 prennent des valeurs de plus en plus petites mais
n‘atteignent jamais 0. Il faut donc choisir un seuil strictement positif.
Voici une proposition de programme.
#Entrées
seuil = float(input("Donner un nombre strictement positif : seuil = "))
#Traitement
n = 0

u = 1
while u > seuil:
n = n + 1
u = 0.8 * u
#Sorties
print("La puissance cherchée est :", n)
On exécute ce programme, on obtient n = 31, pour un seuil de 0,001. On vérifie que 0, 831 ≤ 0,001 et
0, 830 > 0,001.
5. Synthèse du TP
Voici un résumé sur les conditions et connecteurs logiques en Python, puis sur les instructions
élémentaires en Python.
Instruction Description
a == b Vraie si et seulement si a = b
a != b Vraie si et seulement si a ≠ b
a >= b Vraie si et seulement si a ≥ b
a>b Vraie si et seulement si a > b
a <= b Vraie si et seulement si a ≤ b
a<b Vraie si et seulement si a < b
Vraie si et seulement si <condition1> Vraie et <condition2>
<condition1> and <condition2>
Vraie
Vraie si et seulement si <condition1> Vraie ou <condition2>
<condition1> or <condition2>
Vraie
Not <condition> Vraie si et seulement si <condition> Fausse
Notation
Instructions Exemple Exemple Python
algorithmique
Affectation Var ← Valeur A←4 A=4

Entrée Saisir Var Saisir X input(X)
Sortie Afficher Var Afficher X print(X)

Si Condition Alors Si X<=4 Alors if X <= 4 :
Traitement 1 Y = 2*X Y=2*X
Conditionnelle Sinon Sinon else :
Traitement 2 Y=0 Y=0
Fin Si Fin Si
Pour Var variant de
Pour i variant de 1 à 5 faire
Début à Fin faire for i in range(1, 6):
Boucle bornée S←S + i
Traitement S=S+i
Fin Pour
Fin Pour
Tant que Condition Tant que r ≥ 42 faire

while r >= 42 :
faire q ←q + 1
Boucle non
q=q+1
bornée Traitement r ← r − 42
r = r - 42
Fin Tant que Fin Tant que
À noter. En python, le début de la suite des instructions dans une conditionnelle ou dans une
boucle se signale par une indentation de 4 espaces. La fin de l’indentation marque la fin de la
suite des instructions à effectuer dans la conditionnelle ou la boucle.
Remarque. Imbrication des conditionnelles

Si on a trois cas à distinguer (par exemple, x < 0 ou 0 ≤ x < 1 ou x ≥ 1 ), on peut utiliser l’imbrication
des conditionnelles :
if <test 1> :
<suite d’instructions>
elif <test 2> :
else :

SÉQUENCE 3 – FONCTIONS
CHAPITRE 4
Programmer – Notion de fonction en Python
TP4. Notion de fonction en Python
A. Objectifs
• Utiliser des fonctions prédéfinies en Python
• Introduire le vocabulaire propre aux fonctions en informatique : fonction ou procédure, paramètres,
arguments, corps
• Définir ses propres fonctions (simples)
B. Des fonctions prédéfinies en Python
Exercice A
Taper les instructions suivantes dans l’interpréteur et observer les résultats obtenus.
>>> min(9,2)
>>> max(9,2,11,5)
>>> help(min)
Solution
Rappelons que dans une phrase explicative, nous noterons les variables et arguments entre <>, parfois
les instructions aussi, pour bien les séparer du texte.

Nous avons utilisé deux fonctions prédéfinies en
Python : min et max.
La fonction help(<fonction>) affiche la

documentation sur la fonction <fonction>.
La fonction min(<nombre 1>,<nombre 2>,

… ,<nombre n>) retourne le plus petit des n
nombres.
Les nombres <nombre 1>, <nombre 2>,

… s’appellent les arguments de la fonction.

C. Fonctions mathématiques en Python
Nous allons voir comment définir nos propres fonctions mathématiques, par exemple la fonction
f : x → −3x 2 + 5x + 1.
Exercice B
a. Calculer l’image de 0, de 3 puis de 1 par la fonction f.
b. Peut-on calculer l’image de -1 ?
c. Taper les instructions suivantes dans l’éditeur, sauver ce fichier sous le nom TP4ExerciceB.py puis
exécuter.
def fpy(x):
from math import sqrt
y = -3*×**2 + sqrt(5*×+1)
return y
d. Pour tester votre fonction dans l’interpréteur, taper par exemple les instructions suivantes et observer.
>>> fpy(0)
>>> fpy(3)
>>> fpy(−1)
>>> help(fpy)
e. Pour créer une documentation sur notre fonction <fpy>, ajouter dans la définition de <fpy>, la spécifica-
tion donnée ci-dessous entre des triples guillemets.
def fpy(x):
""" number -> float
hypothèses : 5x+1>=0
retourne une valeur approchée de f(x)=3x^2+sqrt(5x+1)
pour x un nombre donné"""
y = -3*x**2 + sqrt(5*x+1)
return y
Modifier votre fichier TP4ExerciceB.py, l’exécuter puis taper à nouveau dans l’interpréteur l’instruction
suivante :
>>> help(fpy)
Solution
a. L’image de 0 est f (0) = −3 × 02 + 5 × 0 + 1 = 1.
L’image de 3 est f (3) = −3 × 32 + 5 × 3 + 1 = −27 + 4 = −23.
L’image de 1 est f (1) = −3 × 12 + 5 × 1 + 1 = −3 − 6.

b. Non, car 5 × (−1) + 1 = −4 et la racine carrée d’un nombre négatif n’est pas définie.
c. On tape les instructions suivantes dans l’éditeur et on sauve ce fichier sous le nom TP4ExerciceB.py
puis on l’exécute.
def fpy(x):
y = -3*x**2 + sqrt(5*x+1)
return y
L’instruction <def fpy(x) :> définit une fonction de nom <fpy>, ayant un seul paramètre <x>, c’est-à-dire
dépendant d’une seule variable.

Nous importons la fonction racine carrée <sqrt> définie dans le module <math> car nous en avons besoin
dans notre fonction.
Les instructions <from math import sqrt>, <y=-3*x**2+sqrt(5*x+1)> et <return y> forment ce que
l’on appelle le corps de la fonction. Elles doivent être décalées d’au moins 4 espaces par rapport à
l’instruction <def fpy(x) :>. Dès que le décalage d’une instruction redevient inférieur à 4 espaces,
cette instruction ne fait plus partie de la définition de la fonction et donc la définition de la fonction est
considérée comme terminée.
En informatique, ce décalage s’appelle une indentation.
En Python, nous avons vu que la fin d’une instruction est marquée par un retour à la ligne. Il faut aussi
retenir que la fin d’une fonction est marquée par la fin de l’indentation.
Remarques
• On utilise ** pour élever à une puissance donnée (ici 2).
• On aurait pu appeler notre fonction en Python <f> plutôt que <fpy> mais nous préférons distinguer la
fonction mathématique f de la fonction <fpy> définie dans le langage de programmation Python.
• Importer <sqrt> dans le corps de notre fonction est important, notre fonction est indépendante ; elle
s’exécute toujours sans que l’on soit obligé d’importer au préalable le module <math> (ou la fonction
<sqrt>).
On exécute le fichier où est écrite notre fonction.
Dans l’interpréteur, vous obtenez une sortie de ce type :
>>> C:\Users\Nom\Documents\TPPython\TP4ExerciceB.py
Nom complet du fichier
d. On exécute les instructions dans l’interpréteur
Exécution dans l’interpréteur

>>> fpy(0)
1.0
>>> fpy(3)
-23.0
>>> fpy(-1)
fpy(-1)
File “C:/Users/Nom/Documents/TPPython/TP4ExerciceB.py”, line 8, in fpy
y = -3*x**2 + sqrt(5*x+1)
ValueError: math domain error
>>> help(fpy)
Help on function fpy in module __main__:
fpy(x)

Commentaires
La valeur de fpy(0) est 1, c’est l’image de 0 par la fonction mathématique f.
La valeur de fpy(3) est −23, c’est l’image de 3 par la fonction mathématique f.
La valeur de fpy(1) est −0.5505102572168221, c’est une valeur approchée de l’image de 3 par la fonction
mathématique f. Python ne donne que des valeurs approchées des nombres réels (*).
Python signale une erreur lorsque l’on cherche à calculer fpy(–1). Il précise bien que l’on est sorti du
domaine de définition d’une fonction mathématique (ici la racine carrée).
La documentation sur notre fonction <fpy> n’a pas été créée.
(*) Les nombres réels sont une construction mathématique. En informatique, ils sont représentés par des nombres dits flottants. En Python, la
−16
précision sur les nombres réels est généralement d’environ 10 .
e. Pour créer une documentation sur notre fonction <fpy>, on ajoute dans la définition de <fpy>, la
spécification ci-dessous.
def fpy(x):
""" number -> float
pour x un nombre donné"""
y = -3*x**2 + sqrt(5*x+1)
return y
On précise qu’en entrée, la fonction <fpy> prend pour argument <x>, un nombre du type <number>
et que sa sortie est toujours un nombre du type <float>. On précise que l’utilisateur de la fonction doit
faire attention à passer en argument un nombre <x> tel que 5x + 1 ≥ 0. Effectivement, si 5x + 1 n’est
pas positif alors on ne peut pas en calculer la racine carrée. Puis, on donne la description en français
du « problème » résolu par la fonction. La spécification s’écrit entre des triples guillemets.
>>> help(fpy)
Help on function fpy in module __main__:
fpy(x)
number -> float
pour x un nombre donné
D. Des fonctions en Python
Exercice C
a. Taper dans l’éditeur les instructions ci-dessous, sauvegarder votre fichier sous le nom
TP4ExerciceC.py.
def f(xM, yM):
Vrai_ou_Faux = yM < 3*xM-5
return Vrai_ou_Faux

Exécuter ce fichier et tester la fonction f
• avec xM = 1 et yM = 1,
• puis avec xM = 1 et yM = -3
b. Que fait la fonction f ?
c. Créer une documentation pour cette fonction f.
Solution
a. et b. On interprète les instructions du corps de la fonction :
def f(xM, yM):
return Vrai_ou_Faux
Cette fonction retourne le booléen True si yM < 3xM - 5, et le booléen False sinon. Autrement dit, elle
( )
retourne un booléen qui vaut True si le point M de coordonnées xM ; yM est en dessous de la droite D
d’équation y = 3x - 5.
Exécution dans
Commentaires
l’interpréteur
>>> f(1,1) Le point de coordonnées (1; 1) n’est pas en dessous de la droite D.
False
>>> f(1,-3) Le point de coordonnées (1; -3) est en dessous de la droite D.
True
c. Voici une proposition de documentation pour cette fonction f.

def f(xM, yM):
""" number, number -> bool
retourne le booléen True si le point M(xM;yM) est en dessous de
la droite d'équation y=3x-5"""
return Vrai_ou_Faux
Remarque
Pour les variables, les paramètres ou arguments, les fonctions et plus généralement tous les objets que
l’on utilise dans un programme, on essaye de choisir des noms significatifs.
Que proposeriez-vous pour la fonction f ? On pourrait l’appeler Est_en_dessous_D.
Exercice D
( )
a. Proposer une fonction Appartient_C qui retourne le booléen True si le point M xM ; yM appartient à la
3
courbe � d’équation y = - 5, et le booléen False sinon.
x
 3 2 − 10 
b. Déterminer si les points suivants appartiennent à la courbe � : A(1; -2), B(-3; 2) et C  2 ; .
 2 
 3 2 − 10 
c. Tester votre fonction sur les points A(1; -2), B(-3; 2) et C  2 ; .
 2 

Solution
a. On propose la fonction suivante
def Appartient_C(xM, yM):
retourne le booléen True si le point M(xM;yM) appartient à la
courbe d'équation y=3/x-5"""
Vrai_ou_Faux = yM == 3/xM-5
return Vrai_ou_Faux
3
b. On a - 5 = -2 donc le point A (1; –2) appartient à la courbe �.
1
On a
3
-3
( )
- 5 = -6 et −6 ≠ 2 donc le point B -3 ; 2 n’appartient pas à la courbe �.
3 3× 2 3 2 3 2 - 10  3 2 − 10 
On a -5= -5= -5= donc le point C  2 ;  appartient à la
2 2× 2 2 2  2 
courbe de �?
c. On teste notre fonction en exécutant dans l’interpréteur, le programme suivant que nous avons tapé
dans l’éditeur et sauver dans un fichier TP4ExerciceD.py
Vrai_ou_Faux = yM == 3/xM-5
return Vrai_ou_Faux

print("Le point A appartient à la courbe ?",Appartient_C(1,-2))
print("Le point B appartient à la courbe ?",Appartient_C(-3,2))
print("Le point C appartient à la courbe
?",Appartient_C(sqrt(2),(3*sqrt(2)-10)/2))
On obtient dans l’interpréteur les affichages suivants :

RESTART: C:/Users/Nom/Documents/TPPython/TP4ExerciceD.py
Le point A appartient à la courbe ? True
Le point B appartient à la courbe ? False
Le point C appartient à la courbe ? False
La réponse n’est pas correcte pour le point C.
Le problème est que le calcul par Python de <3/xM-5> est approché ainsi que celui du nombre
<(3*sqrt(2)-10)/2> passé en argument dans la fonction Appartient_C.
On décide alors que l’on considèrera yM égal à 3/xM-5 si leur distance est inférieure à une précision
donnée que l’on appelle epsilon et que l’on choisit égale à 10-15. Autrement dit, on décide que
 3
yM − 
 xM

( )
− 5 ≤ 10−15 signifie que le point M xM ; yM appartient à la courbe �.


On propose donc le nouveau programme suivant :
epsilon = 10**(-15)
Vrai_ou_Faux = abs( yM - (3/xM-5) ) <= epsilon
return Vrai_ou_Faux

print("Le point A appartient à la courbe ?",Appartient_C(1,-2))
print("Le point B appartient à la courbe ?",Appartient_C(-3,2))
print("Le point C appartient à la courbe
?",Appartient_C(sqrt(2),(3*sqrt(2)-10)/2))
On obtient dans l’interpréteur les affichages suivants :
RESTART: C:/Users/Nom/Documents/TPPython/TP4ExerciceDbis.py
Le point A appartient à la courbe ? True
Le point B appartient à la courbe ? False
Le point C appartient à la courbe ? True
E. Synthèse du TP
La syntaxe d’une fonction en Python est la suivante
def Nom_de_la_fonction(liste des paramètres) :
"""type des paramètres -> type de la sortie
(Hypothèses si restriction sur les paramètres)
Documentation de la fonction : ce que fait cette fonction """
Instruction 1
Instruction 2
Instruction n
(return résultat)
L’indentation de 4 espaces marque le début du corps de la fonction, c’est-à-dire l’ensemble des

instructions de la fonction, et la fin de l’indentation marque la fin de la fonction.
Une fonction en Python peut ne pas avoir de sortie (dans ce cas, il n’y a pas de return).
Une fonction Python peut avoir plusieurs paramètres, de type différents et elle peut avoir des sorties
de tout type.
En Python, les fonctions sont aussi appelées des méthodes ou procédures (vous pourrez rencontrer
ces termes sur différents sites).
Si la fonction prend en argument un nombre et renvoie un nombre, on retrouve la définition des
fonctions mathématiques que vous connaissez.

CHAPITRE 3
TP 6. Statistiques et Outils logiciels





Groupe A
Grandeurs statistiques Groupe A Groupe B

     
 


( - )



>>> maliste = [2,6,6,3,6,2]

>>> maliste
>>> maliste[0]
>>> maliste[1]
>>> maliste[:3]
>>> maliste[2:5]
>>> maliste[-1]
>>> maliste[-2]
>>> maliste[-3:]
>>> type(maliste)
>>> maliste = [2,6,6,3,6,2]

>>> maliste
[2, 6, 6, 3, 6, 2]
>>> maliste[0]
2
>>> maliste[1]
6
>>> maliste[:3]
[2, 6, 6]
>>> maliste[2:5]
[6, 3, 6]
>>> maliste[-1]
2
>>> maliste[-2]
6
>>> maliste[-3:]
[3, 6, 2]
>>> type(maliste)
<class 'list'>
>>>
>>> maliste = [2,6,6,3,6,2]

>>> maliste.reverse()
>>> maliste
>>> maliste.sort()
>>> maliste
>>> sum(maliste)
>>> maliste[:]=[]
>>> maliste
>>> help(list)
>>> maliste = [2,6,6,3,6,2]

>>> maliste.reverse()
>>> maliste
[2, 6, 3, 6, 6, 2]
>>> maliste.sort()
>>> maliste
[2, 2, 3, 6, 6, 6]
>>> sum(maliste)
25
>>> len(maliste)
6
>>> maliste[:]=[]
>>> maliste
[]
>>> help(list)
Help on class list in module builtins:
class list(object)
| list() -> new empty list
| list(iterable) -> new list
initialized from iterable's items
|
| Methods defined here:
…





    
 
    
 
    
 
    
 

 
    
 
SÉQUENCE 9. PROBABILITÉS ET ÉCHANTILLONNAGES
CHAPITRE 2
TP8. Programmer – L’aléatoire et le Python

Objectifs
• Introduire le module <random> pour faire des simulations
• Réinvestir les notions vues dans les précédents travaux pratiques de programmation en Python, en
particulier les listes.
Exercice A
On souhaite simuler le lancer d’un dé cubique équilibré, c’est à dire choisir au hasard un nombre entier
entre 1 et 6, chacun ayant la même probabilité d’être choisi.
Pour cela, on va utiliser le module <random> de Python qui propose différentes fonctions pour simuler le
hasard.
a) Taper les instructions suivantes dans l’interpréteur, observer et commenter.
>>> from random import *
>>> randint(1,6)
b) Taper les instructions suivantes, observer et commenter.

>>>from random import *
>>>des=[1,2,3,4,5,6]
>>>choice(des)
>>>choices(des,k=20)
Solution a)
>>> from random import * Le module <random> comporte des fonctions pour générer des
nombres aléatoires.
>>> randint( 1, 6 ) La fonction <randint> a pour argument, deux entiers <n> et
<p>. Elle retourne un entier compris entre n inclus et p inclus,
4 choisi au hasard. Chaque entier compris entre n et p, tous deux
inclus, a la même probabilité d’être obtenu.
Ici, on simule un lancé du dé cubique.
CNED SECONDE MATHÉMATIQUES 1

Solution b)

>>> from random import * On définit la liste des issues possibles lorsque l’on lance un
>>> des = [1, 2, 3, 4, 5, 6] dé cubique : [1, 2, 3, 4, 5, 6].
La fonction <choice> a pour argument une liste <liste>. Elle
>>> choice( des ) retourne un élément de la liste, choisi au hasard, en
supposant que tous les éléments de la liste ont la même
4
probabilité d’être obtenus.
Ici, on simule un lancé du dé cubique.
>>> choices( des, k=20 ) La fonction <choices> a pour arguments une liste <liste> et
<k=n>. Elle retourne une liste de n éléments, chacun ayant
été choisi dans la liste <liste> avec la même probabilité.
[1, 5, 3, 4, 3, 2, 1, 4, 6, 3, 4, 5, 4, 3, Ici, on a n = 3, on simule 3 lancers de dé cubique successifs.
4, 4, 4, 4, 2, 3] Le premier élément de la liste est le résultat du premier
lancer, le deuxième élément, le résultat du deuxième
lancer,...
Exercice B
Simuler le tirage au sort d’une lettre de l’alphabet, revient à choisir au hasard une lettre parmi les
26 lettres de l’alphabet, chacune ayant la même probabilité d’être choisie.
a) Écrire un programme qui effectue les tâches suivantes.
• Il demande le nombre n de lettres de l’alphabet à choisir.
• Il choisit n lettres parmi les 26 lettres de l’alphabet, une même lettre pouvant être choisie
plusieurs fois. On parle alors de tirage avec remise : au tirage suivant, on a encore le choix
parmi 26 lettres.
• Il affiche le mot de n lettres ainsi obtenu.
b) Modifier votre programme pour qu’on ne puisse pas choisir la même lettre. On parle alors de
tirage sans remise : une lettre étant choisie, elle ne fait plus partie de la liste des lettres que l’on
peut choisir.
Solution a)
#Module pour générer des nombres (pseudo-)aléatoires
from random import *
#On définit la liste des lettres de l’alphabet
alphabet = [ 'a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','q','r','s','t','u','v','w','x','y','z' ]
n = int( input( " Donner le nombre de lettres de l'alphabet à choisir: n = " ))

#On crée un mot en concaténant les lettres obtenues dans l'ordre de tirage
mot = ''
for compteur in range( 1, n+1 ):
lettre = choice( alphabet )
mot = mot + lettre
print( "Le mot aléatoire obtenu est ", mot)
Voici des exemples d’exécution de ce programme :

Donner le nombre de lettres de l'alphabet à choisir: n = 5
Le mot aléatoire obtenu est rknmv
Le mot aléatoire obtenu est ipwcfiosqyveygzmwdfv
Solution b)
#On créé une copie indépendante de cette liste
copie_alphabet = alphabet[:]
mot = ''
for compteur in range( 1, n+1 ):
lettre = choice( copie_alphabet )
mot = mot + lettre
#On retire la lettre de la liste
copie_alphabet.remove( lettre )
print( "Le mot aléatoire obtenu est ", mot)
Voici un exemple d’exécution de ce programme :

Le mot aléatoire obtenu est kuinycoxrhldmbzewsap
On affiche la liste des lettres après exécution du programme.
>>> copie_alphabet
['f', 'g', 'j', 'q', 't', 'v']
On a fait une copie indépendante de la liste des lettres de l’alphabet pour ne pas modifier la
liste de toutes les lettres de l’alphabet.

Remarque. On peut aussi utiliser la commande sample(Liste,k=N) qui retourne une liste de N
éléments tirés sans remise dans la liste Liste.
Le programme peut alors s’écrire
lettre_mot = sample( alphabet, k=n )
mot = ''
for lettre in lettre_mot:
mot = mot + lettre
print( "Le mot aléatoire obtenu est ", mot )
Voici un exemple d’exécution :

Le mot aléatoire obtenu est ozvnxcdmhlefbqjrptsu
Affichons la liste des lettres de l’alphabet.
>>> alphabet
['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z']
On remarque que la liste alphabet, n’a pas été modifiée, avec la commande sample , nous
n’avons pas besoin d’en faire une copie.
Exercice C
Comment pourrait-on simuler le tirage au sort d’une boule dans une urne qui contient 2
boules rouges et 3 boules vertes ?
Solution
>>> from random import *
#Première solution : on définit l'urne
>>> urne = [ "rouge", "rouge", "verte", "verte", "verte" ]
>>> choice( urne )
#Deuxième solution : on définit la liste des issues et la probabilité de chacune d'elle

>>> issues = [ "rouge", "verte" ]
>>> probabilite = [ 2/5, 3/5 ]
>>> choices( issues, probabilite, k=1 )

On peut aussi rentrer les effectifs à la place des probabilités, on simule alors la même
expérience aléatoire :
>>> issues = [ "rouge", "verte" ]
>>> effectifs = [ 2, 3 ]
>>> choices( issues, effectifs, k=1 )
Remarque. Attention, la fonction <choices> retourne toujours une liste, même si vous ne
faites qu’un seul tirage au sort ( k = 1).
Exercice D
On considère la roulette américaine qui comporte 38 cases numérotées et
colorées. Ces cases sont numérotées de 0 à 36 et une case porte le double
zéro (00). 18 de ces cases sont noires, 18 sont rouges, le 0 et le 00 sont verts.
On ne mise que sur une « chance simple », c’est-à-dire que sur l’une des
couleurs : noire ou rouge (le vert n’est pas autorisé). À la roulette américaine, la règle est de
gagner une fois sa mise si la couleur choisie sort, sinon la mise est perdue. Par exemple, si vous
misez 10 euros sur le rouge et que le rouge sort, vous gagnez 10 euros. Sinon, vous donnez 10
euros à la banque du casino.
a) Écrire une fonction de nom ChanceSimple qui prend en argument la couleur choisie (noire ou
rouge) et votre mise. Elle retourne votre gain ou votre perte : par exemple si vous avez misé 10
euros, elle retourne 10 si votre couleur est sortie, et –10 sinon.
b) Écrire un programme qui demande votre couleur choisie et votre mise, puis affiche votre gain.
Solution
Voici une proposition de programme.
def ChanceSimple( Couleur, Mise ):
""" string, integer -> integer
Couleur est la chaîne de caractère 'rouge' ou 'noire'.
Mise est un entier positif, non nul.
La fonction retourne le gain ou la perte lorsque l'on joue une chance simple à la roulette
américaine."""
from random import choices
Issues = [‘rouge’, ‘noire’, ‘vert’ ]
Effectifs = [ 18 , 18 , 2 ]
CouleurSortie = choices( Issues, Effectifs )
if CouleurSortie[0] == Couleur:
Gain = Mise
else:
Gain = -Mise
return Gain
#Entrées

print( "Faîtes vos jeux, choisissez une couleur : tapez 'rouge' ou 'noire'. " )
Choix = input( "votre choix :" )
Mise = int( input( "Choisissez votre mise :" ))
#On fait tourner la roulette...
Gain = ChanceSimple( Choix, Mise )
#On affiche votre gain...
print( "Votre gain est de", Gain,"euros." )
Voici un exemple d’exécution
Faîtes vos jeux, choisissez une couleur : tapez 'rouge' ou 'noire'.
votre choix :'rouge'
Choisissez votre mise :10
Votre gain est de -10 euros.
Synthèse du TP8 – L’aléatoire et le Python

Le module <random>
randint( n, p) Retourne un entier tiré au hasard entre les entiers
<n> et <p>, tout deux inclus.
choice(Liste) Retourne un élément de la liste <Liste> choisi
aléatoirement, chacun des éléments de la liste ayant
la même probabilité d’être choisi.
choices(ListeIssues,ListeProbabilités,k=N) <ListeIssues> est la liste des issues d’une expérience
aléatoire.
<ListeProbabilités> est la liste des probabilités de
chacune des issues de la liste <ListeIssues>.
<N> est le nombre de fois où l’on répète l’expérience
aléatoire de manière identique et indépendante
(« avec remise »).
Retourne la liste des issues obtenues lorsque l’on
répète N fois l’expérience aléatoire de manière
identique et indépendante.
sample(Liste,k=N) Retourne la liste des issues obtenues après N tirages
« sans remise ».
Lors d’un tirage, on choisit aléatoirement un élément
dans la liste <Liste>, chaque élément a la même
probabilité d’être choisi. Un élément choisi est retiré
de la liste pour le prochain tirage. On parle de tirage
« sans remise ».

SÉQUENCE 9. PROBABILITÉS ET ÉCHANTILLONNAGES
CHAPITRE 2
TP9. Échantillonnage
Objectifs
• Découvrir la notion d’échantillonage.
• Utiliser le module <random> pour faire des simulations.
• Réinvestir les notions vues dans les précédents travaux pratiques de programmation en
Python, en particulier les listes.
Exercice A. Fluctuation d’échantillonnage

Une épreuve de Bernoulli est une expérience aléatoire dont l’univers est constitué de deux issues
appelées « succès » et « échec ».
Exemples
• Lancer une pièce de monnaie équilibré est une épreuve de Bernoulli, on peut décider que
« Obtenir Face » est le « succès » et « Obtenir Pile » est l’ « échec ». Ces deux issues sont
1
équiprobables : leur probabilité est chacune de .
2
• Lancer un dé cubique et observer si on obtient 6 ou non, est une épreuve de Bernoulli. On
décide que « Obtenir un six » est le « succès » et « Obtenir un autre numéro que six » est
l’ « échec ». Dans ce cas, ces deux issues ne sont pas équiprobables : la probabilité
1 5
d’obtenir un six est et celle de ne pas obtenir un six est .
6 6
Dans cet exercice, on considère l’épreuve de Bernoulli qui consiste à lancer une pièce de monnaie
équilibrée. On note F, l’issue « Face » que l’on choisit comme « succès » et on note P, l’issue
« Pile ».
On répète n fois cette expérience, il s’agit de la même expérience et son résultat ne dépend pas de
ce que nous avons obtenu précédemment. On dit alors que l’on répète l’expérience de manière
identique et indépendante.
L’ensemble des n résultats obtenus forme un échantillon de taille n pour cette épreuve de
Bernoulli.
On s’intéresse à la fréquence de succès dans un échantillon de taille n .
Par exemple, si on répète 5 fois l’expérience et on obtient {F ,P ,F ,F ,F } , la fréquence de F dans cet
4
échantillon est .
5

Nous utilisons le langage Python pour effectuer les simulations.
Vous pourrez recopier les fonctions et les programmes donnés dans un fichier ouvert avec l’éditeur
Python, les exécuter et observer les résultats dans la console.
a) On considère la fonction effectif ci-dessous. Que réalise cette fonction ?

def effectif(n):
from random import choice
piece = ['F','P']
nb_face = 0
for k in range(1, n+1):
lancer = choice(piece)
if lancer == 'F':
nb_face = nb_face + 1
return nb_face
b) Écrire en Python, une fonction frequence qui prend en argument n la taille de l’échantillon
(c’est à dire le nombre de fois où l’on répète l’expérience de lancer une pièce), et retourne la
fréquence de « Face » obtenues. Vous pourrez utiliser la fonction effectif définie ci-dessus.
Tester votre fonction pour différentes valeurs de n.
c) Voici un programme qui permet de tracer les fréquences obtenues pour 100 échantillons de
taille 500. Il utilise les fonctions effectif et frequence définies précédemment. Il ne faut pas oublier
de les exécuter avant de lancer le programme.
Une exécution de ce programme nous a donné le graphique ci-dessous.
En abscisse se trouve le rang de
l’échantillon de taille 500, et en
ordonnée la fréquence de « Face »
obtenue pour cet échantillon.
Qu’observez-vous ?
import matplotlib.pyplot as plt
import numpy as np
plt.axis([0,100,0,1])
plt.grid()
for nb_echantillon in range(1, 101):
f_echantillon = frequence(500)
plt.plot(nb_echantillon,
f_echantillon,'rx')
plt.show()

Solution
a) La fonction effectif prend en argument la taille n de l’échantillon (le nombre de fois où l’on
répète l’expérience de lancer une pièce). Elle simule la répétition de n fois l’expérience de lancer
un espèce et d’observer si elle tombe sur « Face » ou « Pile ». Elle retourne le nombre de fois où
l’on a obtenu « Face ».
b) La fréquence d’obtention de « Face » est la proportion des « Face » sur l’ensemble des lancers.
Effectif des "Face" effectif (n)
On la calcule par f = , soit f = .
Nombre de lancers n
On propose la fonction suivante :
def frequence(n):
nb_face = effectif(n)
f = nb_face/n
return f
On teste notre fonction dans la console (après avoir exécuter le fichier où elle est entrée) pour
différentes tailles d’échantillon.
>>> frequence(100)
0.48
>>> frequence(50)
0.6
c) On voit que pour chaque échantillon de taille 500, on obtient une fréquence différente mais qui
est proche de 0,5. Ces variations des fréquences, pour des échantillons de même taille, s’appelle la
fluctuation de l’échantillonnage.
Exercice B. Loi des grands nombres

On considère la même épreuve de Bernoulli : le lancer d’une pièce et on regarde sur quelle face
elle tombe. On reprend nos fonctions en Python précédentes : effectif et frequence qui prennent en
argument la taille de l’échantillon (le nombre de fois où l’on répète l’expérience) et retournent
respectivement le nombre de « Face » obtenues et la fréquence d’obtention des « Face ».
Dans un repère, on souhaite construire la droite d’équation y = 0,5 et un nuage de points (n;f (n))
où n est la taille de l’échantillon et f (n) une fréquence d’obtention de « Face ». On fait varier n de
1 à 500 de 5 en 5 : on dit que l’on prend un pas de 5.
Pour construire ce graphique, on vous propose le programme suivant à compléter.
#Création des axes gradués et de la grille
#Abscisses : de 0 à 500, ordonnées : de 0 à 1
plt.axis([0, 500, 0, 1])
plt.grid()
#Création de la droite y=0.5
x = np.linspace(0, 500, 500)
plt.plot(x,0*x+0.5)

#Création du nuage de points
for n in range(1, ..., 5):
f_n = ...
plt.plot(n, f_n,'rx')
plt.show()
Après avoir complété ce programme, le copier dans un fichier de l’éditeur et l’exécuter.

Il ne faut pas oublier d’exécuter les fonctions effectif et frequence avant de lancer le programme.
Commenter le graphique obtenu.
Solution
Voici le programme complété, nous avons écrit en bleu les complétions faites.
#Création des axes gradués et de la grille
#Abscisses : de 0 à 500, ordonnées : de 0 à 1
plt.axis([0, 500, 0, 1])
plt.grid()
#Création de la droite y=0.5
x = np.linspace(0, 500, 500)
plt.plot(x,0*x+0.5)
#Création du nuage de points
for n in range(1, 501, 5):
f_n = frequence(n)
plt.plot(n, f_n,'rx')
plt.show()
Vous devez obtenir un graphique avec la même allure.
On observe que pour des grandes tailles d’échantillon, la fréquence observée fluctue mais est
proche de la valeur 0,5 qui est la probabilité d’obtenir « Face ».
C’est un résultat très important que l’on appelle « la loi des grands nombres » (que vous
démontrerez bien plus tard). Soit une épreuve de Bernoulli avec une probabilité de succès p .
Lorsque la taille de l’échantillon est suffisamment grande, la fréquence observée du « succès » se
stabilise autour de la probabilité p du succès.
C’est ce qui permet d’estimer une probabilité à partir de simulation.
Exercice C. Intervalle de dispersion ou de fluctuation

On considère la même épreuve de Bernoulli : le lancer d’une pièce et on regarde sur quelle face
elle tombe. On reprend nos fonctions en Python précédentes : effectif et frequence qui prennent en
argument la taille de l’échantillon (le nombre de fois où l’on répète l’expérience) et retournent
respectivement le nombre de « Face » obtenues et la fréquence d’obtention des « Face ».
On se donne un entier n assez grand.

On considère des échantillons de taille n , pour chacun de ces échantillons, on observe une
fréquence f de « Face ». Nous avons vu que cette « fréquence observée » fluctue autour de la
probabilité p d‘obtenir « Face » et qu’elle s’en approche quand n est suffisamment grand.
Nous allons simuler N échantillons de taille n et calculer la proportion de cas où la distance entre
1 1
p et f est inférieur à , c’est à dire où | f − p |≤ .
n n
a) Que réalise la fonction distance définie ci-dessous ?
def distance(n,f):
p = 0.5
if abs( f - p) <= 1/sqrt(n):
compteur_d = 1
else:
compteur_d = 0
return compteur_d
b) Que réalise la fonction proportion définie ci-dessous ?
def proportion(n, N):
compteur = 0
for i in range(1, N+1):
f = frequence(n)
compteur = compteur + distance(n,f)
prop = compteur/N
return prop
c) On prend n = 100 et N = 200 . Exécuter la fonction proportion.
Quelle est la proportion obtenue ?
d) Dans la console Python, exécuter plusieurs fois la fonction proportion pour les mêmes valeurs
de n et N . Qu’observez-vous ?
Solution
a) La fonction distance prend en argument n la taille d’un échantillon et f la fréquence de « Face »
de cet échantillon, elle retourne 1 si la distance | f − p | entre la fréquence et la probabilité d’obtenir
1
« Face » ( p = 0,5 ) est inférieure à , et elle retourne 0 sinon.
n
b) La fonction proportion prend en argument n la taille des échantillons et N le nombre
d’échantillons que l’on simule. Elle simule N échantillons de taille n . Pour chaque échantillon,
elle calcule la fréquence f de « Face ». Elle compte la proportion d’échantillons parmi les N qui
1
ont une fréquence f telle que la distance à p soit inférieure ou égale à .
n
c) Une première exécution donne une proportion de 0,965 soit 96,5 %.

d) Des exécutions successives donnent des proportions variant de 0,95 à 0,99 soit de 95 % à 99 %, il
semble donc que cette proportion reste supérieure à 95 %.
C’est un résultat que l’on peut démontrer et que l’on appelle « théorème central limite » : sous
certaines conditions, la probabilité que la fréquence d’un échantillon de taille n soit dans
 1 1 
l’intervalle p − ;p +  est au moins égale à 95 %.
 n n
Synthèse du TP9 – Échantillonnage

Dans ce TP, nous avons vu sur un exemple la notion d’échantillon, de fluctuations
d’échantillonnage et une vulgarisation de la « loi des grands nombres » et du « théorème central
limite ». Dans le cours, nous définirons ces notions et énoncerons ces résultats dans le cas
général.
Complément sur le module <random>
random() Retourne un nombre « aléatoire » r de l’intervalle [0;1] celui-ci étant
muni d’une loi uniforme : quelque soit N le nombre de subdivisions en
sous-intervalles égaux de [0;1] , la probabilité du nombre r d’appartenir à
1
l’un de ces N sous intervalles est la même et est donc égale à .
N
uniform(a,b) Retourne un nombre « aléatoire » r de l’intervalle [a;b ] celui-ci étant

muni d’une loi uniforme : quelque soit N le nombre de subdivisions en
sous-intervalles égaux de [a;b ] , la probabilité du nombre r d’appartenir
1
à l’un de ces N sous intervalles est la même et est donc égale à .
N

2nd-Python CNED 2021-2022

Transféré par

Droits d'auteur :

Formats disponibles

2nd-Python CNED 2021-2022

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

2nd-Python CNED 2021-2022

Transféré par

Droits d'auteur :

Formats disponibles

ACTIVITÉ 1.

L’INRIA (Institut National de Recherche en Informatique et Automatisme), propose la définition suivante

L’objet obtenu à partir de cet algorithme est la définition du mot cherché.

CNED – SECONDE – MATHÉMATIQUES 1

Définitions et notations en algorithmique

Instructions Notation algorithmique Exemple

Tester un algorithme et suivre les variables

2 CNED – SECONDE – MATHÉMATIQUES

Ligne de Ligne de l’algorithme exécutée i S

CNED – SECONDE – MATHÉMATIQUES 3

Solution. Avec la calculatrice, on obtient une approximation de A = 577 ≈ 1, 4142568 puis de

Valeur de p Encadrement Vrai ou faux ?

1 −0,1 ≤ 2 − A ≤ 0,1 Vrai

4 CNED – SECONDE – MATHÉMATIQUES

Valeur de p Encadrement Vrai ou faux ?

1 −0,1 ≤ 2 − A ≤ 0,1 Vrai

2 −0,01 ≤ 2 − A ≤ 0,01 Vrai

3 −0,001 ≤ 2 − A ≤ 0,001 Vrai

4 −0,0001 ≤ 2 − A ≤ 0,0001 Vrai

5 −0,00001 ≤ 2 − A ≤ 0,00001 Vrai

6 −0,000001 ≤ 2 − A ≤ 0,000001 Faux

5. On considère les nombres de la forme F = 1 + 1 + 1 − 1 où n est un entier naturel non nul.

Que fait cet algorithme ?

CNED – SECONDE – MATHÉMATIQUES 5

TP2. Variables, entrées et sorties en Python

Exercice A. Variables, types et affectation

CNED – SECONDE – MATHÉMATIQUES 1

Exécution dans l’interpréteur Commentaires

Une variable est une « case » dans la mémoire où l’on

L’instruction d’affection <var = valeur> a pour effet de

Espace des noms

Exercice B. Affectation multiple

2 CNED – SECONDE – MATHÉMATIQUES

Exécution dans l’interpréteur Commentaires

Le Python permet l’affectation multiple : on

CNED – SECONDE – MATHÉMATIQUES 3

2. On demande l’exécution avec la commande Run de l’éditeur.

3. L’exécution se fait dans l’interpréteur.

4 CNED – SECONDE – MATHÉMATIQUES

Exercice C. Entrées et sorties

n = int(input("Donner un entier n, n = ")) #On demande d’entrer un entier.

m = input("Donner un nombre m, m = ")

reponse = input("Répondre par oui ou non, n est un multiple de trois ? ")

2. Exécuter ce programme dans l’interpréteur.

3. Voici un exemple de fichier commenté.

CNED – SECONDE – MATHÉMATIQUES 5

2. Taper l’instruction suivante, saisir 1+2/3 et observer.

>>> x=float(input(‘Donner un réel x :’))

Donner un réel x :1+2/3

Traceback (most recent call last):

File “<pyshell#119>”, line 1, in <module>

x=float(input(‘Donner un réel x :’))

ValueError: could not convert string to float: ‘1+2/3’

Traceback (most recent call last):

6 CNED – SECONDE – MATHÉMATIQUES

NameError: name ‘x’ is not defined

2. On obtient le résultat souhaité :

>>> x=eval(input(‘Donner un réel x :’))

Donner un réel x :1+2/3