Lycée Carnot - H1B Matthias Gorny

Algorithmique et informatique avec Python :

le cours de première année

TP no 1 – Les commandes de base en Python

1) Différents types d’objets

Si x et y sont deux En Python (comme en Mathématiques) il y a différents types d’objets que l’on peut
variables Python, alors affecter à des variables avec la commande nom=expression. Le contenu de expression
la commande x,y=y,x (une expression mathématique) est alors stocké dans une variable appelée nom.
échange leurs contenus Parmi les types d’objets, il y a notamment :
respectifs (sauf rares • Les entiers (type int).
exceptions comme, par • Les réels ou flottants (type float).
exemple, lorsqu’il s’agit de
En mathématiques les entiers sont des réels. En Python ce sont deux types
lignes ou de colonnes d’un
différents : par exemple 1 est entier et 1. est un réel et Python ne considèrera pas
tableau du type ndarray).
le deuxième comme un entier. Il faut donc y penser quand on utilise une commande
demandant un entier (comme range) et que l’on dispose d’un réel. La commande
Il y a plein de subtilités au- int(a) transforme un réel a en un entier (en enlevant les chiffres après la virgule).
tour des entiers et des flot- • Les chaînes de caractère (type str). Pour définir une chaîne de caractères, on
tants pour Python qu’il n’est écrit les caractères entre guillements (") ou bien entre apostrophes (’). Si dans la
pas utile d’explorer en ECG. chaîne, il y a déjà des guillements ou des apostrophes, on les fait précéder de \.
Par exemple "Je m\’appelle Bond, James Bond."
Une chaine de caractère contenant un mot ne doit pas être confondue avec le mot
lui-même (sans " ou ’, Python considèrera qu’il s’agit d’une variable).
Par exemple "eps" affiche le mot eps alors que eps affiche le contenu de la
variable eps.
La commande str(x) transforme le contenu de la variable x en la chaîne de
Si x=5, alors la commande caractère correspondant au contenu de x.
’x’ renvoie ’x’, alors que la • Les booléens (type bool) qui ne prennent que deux valeurs : True (vrai) ou False
commande str(x) renvoie (faux).
’5’. • Les listes (type list, cf. paragraphe 3).
• Les tableaux (type ndarray, cf. paragraphe 4 et TP no 6).
• Les fonctions (type function, paragraphe 5 et TP no 2).

La commande type(A) renvoie le type de l’objet A.

2) Opérations de base sur les variables

a) Opérations sur les réels
• Soient x et y deux réels implémentés en Python dans les variables x et y. Les
commandes x+y,x-y,x*y renvoient respectivement la somme de x et y, la sous-
traction de x par y et la multiplication de x par y. Si y 6= 0, x/y renvoie la division
de x par y. Enfin, sous réserve d’existence, x**y renvoie xy .
La commande x+=y ajoute définitivement y à la variable x (c’est-à-dire elle remplace
le contenu de x par le résultat de x+y). Elle fait la même chose que x=x+y.

1
 Les commandes x-=y, x*=y, x/=y et x**=y fonctionnent sur le même principe
mais avec la soustraction, la multiplication, la division et l’élévation à la puissance.
La commande x%y est utile • Si x et y deux entiers implémentés en Python dans les variables x et y, alors la
(pour savoir si x est un mul- commande x%y renvoie le reste de la division euclidienne de x par y et la commande
tiple de y notamment) mais x//y le quotient.
elle n’apparaît pas dans le • On peut également évaluer des réels par des fonctions usuelles (cf. paragraphe 5)
programme. ou des fonctions que l’on définit soi-même (cf. TP no 2).
• Python nous permet d’accéder à des approximations de π et de e = exp(1) via les
Mais avant cela il faut im- commandes np.pi et np.e respectivement.
porter la bibliothèque numpy
en utilisant la commande b) Opérations sur les booléens
import numpy as np (on
Les booléens sont très utiles puisqu’ils apparaissent dans les conditions des structures
en reparlera).
conditionnelles et des boucles while (cf. TP no 2).
• En général les booléens sont créés en faisant des comparaisons entre réels (ou entre
vecteurs, entre matrices, cf. paragraphe 4). Si x et y sont des réels implémentés
Ne pas confondre == qui en Python par x et y, alors x==y,x<y,x<=y,x>y,x>=y,x!=y renvoient True si x
teste l’égalité et = qui sert est respectivement égal à y, strictement inférieur à y, inférieur à y, strictement
à l’affectation dans une va- supérieur à y, supérieur à y et différent de y. Elles renvoient False sinon.
riable. • On peut faire des opérations sur les booléens avec les commandes and,or,not
qui implémentent respectivement les et, ou, non logiques.
Par exemple, x>3 and x<=5 renvoie True si et seulement si x ∈ ]3 ; 5]. La
commande x>=8 or x<-2 renvoie True si et seulement si
x ∈ ]−∞ ; −2[ ∪ [8 ; +∞[.
• Si x est un réel implémentés en Python par x, alors la commande int(x)==x
renvoie True si x est un entier, False sinon.
Ces trois commandes ne • Si n et p sont des entiers (avec p =
6 0) implémentés en Python par n et p, alors :
sont pas explicitement au — (n%2)==0 renvoie True si n est pair, False sinon.
programme mais sont très
— (n%2)==1 renvoie True si n est impair, False sinon.
utiles.
— (n%p)==0 renvoie True si n est divisible par p, False sinon.

3) Listes
• On peut construire une liste d’objets (pas forcément du même type) entre crochets
et séparés par des virgules.
Par exemple L=[1,2,0,8,-9,7,4,0].
• La commande [] crée une liste vide.
• Si x est une variable, alors la commande x in L renvoie True si la variable x est
un élément de la liste L et False sinon.
• Si L est une liste, la commande len(L) renvoie le nombre d’éléments de la liste.
Dans ce cours, on différen- • Python numérote les indices d’une liste à partir de 0 et non de 1. Ainsi le
tiera indice (numérotation premier élément de la liste est, pour Python, celui d’indice 0. Le deuxième élément
à partir de 0) et position de la liste est, pour Python, celui d’indice 1, etc.
(numérotation à partir de 1) • L[i] renvoie la (i + 1)ième coordonnée de L. Ainsi, pour accéder au iième élément
dans la liste. de L, la commande est L[i-1].
• L[-1] renvoie le dernier coefficient de L.
• On peut modifier des éléments en utilisant la syntaxe usuelle pour l’affectation
dans une variable.
Par exemple L[2]=5 remplace le 3ième (celui d’indice 2) élément de L par 5.

2
Les commandes append, • On peut ajouter un élément a à une liste L avec la commande L.append(a).
pop et len ne sont pas ex- La commande L.pop(i) renvoie et enlève l’élément d’indice i (i.e. celui en position
plicitement au programme i+1) de la liste L.
mais sont très utiles. • Si L et M sont deux listes, alors la commande L+M concatène les deux listes.
Concaténer deux listes signi- Ainsi la commande L=L+[a] ajoute aussi l’élément a à la liste L.
fie les regrouper pour en • La commande L[:i] renvoie la sous-liste de L constituée des i premiers éléments
créer une nouvelle. de L (i.e les éléments de l’indice 0 à l’indice i-1).
La commande L[i:] renvoie la sous-liste de L constituée des éléments de L à
partir de l’indice i (i.e de la position i+1).
Par exemple L[2:] renvoie [0,8,-9,7,4,0].
Plus généralement la commande i:j renvoie la sous-liste des éléments de L de
l’indice i à l’indice j-1 (i.e. de la position i+1 à la position j).
Ainsi la commande L=L[:i]+L[i+1,:] supprime l’élément d’indice 5 (i.e. en
position 6). La commande L.pop(i) fait la même chose mais renvoie en plus
l’élément supprimé (que l’on peut stocker dans une variable).
On touche ici à une subti- Enfin, la commande L[:] renvoie (une copie de) L.
lité de Python : si jamais • Si n et m sont deux entiers tels que 0 6 m < n implémentés en Python par n
on écrit M=L, alors toute mo- et m, alors range(n) renvoie la liste des entiers compris au sens large entre 0 et
dification de M entraînera n − 1. La commande range(m,n) renvoie la liste des entiers compris au sens large
la même modification de L entre m et n − 1. Et donc range(m,n+1) contient la liste des entiers compris au
(c’est comme ça : il s’agit du sens large entre m et n.
même objet car il est stocké
au même endroit dans la mé-
En fait, il faudrait plutôt écrire list(range(m,n)) pour qu’il s’agisse vraiment
moire) et vice versa. Mais,
d’une liste. A part si on veut lui ajouter ou enlever des éléments, il ne sera pas
si on écrit M=L[:], alors les
nécessaire en pratique d’ajouter list.
listes M et L sont identiques
mais elles sont désormais in- 4) La bibliothèque numpy
dépendantes.
L’utilisation de Python requiert l’importation préalable de bibliothèques (à chaque
démarrage de l’environnement de travail). Nous allons en utiliser plusieurs mais, pour le
Un vecteur est plus ou moins moment, concentrons-nous sur la plus utile : la bibliothèque numpy. Celle-ci contient des
similaire à une liste mais commandes permettant de créer et manipuler des tableaux à plusieurs dimensions (des
tous les éléments sont consi- vecteurs en dimension 1, des matrices en dimension 2).
dérés comme étant du même Pour le moment on limite notre étude aux vecteurs et on étudiera les matrices dans le
type. TP no 6.
• Pour importer la bibliothèque numpy, on utilise la commande

import numpy as np

L et np.array(L) sont de • Si L est une liste de nombres, alors np.array(L) crée le vecteur ligne (tableau
type différent. unidimensionnel) contenant, dans l’ordre, les nombres de la liste.
• On peut créer ainsi un vecteur « à la main » à partir d’une liste mais on peut
aller plus vite pour des vecteurs remarquables (surtout si il y a beaucoup de
coordonnées) : soient n ∈ N et (a, b, h) ∈ R3 implémentés en Python par n,a,b
et h respectivement :
— np.zeros(n) renvoie un vecteur avec n coordonnées toutes nulles.
— np.ones(n) renvoie un vecteur avec n coordonnées valant toutes 1.
— np.linspace(a,b,n) renvoie un vecteur contenant n valeurs comprises
entre a et b (a et b inclus) régulièrement espacées.
Par exemple np.linspace(3,4,6) renvoie
array([3.,3.2,3.4,3.6,3.8,4.])

3
 — Si a < b et h > 0, np.arange(a,b,h) renvoie un vecteur contenant
a, a + h, a + 2h, a + 3h, a + 4h etc. jusqu’à b (b non inclus). Si a > b
et h < 0, alors cela fait la même chose mais dans l’ordre décroissant.
Par exemple np.arange(3,4,0.2) renvoie
array([3.,3.2,3.4,3.6,3.8])
Encore une fois Python nu- et np.arange(6,0,-1) renvoie array([6,5,4,3,2,1])
mérote à partir de 0 et non • On accède aux coordonnées du vecteur (et on les modifie) de la même façon qu’on
de 1 donc on fera la distinc- accède aux éléments d’une liste.
tion entre indice et position • Si on ne connaît pas le nombre de coordonnées d’un vecteur V, il suffit d’utiliser la
dans la liste. commande len(V).
Si on écrit M=L, alors M • On peut effectuer des opération coefficient par coefficient sur des vecteurs via les
contient le vecteur L bien commandes +,-,*,/,**.
sûr. Mais toute modification Par exemple :
du vecteur L provoquera la — V**3 renvoie le vecteur V dont tous les coordonnées ont été élevées à la
même modification sur M im- puissance 3.
plémente (car c’est le même — Si V=np.array([1,2,3]) et W=np.array([0,7,-1]), alors V*W
objet en fait). Si on veut renvoie array([0,14,-3]).
éviter cela, il faut remplacer
On ne peut sommer, soustraire, multiplier, diviser deux vecteurs entre eux que
par M=L par L=np.copy(L)
s’ils ont le même nombre de coordonnées.
ou M=L.copy() (mais ces
• On peut comparer deux vecteurs coefficient par coefficient ou comparer un
commandes ne sont pas exi-
vecteur coefficient par coefficient avec un nombre en utilisant les commandes
gibles) : les modifications du
==,>,<,>=,<=,!=. Le résultat est une matrice de booléens.
vecteur L n’auront alors pas
d’effet sur le vecteur M. Par exemple, si V=np.array([-1,2,3,4]) et W=np.array([7,1,3,5]),
alors V>=W renvoie array([False,True,True,False]).

5) Fonctions usuelles
Les fonctions exp, ln, sin, cos, racine carrée, valeur absolue et partie entière sont implémen-
tées en Python respectivement par np.exp, np.log, np.sin, np.cos, np.sqrt,
La commande int(a) ne np.abs et np.floor.
renvoie pas la partie entière log désigne le logarithme népérien pour Python (c’est la convention anglo-saxonne).
de a si a est réel négatif
Ces fonctions peuvent s’appliquer à des variables numériques ou vectoriellement (à des
non entier, contrairement à
vecteurs réels) coordonnée par coordonnée.
np.floor(a).
Par exemple np.log(np.e) renvoie 1.0.
La commande np.sin([0,np.pi,np.pi/2]) renvoie array([0.0,0.0,1.0]).
Remarques :
• Si x ∈ Dtan est implémenté en Python par x, alors np.sin(x)/np.cos(x) renvoie
On peut aussi utiliser (une approximation de) tan(x).
np.tan(x) mais cette • Si x ∈ R+ et n ∈ N\{0; 1} sont implémentés en Python par x et n, alors x**(1/n)
√
commande n’est pas renvoie (une approximation de) n x.
exigible. • Si x ∈ R est implémenté en Python par x, alors np.arctan(x) renvoie (une
approximation de) Arctan(x) mais cette commande n’est pas exigible. On peut
aussi programmer la fonction Arctan avec la méthode des rectangles (cf. TP no 8)
ou un algorithme de dichotomie (cf. TP no 7).

TP no 2 – Structures de bases de la programmation

Avant de commencer une commande très utile : #. Elle permet d’écrire un commentaire :
tout ce qui suit cette commande (jusqu’au retour à la ligne) ne sera pas exécuté par
Python et qui sert par exemple à expliquer ce que l’on fait, à s’y retrouver. Citons le
programme : « les étudiants doivent savoir faire un usage judicieux des commentaires ».

4
 1) Définition et utilisation d’une fonction
Pour créer une fonction en Python, appelée f, qui prend en entrée des variables
x1,x2,...xn et qui renvoie une variable y, voici la syntaxe :
1 d e f f ( x1 , x2 , . . . xn ) :
2 <b l o c d ‘ i n s t r u c t i o n s >
3 return y

Remarquons les alinéas On remplace <bloc d’instructions> par des commandes permettant de transformer
après la commande def les variables d’entrée en la variable de sortie. En exécutant la fonction dans la console
(il y en a aussi après les Python puis la commande f(x1,x2,...xn), on obtient l’image de x1,x2,...xn par f.
commandes if,elif,else, Exemple : Voici une fonction qui prend en argument un réel x et un entier n et qui
for,while, cf. paragraphes b10n xc
renvoie .
suivants). Ce n’est pas 10n
facultatif : on appelle 1 def tronc (x , n) :
cela l’indentation. En 2 y =10∗∗n
Python, il n’y a pas de 3 r e t u r n np . f l o o r ( y ∗ x ) / y
begin ou de end, ni de
La commande tronc(np.pi,5) renvoie 3.14159. Elle tronque l’écriture décimale de π
marqueurs du début ou de
à 5 chiffres.
la fin d’un code. Les seuls
délimiteurs sont les : et Remarques :
l’indentation (l’indentation • Les variables x1,x2,...,xn,y peuvent tout à fait être de types différents. Notam-
démarre la structure et ment y peut être une liste, un vecteur ou une matrice s’il y a plusieurs arguments
la « désindentation » la de sortie.
termine).
• Ne pas confondre return et print (qui ne fait même pas partie des com-
mandes exigibles) qui afficherait la variable de sortie mais sans la retourner (celle
ci serait inutilisable dans la suite car on ne pourrait pas récupérer ce qui est affiché
dans une variable).
• Si f est une fonction qui prend en entrée un réel x et qui renvoie un réel y, il est
classique de vouloir appliquer f à une liste ou un tableau X pour récupérer une
liste ou un tableau Y contenant les images des éléments de X. Pour cela on utilise
On peut aussi « vectoriser » la syntaxe Y=[f(x) for x in X].
la fonction avec la com- Si X=range(-2,5), alors la commande [x**2+1 for x in X] renvoie
mande f=np.vectorize(f) [5,2,1,2,5,10,17].
puis utiliser Y=f(X)
2) Structures conditionnelles
Si on veut que le bloc d’instructions <bloc d’instructions> soit exécuté si la condition
<condition> est remplie, et que le bloc d’instructions <bloc d’instructions sinon>
S’il n’y a pas d’instruction soit exécuté sinon, voici la syntaxe :
alternative, alors on ne met 1 i f <c o n d i t i o n >:
pas les deux dernières lignes. 2 <b l o c d ‘ i n s t r u c t i o n s >
3 else :
4 <b l o c d ‘ i n s t r u c t i o n s s i n o n >

Si on veut que le bloc d’instructions <bloc d’instructions 1> soient exécuté si la

condition <condition 1> est remplie, le bloc d’instructions <bloc d’instructions 2>
si la condition <condition 2> est remplie, le bloc d’instructions
<bloc d’instructions 3> si la condition <condition 3> est remplie... et enfin le bloc
d’instructions <bloc d’instructions sinon> si aucune de ces dernières conditions
n’est remplie, voici la syntaxe :

5
Vous aurez compris que 1 i f <c o n d i t i o n 1 >:
elif est une contraction de 2 <b l o c d ‘ i n s t r u c t i o n s 1>
3 e l i f <c o n d i t i o n 2>:
else if.
4 <b l o c d ‘ i n s t r u c t i o n s 2>
5 e l i f <c o n d i t i o n 3>:
6 <b l o c d ‘ i n s t r u c t i o n s 3>
7 ...
8 else :
9 <b l o c d ‘ i n s t r u c t i o n s sinon>

Exemple : Voici une fonction qui prend en entrée trois réels a, b, c avec a 6= 0 et qui
renvoie une liste contenant les solutions de l’équation ax2 + bx + c = 0.
1 def trinome (a , b , c ) :
2 D=b∗∗2−4∗ a ∗ c
3 i f D>0:
4 r e t u r n [( −b−np . s q r t (D) ) / ( 2 ∗ a ) ,( − b+np . s q r t (D) ) / ( 2 ∗ a ) ]
5 e l i f D==0:
6 r e t u r n [−b / ( 2 ∗ a ) ]
7 else :
8 return [ ]

3) Structures répétitives
Les structures répétitives (ou itératives) permettent d’effectuer plusieurs opérations à la
suite. En général, la construction d’une telle structure au sein d’un programme se base
sur quatre étapes :
• On identifie les variables d’entrées (qui proviennent du début du programme ou
qui sont des arguments d’entrée d’une fonction par exemple).
• On définit des variables qui vont être modifiées lors de la boucle. C’est l’étape
d’initialisation.
• On écrit la boucle en tant que telle. Elle utilise les variables d’entrée et, à chaque
étape de la boucle, les variables définies à l’étape d’initialisation sont mises à jour.
• On renvoie les variables de sorties (en général des fonctions des quantités calculées
pendant la boucle).

a) Boucles for
On emploie les boucles for lorsqu’on veut exécuter un bloc d’instructions un certain
Souvent T=range(a,b) (la nombre de fois, nombre que l’on connaît. Soit T une liste ou un tableau.
liste des entiers compris au
1 f o r x in T:
sens large entre l’entier a et 2 <b l o c d ‘ i n s t r u c t i o n s >
l’entier b-1).
La variable x va prendre tour à tour et dans l’ordre les valeurs présentes dans T et, pour
chacune d’entre elle, elle va exécuter le bloc d’instructions <bloc d’instructions>.
Ce dernier peut dépendre ou non de x.
x est une variable muette dans la boucle (il faut la voir comme un indice de
sommation par exemple) et ne doit pas être introduite.

Pour cela parcourt la liste Exemple : La fonction suivante prend en argument une liste (ou un vecteur) et renvoie
avec une boucle for. Pour le nombre d’éléments qui sont strictement positifs.
chaque élément, elle teste si 1 def nb_st_positif (L) :
il est strictement positif ou 2 n=0#Au d é p a r t , aucun é l é ment n ‘ e s t s t r i c t e m e n t p o s i t i f .
non et, si c’est le cas, elle 3 f o r x i n L :#Pour chaque é l é ment de l a l i s t e
4 i f x >0:#S i c e t é l é ment e s t s t r i c t e m e n t p o s i t i f
incrémente un compteur de 5 n=n+1#Ca en f a i t un de p l u s
1. Ici n est le compteur et 6 return n
sa valeur est mise à jour (1
de plus) si on rencontre un
La commande nb_st_positif([1,-8,5,9,-7,-4,7,3,2]) renvoie 6.
élément strictement positif.
6
 L’une des fonctionnalités les plus intéressantes de Python est la possibilité de définir des
Les boucles for servent prin- listes « par compréhension » : si f est une fonction et T une liste ou un tableau, alors la
cipalement à calculer des commande [f(x) for x in T] construit la liste des images des éléments de T par la
sommes, produits ou les fonction f. On a vu un exemple dans le paragraphe précédent.
termes successifs d’une suite.
C’est l’objet du prochain TP. b) Boucles while
On emploie les boucles while lorsqu’on veut exécuter un bloc d’instructions tant qu’une
certaine condition est remplie (souvent lorsqu’on ne l’on connaît pas précisément le
Les variables interve- nombre d’itérations à exécuter).
nant dans la condition
1 w h i l e <c o n d i t i o n >:
<condition> doivent être 2 <b l o c d ‘ i n s t r u c t i o n s >
introduites préalablement
contrairement à l’indice Tant que la condition <condition> est remplie, le bloc d’instructions
dans une boucle for. <bloc d’instructions> sera exécuté. Il est donc essentiel que l’exécution
de <bloc d’instructions> vienne modifier la condition <condition> afin que cette
dernière finisse par devenir fausse (sinon la boucle va durer éternellement).

Pour trouver nA , l’idée est Exemple : On sait que n3 − 7n + 2021 −−−−−→ +∞ et donc, pour tout A > 0, il existe
n→+∞
de démarrer avec n = 0 et, nA ∈ N tel que, pour tout n > nA , n3 − 7n + 2021 > A. La fonction suivante prend A
tant que n3 −7n+2021 < A, en argument et détermine nA .
on augment de 1 la valeur
1 d e f rang_min (A) :
de n.
2 n=0
3 w h i l e n∗∗3−7∗n+2021<A :
4 n=n+1
5 return n

On verra d’autres exemples La commande rang_min(10000) renvoie 21, la commande rang_min(100000) renvoie
dans le TP consacré aux 47 et la commande rang_min(1000000) renvoie 100.
sommes.
TP no 3 – Sommes, produits et suites avec Python
1) Calcul de sommes et produits « simples »

L’outil informatique trouve Le but de cette partie est de calculer des valeurs approchées avec Python d’une somme
X Y
son intérêt lorsque l’on n’ar- ui ou d’un produit ui d’une famille de réels (ui )i∈I indexée par un ensemble fini I.
rive pas à trouver une for- i∈I i∈I
mule pour la somme ou le Comment faire ?
produit. • On code la famille I en une liste Python I. En général :
— si n ∈ N∗ et I = J0 ; nK, on prend I=range(n+1).
— si n ∈ N∗ et I = J1 ; nK, on prend I=range(1,n+1).
— si m et n sont des entiers relatifs tels que m < n et si I = Jm ; nK, on prend
I=range(m,n+1).
Bien sûr I peut être quelconque (fini) mais, en général, soit on arrive à se ramener à
l’un des cas précédents soit on construit I à la main (lorsqu’il y a peu d’éléments).
On peut aussi sommer/mul- • Si les expressions des réels de la famille (ui )i∈I sont compliquées, on peut construire
tiplier des termes d’une suite. une fonction en Python (appelons-la u), qui prend en argument un élément i de I
Nous verrons cela dans le et qui renvoie une expression de ui .
prochain paragraphe. • Pour les sommer, on dispose essentiellement de deux options :
— Faire une boucle sur les éléments de I telle que, à chaque étape, on ajoute le
Ne pas oublier d’initialiser la terme suivant à la somme.
somme à 0 (une somme vide
1 S=0
est nulle). 2 for i in I :
3 S=S+u [ i ]

7
 — Créer une liste contenant les réels ui , i ∈ I et les sommer.
1 i m p o r t numpy a s np
2 S=np . sum ( [ u ( i ) f o r i i n I ] )

Dans les deux cas, la variable S contient la somme que l’on cherchait à calculer.
• Pour les multiplier, on dispose essentiellement de deux options :
— Faire une boucle sur les éléments de I telle que, à chaque étape, on multiplie
Ne pas oublier d’initialiser le le produit par le terme suivant.
produit à 1 (un produit vide
1 P=0
vaut 1). 2 for i in I :
3 P=P∗u [ i ]

— Créer une liste contenant les réels ui , i ∈ I et les multiplier.

1 i m p o r t numpy a s np
2 P=np . p r o d ( [ u ( i ) f o r i i n I ] )

Dans les deux cas, la variable P contient le produit que l’on cherchait à calculer.

Exemples : 20
X
• Pour calculer i2 :
i=0
1 np . sum ( [ i ∗∗2 f o r i i n r a n g e ( 2 1 ) ] )
2021
X i
• Pour calculer :
i=17
31+i2
1 np . sum ( [ i /(3∗∗(1+ i ∗ ∗ 2 ) ) f o r i i n r a n g e ( 1 7 , 2 0 2 2 ) ] )
n
Y
Cette commande fonctionne • Pour tout n ∈ N∗ , n! = k donc pour calculer n! :
même si on prend n = 0. k=1

En effet, dans ce cas, on fait 1 np . p r o d ( [ k f o r k i n r a n g e ( 1 , n+1) ] )

le produit d’une liste vide et
celui-ci vaut 1.
• Pour tous n ∈ N∗ et p ∈ J0 ; nK,
  p−1
n n(n − 1)(n − 2) · · · (n − p + 1) Y n−k
On n’utilise surtout pas la = = .
p p(p − 1)(p − 2) · · · 1 p−k
formule avec les trois facto- k=0

rielles. On verra pourquoi en

 
n
exercice. Ainsi pour calculer :
p
1 np . p r o d ( [ ( n−k ) / ( p−k ) f o r k i n r a n g e ( p ) ] )
X
On peut même calculer des • Pour calculer Tn = ij :
sommes doubles, qui ne 16i<j6n

sont rien d’autres que des 1 S=0

2 f o r i in range (1 , n) :
sommes de sommes.
3 f o r j i n r a n g e ( i +1,n+1) :
4 S=S+i ∗ j

ou encore (si on ne veut pas prendre la peine de réfléchir à comment couper en

deux sommes) :
1 S=0
2 f o r i i n r a n g e ( 1 , n+1) :
3 f o r j i n r a n g e ( 1 , n+1) :
4 i f i <j :
5 S=S+i ∗ j

8
 2) Suites réelles avec Python

L’idée générale est d’écrire L’outil informatique est précieux pour calculer des approximations des termes successifs
un programme avec une va- d’une suite définie par récurrence lorsqu’on ne peut pas trouver une formule générale
riable u initialisée en le pre- explicite. Il permet aussi de représenter graphiquement l’évolution d’une suite et de
mier terme de la suite. On conjecturer éventuellement sa nature et la valeur de sa limite (si elle existe). Supposons
fait ensuite une boucle for que (un )n∈N est une suite telle que, pour tout n ∈ N, un+1 = F (un , n) avec F une
(si on veut calculer le terme fonction de R2 dans R.
d’un certain rang donné) ou Par exemple :
une boucle while (si on veut — Si F : (x, y) 7−→ 3x − 1, alors un+1 = 3un − 1 pour tout n ∈ N.
calculer un terme vérifiant
x2 u2n
une certaine condition) telle — Si F : (x, y) 7−→ , alors un+1 = pour tout n ∈ N.
y+1 n+1
que, à chaque étape, on
On suppose que l’on a implémenté F au préalable en Python.
transforme u en le terme sui-
vant.
a) Calculer et représenter les premiers termes de la suite

Si le premier rang de Soient n ∈ N∗ et x ∈ R. Le script suivant calcule le nième terme de la suite de terme
la suite est n0 , on rem- initial x et le stocke dans la variable u :
place range(n) par 1 u=x
range(n0,n). 2 f o r k in range (n) :
3 u=F ( u , k )

Si la suite converge vers ` ∈ R alors, lorsque n est grand, on obtient une approximation
Généralement on s’est donné de `. Le script suivant calcule les premiers (du 0ième au nième) termes de la suite de terme
ε > 0 petit et on a déter- initial x et les stocke dans un tableau L :
miné au préalable un entier 1 i m p o r t numpy a s np
n afin que |un − `| 6 ε, par 2 u=x ; L=np . z e r o s ( n+1) ; L [ 0 ] = u
exemple à l’aide de l’inéga- 3 f o r k in range (n) :
4 u=F ( u , k )#On c a l c u l e l e t e r m e s u i v a n t
lité des accroissements finis. 5 L [ k+1]=u#On l e met d a n s l a c o o r d o n n é e s u i v a n t e

Dans le script précédent, on a commencé par créer une liste avec que des 0 et on a
remplacé les 0 tour à tout par les valeurs successives de la suites. On aurait aussi pu
créer une liste vide et lui ajouter à chaque étape le terme suivant :
1 u=x ; L=[u ]
2 f o r k in range (n) :
3 u=F ( u , k )#On c a l c u l e l e t e r m e s u i v a n t
4 L . append ( u )#On l ’ a j o u t e à l a l i s t e

b) Le cas des suites récurrentes d’ordre 2

C’est un classique à Soient a, b, x, y des réels tels que b 6= 0. Considérons la suite (un )n∈N telle que u0 = x,
connaître. On a besoin de u1 = y et
deux variables que l’on ∀n ∈ N, un+2 = aun+1 + bun .
met à jour à chaque étape Si n ∈ N∗ , le script suivant calcule le nième terme de la suite (en renvoyant u) :
puisque, pour calculer un
terme, on a besoin des deux 1 u=x ; v=y
2 f o r k in range (n) :
précédents. 3 w=v
4 v=a ∗ v+b∗u#v c o n t i e n t l e t e r m e que l ’ on v i e n t de c a l c u l e r à
l ’ a i d e d e s deux p r é c é d e n t s
5 u=w#u d e v i e n t l e t e r m e p r é c é d e n t

Il fallait introduire une va- Autre possibilité, pour condenser :

riable w intermédiaire car,
1 u=x ; v=y
en écrivant v=a*v+b*u, on 2 f o r k in range (n) :
perd l’ancienne valeur de v. 3 u , v=v , a ∗ v+b∗u

9
 On peut aussi utiliser une liste contenant les valeurs précédentes :
1 L=np . z e r o s ( n+1) ; L [ 0 ] = x ; L [ 1 ] = y
2 f o r k i n r a n g e ( 2 , n+1) :
3 L [ k ]= a ∗L [ k−1]+b∗L [ k −2]

c) Sommer ou multiplier les premiers termes d’une suite

On a déjà vu dans le para- Le script suivant calcule la somme des premiers (du 0ième au nième) termes de la suite de
graphe précédent comment terme initial x et la stocke dans s :
calculer une valeur appro- 1 u=x ; s=u
chée d’une somme à l’aide 2 f o r k in range (n) :
de Python. Lorsqu’il s’agit 3 u=F ( u , k )
4 s=s+u
d’une suite récurrente, on
fait exactement comme dans Remarques :
les paragraphes précédents • On peut remplacer s=s+u par s+=u.
mais, à chaque étape de la
• Si on désire multiplier les termes d’une suite, on remplace juste s=s+u par s=s*u
boucle, on ajoute le nouveau
ou s*=u
terme aux précédents.
Exemple : Soit x ∈ R. Pour tout n ∈ N, posons
n
X xk
Sn (x) = .
k!
k=0

On pourrait calculer cette somme comme dans le paragraphe précédent :

1 S=1//Le 0− i ème t e r m e
2 f o r k i n r a n g e ( 1 , n+1) :
3 S=S+x ∗∗ k / np . p r o d ( [ i f o r i i n r a n g e ( 1 , k+1) ] )

C’est une mauvaise idée puisque, à chaque terme ajouté, on calcule la factorielle du
Si on connaît 72 ! et que l’on dénominateur sans utiliser le fait qu’on l’avait presque calculée au rang d’avant. Même
veut calculer 73 !, il est dom- xk
remarque pour la puissance. On va faire mieux : pour tout k ∈ N, posons uk (x) = .
mage de recommencer tout k!
le calcul, alors qu’il suffit de
On remarque que u0 (x) = 1 et
multiplier 72 ! par 73... x
∀k ∈ N, uk+1 (x) = uk (x).
k+1
Le script ci-dessous crée une fonction qui prend en entrée x et calcule Sn (x) :
1 i m p o r t numpy a s np
2 def S(n , x ) :
3 u =1; s=1
4 f o r k in range (n) :
5 u=x ∗u / ( k+1)
6 s=s+u
7 return s

d) Calculer le plus petit rang pour lequel la suite vérifie une

condition
Il est classique de chercher à calculer le nombre d’itérations nécessaires pour obtenir une
approximation de la limite (la connaissant) d’une suite convergente avec une précision
donnée. Si on connait la limite de la suite et qu’on la stocke dans une variable lim, alors
le script suivant calcule le plus petit rang n tel que |un − lim| 6 eps :
1 u=x ; n=0
2 w h i l e a b s ( u−l i m )>e p s :
3 u=F ( u , n )
4 n=n+1

10
 Si on sait que la suite tend vers +∞, alors le script suivant calcule le plus petit rang n
tel que un > A, pour A un réel :
1 u=x ; n=0
2 w h i l e u<A :
3 u=F ( u , n )
4 n=n+1

n
X 1
Exemple : Pour tout n ∈ N∗ , posons Hn = . La suite (Hn )n∈N∗ tend vers +∞.
k
k=1
Écrivons une fonction en Python qui prend A > 0 en entrée et qui détermine le plus
La suite semble converger petit rang n ∈ N∗ pour lequel Hn > A (ce rang existe puisque la suite tend vers +∞).
très lentement vers +∞. 1 d e f Rang (A) :
C’est normal, on montrera 2 H=1; n=1
dans le chapitre 13 que 3 w h i l e H<A :
Hn 4 H=H+1/(n+1)
−−−−−→ 1. Elle
ln(n) n→+∞ 5 n=n+1
converge aussi lentement 6 return n
vers +∞ que (ln(n))n>1 .
L’exécution de Rang(10) renvoie 12367, l’exécution de Rang(15) renvoie 1835421 et
l’exécution de Rang(20) renvoie 272400600.

TP no 4 – Probabilités avec Python – Première partie

Pour faire des simulations de variables aléatoires avec Python, on commence par importer
la bibliothèque numpy.random avec la commande

import numpy.random as rd

1) Du hasard avec un ordinateur ?

Anyone who considers arithmetical methods of producing random digits is, of course, in
a state of sin.

John von Neumann (1903- John von Neumann

1957) est un mathémati-
cien et physicien américano- Simuler une variable aléatoire réelle d’une loi donnée à l’aide d’un ordinateur consiste à
hongrois. construire un nombre réel que l’on peut assimiler à une réalisation X(ω) d’une variable
aléatoire X ayant cette loi.

Il existe plusieurs généra- Ce procédé repose en général sur deux étapes :

teurs basés sur des phé- • Simuler des variables aléatoires indépendantes de loi uniforme sur ]0 ; 1[.
nomènes physiques (et cer- • Réaliser des opérations sur les simulations afin d’obtenir la réalisation d’une variable
tains sont brevetés et dis- aléatoire de loi voulue.
ponibles dans le commerce).
La première étape pose des problèmes à la fois conceptuels et pratiques... notamment
Ils reposent par exemple sur
comment demander à un ordinateur de faire un choix aléatoire, alors que celui-ci est
des capteurs de bruit ther-
programmé pour n’effectuer qu’une suite d’instructions déterministes ? Aucune solution
mique dans les résistances
totalement satisfaisante n’a été proposée à ce jour. La plupart des générateurs sont
de circuits électroniques, ou
fondés sur des calculs de congruences sur des grands nombres de façon déterministe
sur d’autres mécanismes ba-
(mais que l’on peut initialiser avec l’horloge de l’ordinateur pour ajouter une dose de
sés sur la physique quan-
hasard). On parle alors de générateurs de nombres pseudo-aléatoires : les nombres générés
tique, etc. Ces générateurs
possèdent les propriétés apparentes d’une suite de variables aléatoires indépendantes et
contiennent du vrai hasard
de loi uniforme sur ]0 ; 1[ :
mais ils sont encombrants,
pas toujours fiables, pas faci- • La suite de nombres se comporte de façon chaotique, de sorte que les éléments
lement reproductibles et ne successifs de cette suite de nombres semblent imprévisibles. Plus précisément, pour
sont pas accessibles à une tout k ∈ N∗ , la connaissance des k − 1 premiers termes de la suite ne semble pas
analyse mathématique rigou- nous donner d’information sur le k ième terme.
reuse.
11
 • La moyenne des premiers nombres de la suite semble se concentrer asymptotique-
ment (quand le nombre de termes moyennés tend vers +∞) vers une quantité
fixe.
Presque toutes les fonctions du module dépendent de la fonction de base random(),
qui génère un réel dans [0 ; 1[. Python utilise l’algorithme Mersenne Twister comme
générateur de base. C’est l’un des générateurs de nombres aléatoires les plus largement
testés qui existent. Cependant, étant complètement déterministe, il n’est pas adapté à
Notamment il est totale- tous les usages.
ment inadapté à des fins
cryptographiques 2) Simulation d’une variable aléatoire de loi finie usuelle
a) Loi de Bernoulli
Supposons que p ∈ ]0 ; 1[ a été implémenté en Python dans la variable p. Pour obtenir
une réalisation d’une variable aléatoire de loi de B(p), on peut utiliser la fonction :
1 X=r d . b i n o m i a l ( 1 , p )

Une autre possibilité est d’utiliser la commande U=rd.random() qui renvoie un réel
choisi uniformément entre 0 et 1. Si on pose X=1 lorsque U<p et X=0 sinon, alors X=1
avec fréquence p et X=0 avec fréquence 1 − p, c’est-à-dire X contient une réalisation
Cette deuxième possibilité, d’une variable aléatoire de loi B(p).
bien que plus compliquée 1 i f r d . random ( )<p :
au premier abord, est préfé- 2 X=1
3 else :
rable car on peut facilement
4 X=0
l’adapter si on veut autre
chose que des 0 et 1 ou si on
veut plusieurs alternatives à b) Loi binomiale
l’expérience. On verra des
exemples en TP.
Supposons que n ∈ N∗ et p ∈ ]0 ; 1[ ont été implémentés en Python dans les variables n
et p. Pour obtenir une réalisation d’une variable aléatoires de loi de B(n, p),
• on peut utiliser

1 X=r d . b i n o m i a l ( n , p )

• on peut utiliser simuler n variables de loi B(p) avec la rd.random() (cf. para-
graphe précédent) et les sommer. En effet on peut considérer que les différents
appels de cette fonction sont des réalisations de variables aléatoires mutuellement
indépendants. Ainsi les sommer revient à compter le nombre de 1, donc compter le
Cette deuxième possibilité, nombre de succès. On utilise alors :
bien que plus compliquée
1 X=0
au premier abord, est pré-
2 f o r k in range (n) :
férable car on peut fa- 3 i f r d . random ( )<p :
cilement l’adapter si on 4 X=X+1
somme des succès d’expé-
riences non indépendantes • on peut utiliser la commande U=rd.random(n) qui renvoie un vecteur contenant
ou non identiques. On verra n réels choisis uniformément entre 0 et 1. La commande U<p renvoie un vecteur
des exemples en TP. contenant des True aux coordonnées de U qui sont inférieurs à p et des False
aux autres. Il suffit de sommer les coordonnées de U<p pour compter le nombre de
True (le nombre de succès). Ainsi :

1 np . sum ( r d . random ( n )<p )

contient une réalisation d’une variable aléatoire de loi B(n, p).

12
 c) Loi uniforme
Supposons que les réels a et b (tels que a < b) ont été implémentés en Python dans les
variables a et b. Pour obtenir une réalisation d’une variable aléatoire de loi de U(Ja ; bK),
on peut utiliser la fonction :
1 X=r d . r a n d i n t ( a , b+1)

d) Et les autres lois finies ?

On peut simuler n’importe quelle loi mais il n’y a rien à connaître de plus en ECG.
Laissez-vous guider par les énoncés !

3) Vecteurs et matrices de variables de lois finies usuelles

On peut bien sûr utiliser des boucles for pour construire des listes contenant des variables
aléatoires de lois usuelles en utilisant les commandes du paragraphe précédent. Pour les
commandes rd.binomial et rd.randint, on peut plus simplement :
• rajouter pour paramètre m à l’une de ces commandes et on obtient un vecteur
contenant m réalisations de variables aléatoires de la loi (que l’on peut considérer
Nous verrons les matrices indépendantes).
dans le TP no 6. Pour faire • rajouter pour paramètre [n,m] à l’une de ces commandes et on obtient une matrice
simple, ce sont des tableaux de taille n × m contenant des réalisations de variables aléatoires de la loi (que l’on
bidimensionnels (du type peut considérer indépendantes).
ndarray).
Exemples :
• rd.binomial(10,0.3,7) renvoie array([2, 3, 3, 4, 5, 0, 3]).
• rd.binomial(10,0.3,[3,5]) renvoie array([[4, 4, 5, 2, 4], .
[2, 2, 2, 3, 5],
[3, 3, 5, 3, 2]])

TP no 5 – Représentations graphiques
Pour faire des représentations graphiques, on commence par importer la bibliothèque
matplotlib.pyplot avec la commande

import matplotlib.pyplot as plt

1) Relier des points du plan

Considérons des points du plan dont on connaît les abscisses et les ordonnées, disons
On peut aussi tracer des A1 (x1 , y1 ), A2 (x2 , y2 ), . . . , An (xn , yn ). On implémente ces points en Python en mettant
fonctions en escalier avec x1 , . . . , xn dans une liste ou un vecteur X et y1 , . . . , yn dans une liste ou un vecteur Y.
plt.step() mais cette Alors
commande n’est pas offi-
ciellement au programme. • np.plot(X,Y) relie les points A1 , A2 , . . . , An (dans cet ordre).
Toutefois on l’utilisera dans • plt.show() affiche la représentation graphique. Cette commande doit être mise à
TP no 9 pour tracer des
la toute fin (après avoir appelé différents plt.plot et ajouté d’éventuelles options).
fonctions de répartitions.
Avec les points de l’exemple
Exemple :
ci-contre cela donnerait
4

1 import m a t p l o t l i b . pyplot as p l t 2
2
2 X=r a n g e ( −4 ,8)
3 Y= [ 3 , 2 , − 1 , 4 , 3 , 4 , 2 , 2 , 0 , 2 , − 2 , 0 ]
0
4 p l t . p l o t (X , Y) 0

−2
5 p l t . show ( )
−4 −2 0 2 4 6 −2
−4 −2 0 2 4 6

13
2) Options de tracé
Les commandes de ce paragraphe ne sont pas au programme. Il est inutile le jour des
concours de mettre de la couleur à des courbes, des légendes, etc. Mais en TP, on les
utilisera ne serait-ce que pour différencier les tracés lorsqu’on en superpose.
• Il est possible de préciser la couleur, le style de ligne et de symbole en ajoutant
une chaîne de caractères en option dans la commande plt.plot :
— pour la couleur : b (bleu), g (vert), r (rouge), c (cyan), m (magenta), y (jaune),
k (noir), w (blanc).
— pour le style : - (ligne continue), – (tirets), : (ligne en pointillé), -. (tirets
points).
— pour les symboles : . (point), , (pixel), o (cercle), v (triangle bas), ∧ (triangle
haut), < (triangle gauche), > (triangle droit), s (carré), p (pentagone), h
(hexagone), d (diamant), D (gros diamant), * (étoile), + (plus), x (croix), etc.
Par exemple plt.plot(X,Y,’r–*’) affiche la courbe avec des étoiles rouges
à chaque point et les relie en pointillés rouges.
• Pour afficher une légende à une courbe, on ajoute l’option
label(’Légende_courbe’) à l’intérieur de la commande plt.plot qui trace
la courbe, où ’Légende_courbe’ est une chaîne de caractères contenant la lé-
gende. Ensuite on place la commande plt.legend().
• Pour afficher un titre à une fenêtre graphique, on ajoute la commande
plt.title(’Titre_graphique’) où ’Titre_graphique’ est une chaîne de
caractères contenant le titre.
• Si on fait appelle plusieurs fois à la commande plt.plot, les courbes successives
seront tracées dans la même fenêtre. Si on veut changer de fenêtre, on utilise
la commande plt.figure(). Dorénavant les tracés se feront dans une nouvelle
fenêtre (la même tant qu’on ne fait pas appel de nouveau à plt.figure()).

Exemple :
1 X=r a n g e ( −4 ,8)
2 Y= [ 3 , 2 , − 1 , 4 , 3 , 4 , 2 , 2 , 0 , 2 , − 2 , 0 ]
3 p l t . p l o t (X , Y , ’m−.D ’ , l a b e l= ’ c o u r b e 1 ’ )
4 p l t . p l o t (Y , X , ’ g :+ ’ , l a b e l= ’ c o u r b e 2 ’ )
5 plt . legend ()
6 p l t . t i t l e ( ’ Un e x e m p l e de t r a c é p e r s o n n a l i s é ’ )
7 p l t . show ( )

Un exemple de tracé personnalisé

courbe1
6 courbe2

−2

−4
−4 −2 0 2 4 6

14
 3) Tracer le graphe d’une fonction de R dans R
Tracer la courbe représentative d’une fonction sur un intervalle, revient à tracer une
infinité de points. Or il n’est évidemment pas possible pour un ordinateur de réaliser une
infinité d’instructions. L’approche de Python pour tracer une courbe est de représenter
un nombre fini de points et de les relier par une ligne continue. La puissance de calcul
des ordinateurs permet de considérer un très grand nombre de points et d’obtenir ainsi
une très bonne approximation de la courbe par une ligne brisée dont les abscisses sont
très proches afin de donner l’illusion de courbe.
Soit f une fonction à valeurs réelles définie sur [a ; b] avec a et b deux réels tels que
a < b. Supposons que l’on ait implémenté a, b, f en Python par a,b,f respectivement.
Représenter graphiquement le graphe de f sur [a ; b] consiste en essentiellement trois
étapes :
• On « discrétise » l’intervalle [a ; b] en un grands nombre de points régulière-
ment espacés (disons n avec, en général, n=1000 ou 10000) via la commande
X contient donc un tableau X=np.linspace(a,b,n). Il s’agit du vecteur des abscisses.
contenant n nombres régu- • On crée le vecteur des ordonnées qui contient les images de tous les points du
lièrement espacés entre les vecteur X par la fonction f via la commande Y=[f(x) for x in X].
réels a et b.
• Enfin, on trace la courbe via la commande plt.plot(X,Y) puis on l’affiche avec
plt.show()
x sin(x)
Exemple : Représentons la fonction x 7−→ sur [−20 ; 20] en rouge :
1 + x2

0.4
1 def f ( x ) :
2 r e t u r n x ∗ np . s i n ( x ) /(1+ x ∗ ∗ 2 ) 0.2
3 X=np . l i n s p a c e ( − 2 0 , 2 0 , 1 0 0 0 )
4 Y=[ f ( x ) f o r x i n X ] 0
5 p l t . p l o t (X , Y , ’ r ’ )
6 p l t . show ( )
−0.2
−20 −10 0 10 20

Il y un cas particulier à connaître : celui consistant à tracer une droite. Un premier

réflexe serait d’implémenter une fonction affine en Python puis d’effectuer la démarche
précédente. Cela serait ultra fastidieux : pour tracer une droite, il suffit de relier deux
points. Ainsi, si c et d sont deux réels implémentés en Python par c et d respectivement,
• la commande plt.plot([a,b],[c,d]) trace la droite passant par les points de
i.e. la droite d’équation coordonnées (a, c) et (b, d).
d−c
y= (x − a) + c. • la commande plt.plot([a,b],[c,c]) trace la droite d’équation y = c. Cela est
b−a
particulièrement pratique pour visualiser la convergence d’une suite (cf. paragraphe
suivant) ou tracer une asymptote horizontale.

4) Représentation des termes d’une suite

Soit n ∈ N. Représenter les n + 1 premières valeurs d’une suite (un )n∈N consiste à relier
les points (0, u0 ), (1, u1 ), (2, u2 ), . . . , (n, un ).

n + 1 car il y a u0 . Supposons que l’on ait stocké les n+1 premières valeurs d’une suite dans une liste L. Si on
veut ensuite représenter graphiquement les termes en question, on utilise les commandes :
1 import m a t p l o t l i b . pyplot as p l t
2 p l t . p l o t ( r a n g e ( n+1) , L )
3 p l t . show ( )

15
 Exemples :
C’est le cas particulier de la • Représentons les 21 premières valeurs de la suite (un )n∈N telle que u0 = 3/4 et
suite du paragraphe V.3.b. u2n 4
Sur le graphique obtenu, ∀n ∈ N, un+1 = + un .
2 7
on conjecture que la suite
converge vers 0 (ce que l’on
1 n =20; u =3/4; 0.6
a montré). 2 L=np . z e r o s ( n+1) ; L [ 0 ] = u
3 f o r k in range (n) : 0.4
4 u=u ∗∗2/2+4∗ u /7
5 L [ k+1]=u 0.2
6 p l t . p l o t ( r a n g e ( n+1) , L , ’ b ’ )
7 p l t . show ( ) 0
0 5 10 15 20

C’est le cas particulier de la • Représentons les 16 premières valeurs de la suite (un )n∈N telle que u0 = 1 et
suite du paragraphe V.3.c du 2
chapitre 6. Sur le graphique
∀n ∈ N, un+1 = 1 + .
un
obtenu, on conjecture que la
3
suite converge vers 2 (ce que 1 n =16; u =1;
l’on a montré). Pour aider à 2 L=np . z e r o s ( n+1) ; L [ 0 ] = u 2.5
3 f o r k in range (n) :
la lecture, on a superposé la
4 u=1+2/u 2
droite d’ordonnée 2. 5 L [ k+1]=u
6 p l t . p l o t ( r a n g e ( n+1) , L , ’ b ’ ) 1.5

7 plt . plot ([0 ,15] ,[2 ,2] , ’ r ’ )

8 p l t . show ( ) 1
0 2 4 6 8 10 12 14
n
X xk
• Soit x ∈ R. Reprenons l’exemple de Sn (x) = , n ∈ N. Nous verrons dans le
k!
k=0
chapitre 19 que Sn (x) −−−−−→ ex . Le script ci-dessous crée une fonction qui prend
n→+∞
en entrée x et qui représente graphiquement les n + 1 premières valeurs de la suite
(Sn (x))n∈N et lui superpose la droite d’ordonnée ex pour obtenir ce graphique. On
conjecture bien que la somme tend effectivement vers ex .
1 import m a t p l o t l i b . pyplot as p l t 1
2 i m p o r t numpy a s np
3 def S(n , x ) : 0.8
4 u =1; s =1; L=[ s ]
5 f o r k in range (n) : 0.6
6 u=x ∗u / ( k+1)
0.4
7 s=s+u
8 L . append ( s ) 0.2
9 p l t . p l o t ( r a n g e ( n+1) , L , ’ b ’ )
10 Y=[ np . exp ( x ) , np . exp ( x ) ] 0
11 p l t . p l o t ( [ 0 , n ] ,Y, ’ r ’ ) 0 2 4 6 8 10
Ci-contre, on a exécuté 12 p l t . show ( )
S(10,-1).

5) Diagrammes à barres et histogrammes

On peut aussi tracer des diagrammes à barres (ou en bâton) : à chaque valeur d’abscisses,
on trace un bâton dont la longueur est l’ordonnée correspondante à l’abscisse. Pour cela
Cette commande est très on remplace plt.plot() par plt.bar().
utile mais n’apparaît pas Exemple : On a vu en cours que la loi d’une variable aléatoire finie représentant la
officiellement dans le pro- somme de deux dés lancés simultanément est donnée par le tableau :
gramme.

k 2 3 4 5 6 7 8 9 10 11 12
1 1 1 1 5 1 5 1 1 1 1
pk
36 18 12 9 36 6 36 9 12 18 36

16
 Traçons en Python le diagramme à barres correspondant :

0.15

1 X=r a n g e ( 2 , 1 3 )
2 Y=np . a r r a y 0.1
( [ 1 , 2 , 3 , 4 , 5 , 6 , 5 , 4 , 3 , 2 , 1 ] ) /36
3 p l t . b a r (X , Y)
5 · 10−2
4 p l t . show ( )

0
2 4 6 8 10 12

Nous verrons le cas des va- Nous construirons les diagrammes à barre pour les lois finies usuelles en TP.
riables aléatoires discrètes in-
finies dans le TP no 9. 6) Histogramme
Si on dispose d’une liste (ou d’un vecteur) L contenant des données numériques, on
peut tracer son histogramme avec la commande plt.hist(L). Cette commande trie
les données en différentes classes et, pour chaque classe, elle représente un bâton dont
la hauteur est le nombre de données dans cette classe. On peut préciser le nombre de
classes voulues en ajoutant l’option bins (mais les options des histogrammes ne sont
Nous verrons un exemple pas exigibles).
dans le cours de TP no 10. Exemple : Considérons une épreuve passée par 1367
On peut également renor-
maliser un histogramme élèves. Les notes vont de 0 à 20 (et ne sont pas né-
en lui ajoutant l’option cessairement des entiers) et on les a rangées dans un 150

density=True de telle sorte tableau Python appelé NOTES. Pour bien visualiser
que l’aire qu’il occupe soit la répartition des notes, on peut construire un histo- 100

égale à 1. C’est particulière- gramme avec 20 classes (il y aura donc 20 classes : les
ment pratique pour lui super- notes dans [0 ; 1[, celles dans [1 ; 2[, etc. celles dans 50

poser un diagramme à barres [18 ; 19[ et enfin celles dans [19 ; 20]).
0
de la loi d’une variable aléa-
1 p l t . h i s t (NOTES, b i n s =20) 0 5 10 15 20
toire ou une courbe de den- 2 p l t . show ( )
sité (cf. TP no 10 et cours
d’ECG2).
TP no 6 – Matrices et systèmes avec Python
Pour créer et manipuler des matrices, on commence par importer la bibliothèque numpy
avec la commande
import numpy as np
et la bibliothèque numpy.linalg avec la commande

import numpy.linalg as al

Cette dernière contient des commandes supplémentaires pour manipuler des matrices,
notamment l’inversion de matrices ou la résolution de systèmes linéaires.

1) Création d’une matrice

Il y a une différence Soient L1,L2,L3,...,Ln des listes ou des vecteurs lignes ayant le même nombre
entre np.array(L1) et de coordonnées. La commande np.array([L1,L2,L3,...,Ln]) renvoie une matrice
np.array([L1]). La (tableau bidimensionnel) dont les lignes sont, dans l’ordre, L1,L2,L3,...,Ln.
première crée un vecteur Par
 exemple np.array([[1,-1,0,2],[0,7,8,-5],[4,6,0,0]])
 implémente
(tableau unidimensionnel) 1 −1 0 2
et la deuxième créer une 0 7 8 −5.
matrice (tableau bidimen- 4 6 0 0
sionnel) ayant une seule
ligne.

17
 On peut créer ainsi des matrices « à la main » mais on peut aller plus vite pour des
matrices remarquables (surtout si il y a beaucoup de coordonnées) : soient n et p des
entiers strictement positifs implémentés en Python par n et p respectivement :
• np.zeros([n,p]) renvoie la matrice nulle à n lignes et p colonnes.
• np.ones([n,p]) renvoie la matrice à n lignes et p colonnes dont tous les coeffi-
cients sont des 1.
• np.eye(n) renvoie la matrice identité d’ordre n.

2) Extraction et modification
Soient A une matrice et i, j deux entiers naturels implémentés en Python par A, i et j.

Encore une fois Python nu- Avant toute chose, si on ne connaît pas la taille de la matrice A, on utilise la commande
mérote à partir de 0 et non a,b=np.shape(A) qui stocke dans a le nombre de lignes de A et dans b le nombre de
de 1. colonnes de A.
• A[i,j] renvoie le coefficient d’indice (i + 1, j + 1) de A. Ainsi, pour accéder au
coefficient d’indice (i, j) de A, la commande est A[i-1,j-1].
• A[i,:] renvoie la (i + 1)ième ligne de A. Ainsi, pour accéder à la iième ligne de A,
la commande est A[i-1,:].
• A[:,j] renvoie la (j + 1)ième colonne de A. Ainsi, pour accéder à la j ième colonne
de A, la commande est A[:,j-1].

Si on écrit B=A, alors B Ensuite on peut modifier des coefficients, des lignes et des colonnes en utilisant la syntaxe
contient la matrice A bien usuelle pour l’affectation dans une variable.
sûr. Mais toute modifica- Par exemple L[2]=5 remplace la 3ième coordonnée de L par 5, A[0,3]=-7 remplace
tion de la matrice A provo- le coefficient d’indice (1, 4) de A par −7. Si A a 4 colonnes, alors A[1,:]=np.ones(4)
quera la même modification met des 1 à tous les coefficients de la 2ième ligne de A.
sur la matrice que B implé-
mente (car c’est le même
objet en fait). Si on veut 3) Opérations matricielles
éviter cela, il faut remplacer
Soient A et B deux matrices, c un réel et n un entier naturel implémentés en Python
par B=A par B=np.copy(A)
par A, B, c et n.
ou B=A.copy() (mais ces
commandes ne sont pas exi- • Si A et B ont la même taille, alors A+B renvoie l’addition de A et B, A-B renvoie
gibles) : les modifications de la soustraction de A par B et c*B renvoie la multiplication de A par c.
la matrice A n’auront alors • np.dot(A,B) renvoie le produit matriciel de A par B, si celui-ci a un sens.
pas d’effet sur la matrice B. • np.transpose(A) renvoie la transposée de A.
La commande A*B ne ren- • al.inv(A) renvoie l’inverse de A, si elle est inversible.
voie PAS le produit matriciel • al.matrix_power(A,n) renvoie An , si A est carrée (si n est un entier négatif et
mais, si A et B ont la même que A est inversible, elle renvoie (A−1 )−n ).
taille, elle renvoie le produit • al.rank(A) renvoie le rang de A.
coefficient par coefficient.
• Si A est carrée d’ordre n et B une matrice colonne à n lignes (ou un vecteur
ou une liste à n coordonnées qui implémente le second membre), la commande
Le rang d’une matrice sera al.solve(A,B) renvoie la solution du système AX = B , s’il y en a une, et un
vu en détail dans le cha- message d’erreur sinon.
pitre 30. Pour faire simple,
il s’agit du nombre maximal 4) Opérations coefficient par coefficient
de colonnes de la matrice
Soient A et B deux matrices de même taille et n un entier naturel implémentés en
qui forment une famille libre.
Python par A, B, n.
Ou encore nombre maximal
de lignes de la matrice qui • On peut effectuer des opération coefficient par coefficient via les commandes
forment une famille libre. +,-,*,/,**. Par conséquent * n’est PAS le produit matriciel et ** n’est PAS le
passage à la puissance.

18
 Par exemple, A**3 renvoie la matrice A dont tous les coefficients ont été
élevés à la puissance 3, ce qui n’est PAS a priori la matrice A3 .
• On peut comparer A et B coefficient par coefficient ou comparer A coefficient
par coefficient avec un nombre en utilisant les commandes ==,>,<,>=,<=,!=. Le
résultat est une matrice de booléens.
Par exemple, si A=np.array([[1,-2,3],[0,-4,7]])
et B=np.array([[-2,7,3],[-1,0,4]]), alors
A<=B renvoie array([[False, True, True],
[False, True, False]])
et A>0 renvoie array([[ True, False, True], .
[False, False, True]])

TP no 7 – Résolution de manière approchée de

l’équation f (x) = 0
1) Méthode de dichotomie

Si on cherche c tel que Soient a et b deux réels tels que a < b et f une fonction continue sur [a ; b] telle que
f (x) = m, alors il suffit de 0 est compris entre f (a) et f (b). Le TVI nous garantit l’existence de c ∈ [a ; b] tel que
considérer ce qui suit avec f (c) = 0.
fe = f − m au lieu de f : L’algorithme de dichotomie vu dans la démonstration du TVI permet de construire deux
fe(c) = 0 si et seulement si suites (an )n∈N et (bn )n∈N adjacentes qui convergent vers un réel c de [a ; b] vérifiant
f (c) = m. f (c) = 0. Elle vérifient notamment an 6 c 6 bn pour tout n ∈ N. A ε > 0 fixé, il suffit
donc d’itérer l’algorithme jusqu’à ce que le rang n soit tel que bn − an 6 ε. On a aura
alors
On dit que an est une ap- 0 6 c − an 6 bn − an 6 ε et 0 6 bn − c 6 bn − an 6 ε,
proximation de c par défaut i.e. an et bn sont des approximations à ε près du point c recherché.
et bn une approximation de
c par excès. La fonction suivante prend en entrée f, a, b, ε (f étant une fonction continue sur [a ; b]
telle 0 est compris entre f (a) et f (b)) et renvoie une approximation d’un point en lequel
Elle renvoie l’approximation f s’annule à ε près.
donnée par bn mais on aurait
1 def dichotomie ( f , a , b , eps ) :
pu prendre celle donnée par 2 w h i l e b−a>e p s :
an à la place. 3 c=(a+b ) /2
4 i f f ( a ) ∗ f ( c ) <0:#S i f c h a n g e de s i g n e e n t r e a e t c
5 b=c#A l o r s f s ‘ a n n u l e e n t r e a e t c
6 else :
7 a=c#S i n o n f s ‘ a n n u l e e n t r e c e t b
8 return b

Si on veut construire un algo- Exemple : La fonction f : x 7−→ x2 − 2 est continue sur [1 ; 2] et f (1) < 0 < f (2).
rithme permettant de trou- Puisqu’elle est strictement croissante sur [1 ; 2], le corollaire
√ du TVI nous garantit même
ver une valeur approchée qu’elle s’annule un unique réel de [1 ; 2] (il s’agit de 2). Le script suivant
d’un point fixe de f (dont
1 def f ( x ) :
on a montré l’existence, 2 r e t u r n x ∗∗2−2
voire l’unicité, au préa- 3

lable), on remplace f par 4 dichotomie ( f ,1 ,2 ,0.0001)

g : x 7−→ f (x) − x dans
√
renvoie 1.41424560546875. Ainsi 1, 4142 est une approximation de 2 à
l’algorithme précédent. 10−4 près.
Remarque : Dans la pratique, inutile de faire un algorithme général. Pour l’exemple
précédent, on peut écrire immédiatement :

19
 1 def dichotomie ( eps ) :
2 a =1; b=2
3 w h i l e b−a>e p s :
4 c=(a+b ) /2
5 i f c ∗∗2 >2:
6 b=c
7 else :
8 a=c
9 return c

2) Méthode de point fixe

Supposons que résoudre f (x) = 0 soit équivalent à résoudre l’équation g(x) = x, pour
une certaine fonction g (il en existe forcément : par exemple g : x 7→ f (x) + x), et donc
équivalent à déterminer un point fixe de g. Soit (xn )n∈N la suite définie par x0 ∈ Dg
(bien choisi) et, pour tout n ∈ N, xn+1 = g(xn ). On sait que, si (xn )n∈N converge vers
un réel ` et si g est continue au voisinage en `, alors ` est un point fixe de g.
Pour que la suite (xn )n∈N converge, il faut bien choisir la fonction g. Nous avons vu dans
le chapitre Dérivation que c’est le cas si g est définie sur un intervalle fermé I vérifiant :
• g(I) ⊂ I,
• g est dérivable sur I,
• g 0 est bornée par un réel M ∈ ]0 ; 1[ sur I,
• g admet un point fixe x sur I.
On a même mieux sous les hypothèses précédentes :
∀n ∈ N, |xn − x| 6 M n |x0 − x|.

On fait cette majoration On prend x0 suffisamment proche de x afin que |u0 − x| 6 1 par exemple. On se donne
préalable de |x0 −x| car il ne ε > 0. On a
faut surtout pas que n0 dé- ln(ε)
Mn 6 ε ⇐⇒ n ln(M ) 6 ln(ε) ⇐⇒ n> .
pende de x. En effet, on ne ln(M )
connaît pas x et le but est de  
ln(ε)
l’approcher. On ne va donc Par conséquent, si n0 = + 1, alors
ln(M )
pas utiliser x pour trouver
x... |xn0 − x| 6 M n0 |x0 − x| 6 ε × 1 = ε.
La fonction suivante prend en entrée g, M, x0 , ε et renvoie une approximation de x à ε
près.
1 i m p o r t numpy a s np
2 d e f M e t h o d e P o i n t F i x e ( g ,M, x0 , e p s ) :
3 x=x0
4 n=i n t ( np . l o g ( e p s ) / np . l o g (M) )+1
5 f o r k in range (n) :
6 x=g ( x )
7 return x

En général, cet algorithme permet de trouver une approximation de la solution à une

précision donnée, plus rapidement que l’algorithme de dichotomie. Cependant il est
Si f est de classe C 2 (deux
difficile de savoir quelle fonction g choisir de telle sorte qu’elle remplisse les hypothèses
fois dérivable et la dérivée se-
ci-dessus. Alors que la méthode de dichotomie fonctionne à tous les coups !
conde est continue), on peut x 1
Exemple : On vérifie aisément que g : x 7−→ + est dérivable sur [1 ; 2] et que
néanmoins toujours trouver √ 2 x
une fonction g qui convient
g([1 ; 2]) ⊂ [1 ; 2]. De plus elle 2 pour unique point fixe sur [1 ; 2]. Pour tout x ∈ [1 ; 2],
1 1 1 1 1 1
grâce à la méthode de New- on a g 0 (x) = − 2 . Comme 6 2 6 1, on obtient − 6 g 0 (x) 6 . Ainsi g 0 est
2 x 4 x 2 4
ton (cf. poly d’exercices d’in- 1
formatique).
bornée par M = sur [1 ; 2]. Ainsi la fonction suivante prend en argument ε et renvoie
2 √
une approximation de 2 à ε près :

20
 1 d e f PointFixeSQRT2 ( e p s ) :
2 x=1
3 n=i n t ( np . l o g ( e p s ) / np . l o g ( 1 / 2 ) )+1
4 f o r k in range (n) :
5 x=x /2+1/ x
6 return x

La commande PointFixeSQRT2(0.0001)renvoie 1.414213562373095.

TP no 8 – Calcul approché d’intégrales

La méthode des rectangles Soit f une fonction continue sur [a ; b]. Supposons que a, b, n, f ont été implémentées
est la méthode algorith- en Python dans les variables a,b,n,f. D’après le théorème de convergence des sommes
Z b
mique consistant à appro- de Riemann, le script ci-dessous calcule une valeur approchée de f (t) dt (en utilisant
cher la valeur d’une inté- a
grale (aire sous la courbe)
la méthode des rectangles à droite) et la stocke dans la variable S.
par des sommes de Rie- 1 S=0
mann (somme d’aires de rec- 2 f o r k i n r a n g e ( 1 , n+1) :
tangles). 3 S=S+f ( a+k ∗ ( b−a ) /n )
4
5 S=S ∗ ( b−a ) /n

ou plus simplement
1 S=np . sum ( [ f ( a+k ∗ ( b−a ) /n ) f o r k i n r a n g e ( 1 , n+1) ] ) ∗ ( b−a ) /n

Mais quelle valeur de n doit-on prendre pour avoir une valeur approchée à une précision
donnée ?

1) Le cas où f est monotone

Supposons que f est croissante sur [a ; b]. Notons (Sn (f ))n>1 et (Tn (f ))n>1 les suites
des sommes de Riemann de f à droite et à gauche respectivement.
 
∗ k−1 k
Soit n ∈ N . Pour tous k ∈ J1 ; nK et t ∈ ; , on a
n n
   
(k − 1)(b − a) k(b − a)
f a+ 6 f (a + t(b − a)) 6 f a +
n n

donc, par croissance de l’intégrale,

  k−1  
(k − 1)(b − a) k(b − a)
Z
1 n 1
f a+ 6 f (a + t(b − a)) dt 6 f a+ .
n n k n n
n

On somme et on utilise la relation de Chasles :

Z 1
∀k ∈ J0 ; n − 1K, Tn (f ) 6 (b − a) f (a + t(b − a)) dt 6 Sn (f ).
0
x−a
Le changement de variable affine (donc de classe C 1 ) t = donne enfin :
b−a
Z b
Tn (f ) 6 f (x) dx 6 Sn (f ).
a

Pour obtenir une approximation de l’intégrale à ε près (avec ε > 0), il suffit donc que n
soit tel que Sn (f ) − Tn (f ) 6 ε. Or on remarque que
n     
b−aX b−a b−a
Sn (f ) − Tn (f ) = f a+k − f a + (k − 1) .
n n n
k=1

21
 b−a
On reconnait une somme télescopique : Sn (f ) − Tn (f ) = (f (b) − f (a)). Ainsi
n
(b − a)(f (b) − f (a))
Sn (f ) − Tn (f ) 6 ε ⇐⇒ n> .
ε
 
(b − a)(f (b) − f (a))
On choisit n = + 1 et alors Sn (f ) et Tn (f ) sont des approxi-
ε
Z b
mations de f (t) dt à ε-près respectivement par excès et par défaut.
a
 
(b − a)(f (a)−f (b))
On remplace f par −f dans Dans le cas où f est décroissante sur [a ; b], on choisit n = +1
ε
la preuve ci-dessus. Z b
et alors Sn (f ) et Tn (f ) sont des approximations de f (t) dt à ε-près respectivement
a
par défaut et par excès.
4
Exemple : La fonction f : t 7−→ est continue et décroissante sur [0 ; 1]. On a
Z 1 1 + t2
f (t) dt = [4 Arctan(t)]10 = π. Ainsi, pour tout ε > 0, si on prend
0
   
(1 − 0)(f (0) − f (1)) 2
n= +1= + 1,
ε ε

alors Sn (f ) et Tn (f ) sont des approximations de π à ε-près respectivement par excès et

par défaut. La fonction suivante prend ε en entrée et renvoie une liste contenant une
approximation de π par défaut et par excès à ε près.
1 def r e c t a n g l e ( eps ) :
2 def f ( t ) :
3 r e t u r n 4/(1+ t ∗ ∗ 2 )
4 n=i n t ( 2 / e p s )+1
5 S=0; T=0
6 f o r k i n r a n g e ( 1 , n+1) :
7 S=S+f ( k /n )
8 T=T+f ( ( k −1)/n )
9 r e t u r n [ S/n , T/n ]

2) Le cas où f est de classe C 1

Si f est de classe C 1 sur [a ; b], alors le théorème d’approximation par les sommes de
Riemann dans le cas C 1 nous assure que
b
(b − a)2
Z
Sn (f ) − f (x) dx 6 max |f 0 |.
a 2n [a ;b]

(b − a)2
 
0
Ainsi, pour tout ε > 0, il suffit de prendre n = max |f | + 1 pour que Sn (f )
Z b 2ε [a ;b]
soit une approximation de f (x) dx à ε près.
a
Exemple :
Reprenons l’exemple du paragraphe précédent. La fonction
4
f : t 7−→ est de classe C 1 sur R. Une étude de fonction montre que
1 + t2 √
0 −8t √ 3 3
L’algorithme est√donc plus f : t 7−→ est borné par |f (1/ 3)| = . Ainsi, on prend
(1 + t2 )2 2
3 3
rapide puisque 6 2. √   √ 
4
(1 − 0)2 3 3

3 3
n= +1= + 1.
2ε 2 4ε

22
 TP no 9 – Probabilités avec Python – Deuxième partie
1) Diagrammes à barres d’une variable aléatoire discrète infinie
Dans la partie V, nous avons vu comment tracer le diagramme à barres d’une variable
aléatoire finie. Si X est une variable aléatoire discrète infinie,
X il est bien sûr plus possible
de représenter toutes les barres mais, puisque la série P(X = n) converge, on a
P(X = n) −−−−−→ 0. Il suffit de ne tracer que les barres correspondant à des probabilités
n→+∞
qui ne sont pas « trop petites » (celles qui sont supérieures à ε = 10−3 par exemple).
Exemple :
• Soient p ∈ ]0 ; 1[ et X ,→ G(p), pour tout n ∈ N∗ , P(X > n) = (1 − p)n .
Donc,dans le diagramme,
 on peut se limiter aux n0 ième première barres avec
ln(ε)
De telle sorte que n0 = + 1.
ln(1 − p)
(1 − p)n0 6 ε
• Soient λ > 0 et X ,→ P(λ). Il est difficile de trouver mathématiquement le plus
petit entier ma tel que P(X = ma ) 6 ε. Mais ce n’est pas un problème : dans
l’algorithme, au lieu de construire la liste des probabilités des valeurs entre 0 et
ma , on construit la liste des probabilités jusqu’à ce qu’on rencontre une valeur
inférieur à ε.

Nous construirons les diagrammes à barres pour des variables aléatoires suivant ces deux
lois en TP.

2) Tracé de fonctions de répartition

a) Le cas des variables finies
La fonction de répartition d’une variable aléatoire réelle finie X est une fonction en
escalier qui ne prend qu’un nombre fini de valeurs. Il suffit de connaître les probabilités
P(X = x) pour chaque x ∈ X(Ω) pour la construire.
Soyons plus précis : supposons que X(Ω) = {x1 , . . . , xn } avec x1 < x2 < · · · < xn .
• FX est nulle sur ]−∞ ; x1 [. i
X
• Pour tout i ∈ J1 ; n − 1K, Fx est constante égale à P(X = xk ) sur [xi ; xi+1 [.
k=1
• FX est constante égale à 1 sur [xn ; +∞[.
Supposons que l’on ait construit une liste ou un vecteur X contenant x1 , . . . , xn et une
liste ou un vecteur L en Python qui contient P(X = x1 ), P(X = x2 ), . . . , P(X = xn ).
• On en déduit un vecteur content FX (x1 ), FX (x2 ), . . . , FX (xn ) via la commande
np.cumsum(L). Mais on peut aussi le construire « à la main » :
1 F=np . z e r o s ( n )
2 F[0]=L [ 0 ]
3 f o r k in range (1 , n) :
4 F [ k ]=F [ k−1]+L [ k ]

plt.step ne figure pas dans • On utilise ensuite la commande plt.step(X,F,where=’post’) qui trace une
le programme... courbe en escalier à partir des valeurs de X et F. La fonction de répartition est
tracée !

Exemple : Dans la partie 5 du TP no 5, nous avons tracé le diagramme en bâton de

la variable aléatoire comptant la somme de deux dés équilibrés à six faces. Traçons sa
fonction de répartition :

23
 1
Les lignes verticales au ni-
veau des sauts sont dues au 1 import m a t p l o t l i b . pyplot as p l t 0.8
2 i m p o r t numpy a s np
fonctionnement de la fonc-
3 X=r a n g e ( 2 , 1 3 ) 0.6
tion plt.plot. 4 L=[1 ,2 ,3 ,4 ,5 ,6 ,5 ,4 ,3 ,2 ,1] 0.4
5 F=np . cumsum ( L ) /36
6 p l t . s t e p (X , F , where= ’ p o s t ’ ) 0.2
7 p l t . show ( )
0
2 4 6 8 10 12

Remarque : On peut aussi construire la fonction de répartition « à la main » directement

à partir des listes X et L (définies ci-dessus) puis la tracer avec plt.plot :
1 d e f FoncRep (X , L , t ) :
2 i f t<X [ 0 ] :
3 return 0
4 e l i f t>=X[ − 1 ] :
5 return 1
6 else :
7 i =1
8 w h i l e t>=X [ i ] :#Quand c e t t e b o u c l e s ’ a r r ê t e , i e s t t e l
que X [ i −1]<=t<X [ i ]
9 i=i +1
10 F=0
11 f o r k i n r a n g e ( i ) :#On somme l e s p r o b a s
12 F=F+L [ k ]
13 return F
14
15 T=np . l i n s p a c e (X[ 0 ] − 1 ,X[ −1]+1 ,1000)
16 TT=[ FoncRep (X , L , t ) f o r t i n T ]
17 p l t . p l o t (T , TT)
18 p l t . show ( )

Si on est gêné par le fait que les sauts soient reliés par des lignes verticales, on peut
implémenter directement le tracé de la fonction de répartition qui n’est rien d’autre
qu’une succession de tracés de droites horizontales :
1 d e f T r a c e F r e p (X , L ) :
2 n=l e n (X)
3 y=0
4 p l t . p l o t ( [ X[ 0 ] − 1 ,X [ 0 ] ] , [ 0 , 0 ] , ’ b ’ )#E l l e e s t n u l l e a v a n t l e
premier saut
5 f o r k i n r a n g e ( n−1) :
6 y=y+L [ k ]#On somme l e s p r o b a s
7 p l t . pl ot ( [X[ k ] ,X[ k +1]] ,[ y , y ] , ’b ’ )
8 p l t . p l o t ( [ X[ − 1 ] ,X [ − 1 ] + 1 ] , [ 1 , 1 ] , ’ b ’ )#Pour qu ’ e l l e " c o n t i n u e "
un peu a p r è s l e d e r n i e r s a u t
9 p l t . show ( )
10
11 T r a c e F r e p (X , L )

b) Le cas des variables discrètes infinies

Nous verrons des exemples On se limite dans ce paragraphe au cas d’une variable aléatoire discrète infinie X telle que
en TP. X(Ω) ⊂ N. Comme pour les diagrammes à barres (cf. paragraphe 1), on se limite au tracé
de la fonction de répartition sur l’intervalle ]0 ; n0 [ avec n0 ∈ N tel que P(X > n0 ) 6 ε
(avec par exemple ε = 10−3 ).

24
 3) Simulation d’une variable aléatoire de loi discrète usuelle
a) Loi géométrique
Pour une implémentation en Python, on commence par :
1 i m p o r t numpy . random a s r d

La deuxième possibilité, bien Supposons que p ∈ ]0 ; 1[ a été implémenté en Python dans la variable p. Pour obtenir
que plus compliquée au une réalisation d’une variable aléatoires de loi de G(p), on peut utiliser la fonction :
premier abord, est préfé-
1 X=r d . g e o m e t r i c ( p )
rable car on peut facile-
ment l’adapter si on s’in- Une autre possibilité est d’utiliser la commande U=rd.random() qui renvoie un réel
téresse au premier succès choisi uniformément entre 0 et 1. La commande U<=p renvoie True avec fréquence p et
lors de la répétition d’expé- False avec fréquence 1 − p. Tant qu’on obtient False (c’est-à-dire U>p), on fait appel
riences non indépendantes à cette commande et on compte le nombre d’occurrences avant d’avoir True. Ainsi :
ou non identiques. On verra
1 X=0
des exemples en TP. 2 w h i l e r d . random ( )>p :
3 X=X+1
4 X=X+1

On ajoute 1 pour compter contient une réalisation d’une variable aléatoire de loi G(p).
l’ultime expérience condui-
sant au succès. b) Loi de Poisson
Pour une implémentation en Python, on commence par :
1 i m p o r t numpy . random a s r d

Supposons que λ > 0 a été implémenté en Python dans la variable lam. Pour obtenir
une réalisation d’une variable aléatoire de loi de P(λ), on peut utiliser la fonction :
1 X=r d . p o i s s o n ( lam )

Dans le prochain TP, On a aussi vu en cours que l’on peut approcher une loi Binomiale par une loi de Poisson.
nous superposerons un Comme lois binomiales sont faciles à simuler avec un ordinateur. Cela nous permet donc
histogramme construit à de simuler (de façon approchée) une loi de Poisson avec Python. Le code ci-dessous simule
partir d’un grand nombre une réalisation d’une variable aléatoire qui suit approximativement une loi P(lambda).
de réalisation d’une variable 1 n =10000 , p=lambda /n
aléatoire de loi B(n, λ/n) 2 X=0
(avec n grand) avec le 3 f o r k in range (n) :
4 i f r d . random ( )<p :
diagramme à barre d’une
5 X=X+1
loi P(λ) pour illustrer cette
approximation.
4) Vecteurs et matrices de variables de lois discrètes usuelles
On peut bien sûr utiliser des boucles for pour construire des listes contenant des variables
aléatoires de lois usuelles en utilisant les commandes du paragraphe précédent. Pour les
commandes rd.geometric et rd.poisson, on peut plus simplement :
• rajouter pour paramètre m à l’une de ces commandes, alors on obtient un vecteur
contenant m réalisations de variables aléatoires de la loi (que l’on peut considérer
indépendantes).
• rajouter pour paramètre [n,m] à l’une de ces commandes, alors on obtient une
matrice de taille n × m contenant des réalisations de variables aléatoires de la loi
(que l’on peut considérer indépendantes).

Exemples :
• rd.geometric(0.2,8) renvoie array([10, 8, 1, 3, 3, 6, 11, 7]).

25
 • rd.poisson(7,[4,6]) renvoie array([[4,10, 7, 6, 4, 5], .
[5, 5, 9, 6, 8, 4],
[6, 8,10, 6, 9, 8],
[5,10, 9, 2, 7, 4]])

TP no 10 – Probabilités avec Python – Troisième partie

1) Statistiques descriptives
Soit A une liste, un vecteur ou une matrice de réels en Python.
• np.sum(A) renvoie la somme des coordonnées de A.
• np.prod(A) renvoie le produit des coordonnées de A.
• np.cumsum(A) renvoie le vecteur des sommes cumulées des coordonnées de A.
Par exemple np.cumsum([1,4,2,7]) renvoie array([1,5,7,14]).
• np.mean(A),np.var(A),np.std(A),np.median(A), renvoient respectivement
la moyenne, la variance, l’écart type et la médiane des coordonnées de A.
• np.min(A),np.max(A) renvoient respectivement la plus petite et la plus grande
des coordonnées de A.
Ces opérations peuvent s’appliquer sur une matrice entière ou bien pour chaque colonne
(en ajoutant l’option 0) ou chaque ligne (en ajoutant l’option 1).

2) Statistiques d’échantillon et loi

Considérons des données réelles associées à une expérience aléatoire (par exemple des
réalisations d’une variable aléatoire). On peut ranger ces données dans un tableau dont
la première ligne dresse la liste des différentes valeurs prises par les données dans l’ordre
croissant et la deuxième ligne contient leurs effectifs respectifs (i.e. le nombre de fois
qu’on retrouve chaque valeur parmi les données). En divisant chaque effectif par le nombre
de données, on obtient leurs fréquences. Enfin on ajoute souvent une ligne correspondant
aux fréquences cumulées.
La loi faible des grands nombres garantit que si les données sont des réalisations indé-
En effet la moyenne empi- pendantes d’une variable aléatoire discrète X admettant une variance, alors la moyenne
rique des carrés des don- empirique des données est une approximation de E(X). On en déduit que, si X admet
nées approche E(X 2 ) et on une variance, alors la variance empirique des données est une approximation de V(X).
conclut avec la formule de On a vu dans la paragraphe IV.2 que, si A est un événement associé à une expérience et
Koenig-Huygens. que, l’on réalise un grand nombre de fois cette expérience de façon indépendante, alors
la proportion (ou fréquence) d’expériences ayant conduit à la réalisation de A (on voit la
réalisation de A comme le succès de l’expérience de Bernoulli consistant à observer ou ne
pas observer la réalisation de A) est une approximation de P(A). C’est une conséquence
de la loi faible des grands nombres. Ainsi :
• Pour tout x ∈ X(Ω), la fréquence des données valant x approche P(X = x).
Ici A = [X = x]. Autrement dit le tableau des fréquences approche la loi de X.
• Pour tout x ∈ X(Ω), la fréquence des données inférieures à x approche
Ici A = [X 6 x]. P(X 6 x). Autrement dit le tableau des fréquences cumulées approche la fonction
de répartition de X.

Voyons cela à travers un exemple : illustrons le fait que, si λ > 0 alors B(n, λ/n) est une
approximation de la loi P(λ) lorsque n est grand (cf. paragraphe précédent).
• Prenons n = 1000 et λ = 5 puis construisons un vecteur contenant N = 10000
réalisations de X ,→ B(n, λ/n) :
1 n =1000; lam =5; N=10000; X=r d . b i n o m i a l ( n , lam /n , N)

26
La convergence de la • Créons le vecteur des fréquences d’apparition des entiers de 0 à n dans les données
loi faible des grands (mais on peut se limiter au maximum m des données au lieu de n). Pour cela on
nombres est très lente crée un vecteur nul à m + 1 coordonnées, on parcourt les données une à une et on
en pratique (d’où le incrémente de 1 la coordonnée qui lui correspond. Enfin on divise par N :
N = 10000) tandis que 1 m=np . max (X) ; E f f=np . z e r o s (m+1)
l’approximation Binomia- 2 for x in X:
le/Poisson est très rapide 3 E f f [ i n t ( x ) ]= E f f [ i n t ( x ) ]+1
4 F r e q=E f f /N
(on l’utilise dès que n > 30
dans la pratique).
• Maintenant créons un vecteur contenant les valeurs de P(Z = k) pour k ∈ J0 ; mK
On utilise le fait que, pour et Z ,→ P(λ) :
tout k ∈ N,
1 L o i=np . z e r o s (m+1) ; L o i [ 0 ] = np . exp (−lam )
P(Z = k + 1)
=
λ
. 2 f o r k i n r a n g e (m) :
P(Z = k) k+1 3 L o i [ k+1]= L o i [ k ] ∗ lam / ( k+1)

Le 0.4 fait en sorte que • Enfin on superpose le diagramme en bâtons des fréquences avec celui de la loi :
les barres du deuxième dia-
1 plt . b a r ( r a n g e (m+1) , Freq , l a b e l= ’ f r e q u e n c e s e m p i r i q u e s ’ )
gramme soient plus fines. 2 plt . b a r ( r a n g e (m+1) , L o i , 0 . 4 , l a b e l= ’ l o i de P o i s s o n ’ )
3 plt . legend ()
4 plt . show ( )

• A l’aide de la commande np.cumsum, qui permet de former le vecteur des sommes

cumulées d’un vecteur, on peut superposer de même la courbe (en escalier) des
La commande plt.step fréquences cumulées et fonction de répartition de Z :
n’est pas au programme 1 FreqCum=np . cumsum ( F r e q ) ; FonctRep=np . cumsum ( L o i )
(mais elle serait rappelée) : 2 p l t . s t e p ( r a n g e (m+1) , FreqCum , ’ r ’ , l a b e l= ’ f r e q u e n c e s cumul é e s ’ ,
elle permet de tracer des where= ’ p o s t ’ , )
3 p l t . s t e p ( r a n g e (m+1) , FonctRep , ’ k : ’ , l a b e l= ’ l o i de P o i s s o n ’ , where=
fonctions en escalier.
’ post ’ )
4 plt . legend ()
5 p l t . show ( )

Voici les deux graphiques que l’on obtient (à gauche celui des fréquences et à droite des
fréquences cumulées). On constate bien qu’ils se superposent.

frequences empiriques 1
frequences cumulées
0.15 loi de Poisson loi de Poisson
0.8

0.6
0.1

0.4

5 · 10−2
0.2

0
0
0 2 4 6 8 10 12 14 0 2 4 6 8 10 12 14
Pour tracer l’histogramme des fréquences empiriques, on aurait aussi pu utiliser directe-
L’option density=True sert ment plt.hist avec des options :
à ce que l’histogramme soit
1 p l t . h i s t (X , r a n g e (m+1) , d e n s i t y=True , a l i g n= ’ l e f t ’ , r w i d t h =0.7)
celui des effectifs. L’option
align=’left’ sert à ce les
barres soient centrées sur
la valeur (oui le left n’est
pas intuitif. Enfin l’option
rwidth = 0.7 sert à ré-
27
duire la largeur des barres.
 3) Approche expérimentale de la loi de Gauss
Soit p ∈ ]0 ; 1[. Pour tout n ∈ N∗ , considérons une variable aléatoire Xn de loi B(n, p).
Un des théorèmes les plus importants de probabilités (qui sera vu en deuxième année)
est le Théorème Central Limite. Un cas particulier est que, pour tous réels a et b tels
que a < b, ! Z b
Xn − np 1 2
Le théorème Central Limite P a6 p 6 b −−−−−→ √ e−x /2 dx.
np(1 − p) n→+∞ a 2π
est même l’un des plus im-
portants des mathématiques
Interprétation graphique : quand n est grand, la courbe représentative de la fonction
tout court ! 1 Xn − np
2
ϕ : x 7−→ √ e−x /2 se superpose à l’histogramme d’observations de p .
2π np(1 − p)

L’option bins=20 permet 1 n =10000; p =0.3

d’avoir 20 classes dans 2 N=10000 # t a i l l e d e s o b s e r v a t i o n s
3 X=r d . b i n o m i a l ( n , p , N)
l’histogramme. L’option
4 Y=(X−n∗p ) / np . s q r t ( n∗p∗(1−p ) )
density=True permet de 5 p l t . h i s t (Y , b i n s =20 , d e n s i t y=True , l a b e l=" h i s t o g r a m m e " )
normaliser l’histogramme 6 a=min (Y) ; b=max (Y) ; T=np . l i n s p a c e ( a , b , 1 0 0 0 ) ;
pour que son aire soit égale 7 U=[ np . exp (− t ∗ ∗ 2 / 2 ) / np . s q r t ( 2 ∗ np . p i ) f o r t i n T ]
8 p l t . p l o t (T , U , l a b e l=" y=p h i ( x ) " )
à 1.
9 plt . legend ()
10 p l t . show ( )

0.40 histogramme
y=phi(x)
0.35
0.30
0.25
0.20
0.15
0.10
0.05
0.00
−4 −2 0 2 4

28