Lycée Carnot – H2B Matthias Gorny

Algorithmique et informatique avec Python :

le cours de première année... pour les élèves de deuxième année

I 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 partie V).
• Les fonctions (type function, paragraphe 5 et partie II).

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. partie II).
Mais avant cela il faut im- • Python nous permet d’accéder à des approximations de π et de e = exp(1) via les
porter la bibliothèque numpy commandes [Link] et np.e respectivement.
en utilisant la commande
import numpy as np (on b) Opérations sur les booléens
en reparlera).
Les booléens sont très utiles puisqu’ils apparaissent dans les conditions des structures
conditionnelles et des boucles while (cf. partie II).
Ne pas confondre == qui • En général les booléens sont créés en faisant des comparaisons entre réels (ou entre
teste l’égalité et = qui sert vecteurs, entre matrices, cf. paragraphe 4). Si x et y sont des réels implémentés
à l’affectation dans une va- en Python par x et y, alors x==y,x<y,x<=y,x>y,x>=y,x!=y renvoient True si x
riable. est respectivement égal à y, strictement inférieur à y, inférieur à y, strictement
supérieur à y, supérieur à y et différent de y. Elles renvoient False sinon.
• 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 [Link](a).
pop et len ne sont pas ex- La commande [Link](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 [Link](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 la
type. partie VI.
• Pour importer la bibliothèque numpy, on utilise la commande

import numpy as np

L et [Link](L) sont de • Si L est une liste de nombres, alors [Link](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 :
— [Link](n) renvoie un vecteur avec n coordonnées toutes nulles.
— [Link](n) renvoie un vecteur avec n coordonnées valant toutes 1.
— [Link](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 [Link](3,4,6) renvoie
array([3.,3.2,3.4,3.6,3.8,4.])

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

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 [Link], [Link], [Link], [Link], [Link],
La commande int(a) ne [Link] et [Link].
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
non entier, contrairement à
Ces fonctions peuvent s’appliquer à des variables numériques ou vectoriellement (à des
[Link](a).
vecteurs réels) coordonnée par coordonnée.
Par exemple [Link](np.e) renvoie 1.0.
La commande [Link]([0,[Link],[Link]/2]) renvoie array([0.0,0.0,1.0]).

Remarques :
• Si x ∈ Dtan est implémenté en Python par x, alors [Link](x)/[Link](x) renvoie
On peut aussi utiliser (une approximation de) tan(x).
[Link](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 [Link](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. partie
VII) ou un algorithme de dichotomie (cf. partie VI).

4
 II 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 ».

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([Link],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=[Link](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

5
 <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
Vous aurez compris que n’est remplie, voici la syntaxe :
elif est une contraction de
1 i f <c o n d i t i o n 1 >:
else if. 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>:
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.

6
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. L’une des fonctionnalités les plus intéressantes de Python est la possibilité de définir des
listes « par compréhension » : si f est une fonction et T une liste ou un tableau, alors la
Les boucles for servent prin- commande [f(x) for x in T] construit la liste des images des éléments de T par la
cipalement à calculer des fonction f. On a vu un exemple dans le paragraphe précédent.
sommes, produits ou les
termes successifs d’une suite. b) Boucles while
C’est l’objet de la prochaine
On emploie les boucles while lorsqu’on veut exécuter un bloc d’instructions tant qu’une
partie.
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
Tant que la condition <condition> est remplie, le bloc d’instructions
contrairement à l’indice
<bloc d’instructions> sera exécuté. Il est donc essentiel que l’exécution
dans une boucle for.
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
de n. 1 d e f rang_min (A) :
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 la partie III consacré 47 et la commande rang_min(1000000) renvoie 100.
aux sommes.

III 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).

7
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 ]

— 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 ) ] )

8
 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

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.
que, à chaque étape, on
y+1 n+1
transforme u en le terme sui- On suppose que l’on a implémenté F au préalable en Python.
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

9
 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

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
boucle, on ajoute le nouveau • Si on désire multiplier les termes d’une suite, on remplace juste s=s+u par s=s*u
terme aux précédents. ou s*=u

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) :

10
 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

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 n=n+1
ln(n) n→+∞ 5
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.

IV Représentations graphiques
Pour faire des représentations graphiques, on commence par importer la bibliothèque
[Link] avec la commande
import [Link] 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
A1 (x1 , y1 ), A2 (x2 , y2 ), . . . , An (xn , yn ). On implémente ces points en Python en mettant
x1 , . . . , xn dans une liste ou un vecteur X et y1 , . . . , yn dans une liste ou un vecteur Y.
Alors
• [Link](X,Y) relie les points A1 , A2 , . . . , An (dans cet ordre).
• [Link]() affiche la représentation graphique. Cette commande doit être mise à
la toute fin (après avoir appelé différents [Link] et ajouté d’éventuelles options).

11
On peut aussi tracer des Exemple :
fonctions en escalier avec 4
[Link]() mais cette
commande n’est pas offi- 1 import m a t p l o t l i b . pyplot as p l t 2
ciellement au programme. 2 X=r a n g e ( −4 ,8)
Toutefois on l’utilisera dans 3 Y= [ 3 , 2 , − 1 , 4 , 3 , 4 , 2 , 2 , 0 , 2 , − 2 , 0 ]
la partie VII pour tracer des 4 p l t . p l o t (X , Y) 0
fonctions de répartitions. 5 p l t . show ( )
Avec les points de l’exemple
−2
ci-contre cela donnerait −4 −2 0 2 4 6

2) Options de tracé
2

Les commandes de ce paragraphe ne sont pas au programme. Il est inutile le jour des
0

concours de mettre de la couleur à des courbes, des légendes, etc. Mais en TP, on les
−2 utilise ne serait-ce que pour différencier les tracés lorsqu’on en superpose.
−4 −2 0 2 4 6

• 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 [Link] :
— 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 [Link](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 [Link] qui trace
la courbe, où ’Légende_courbe’ est une chaîne de caractères contenant la lé-
gende. Ensuite on place la commande [Link]().
• Pour afficher un titre à une fenêtre graphique, on ajoute la commande
[Link](’Titre_graphique’) où ’Titre_graphique’ est une chaîne de
caractères contenant le titre.
• Si on fait appelle plusieurs fois à la commande [Link], les courbes successives
seront tracées dans la même fenêtre. Si on veut changer de fenêtre, on utilise
la commande [Link](). Dorénavant les tracés se feront dans une nouvelle
fenêtre (la même tant qu’on ne fait pas appel de nouveau à [Link]()).

Exemple :
Un exemple de tracé personnalisé

courbe1
1 X=r a n g e ( −4 ,8) 6 courbe2
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 ’ , 4
l a b e l= ’ c o u r b e 1 ’ )
4 p l t . p l o t (Y , X , ’ g :+ ’ , 2
l a b e l= ’ c o u r b e 2 ’ )
5 plt . legend () 0
6 p l t . t i t l e ( ’ Un e x e m p l e de t r a c é
personnalis é ’) −2
7 p l t . show ( )
−4
−4 −2 0 2 4 6

12
 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 :
X contient donc un tableau • On « discrétise » l’intervalle [a ; b] en un grands nombre de points régulière-
contenant n nombres régu- ment espacés (disons n avec, en général, n=1000 ou 10000) via la commande
lièrement espacés entre les X=[Link](a,b,n). Il s’agit du vecteur des abscisses.
réels a et b. • On crée le vecteur des ordonnées qui contient les images de tous les points du
vecteur X par la fonction f via la commande Y=[f(x) for x in X].
• Enfin, on trace la courbe via la commande [Link](X,Y) puis on l’affiche avec
[Link]()
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 [Link]([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 [Link]([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 ( )

13
 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;
a montré). 0.6
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

On conjecture que la suite • Représentons les 16 premières valeurs de la suite (un )n∈N telle que u0 = 1 et
converge vers 2. Pour aider 2
à la lecture, on a superposé ∀n ∈ N, un+1 = 1 + .
un
la droite d’ordonnée 2.
3
1 n =16; u =1;
2 L=np . z e r o s ( n+1) ; L [ 0 ] = u 2.5
3 f o r k in range (n) :
4 u=1+2/u 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. Le script ci-dessous
k!
k=0
crée une fonction qui prend 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 [Link]() par [Link]().
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

14
 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 y reviendrons dans la partie VII.

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 [Link](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
pas exigibles).

On peut également renor- Exemple : Considérons une épreuve passée par 1367
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 de deuxième an-
née).
V 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 [Link] avec la commande

import [Link] 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 [Link](L1) et de coordonnées. La commande [Link]([L1,L2,L3,...,Ln]) renvoie une matrice
[Link]([L1]). La (tableau bidimensionnel) dont les lignes sont, dans l’ordre, L1,L2,L3,...,Ln.
première crée un vecteur Par
 exemple [Link]([[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 On peut créer ainsi des matrices « à la main » mais on peut aller plus vite pour des matrices
ligne. 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. La commande

15
 • [Link]([n,p]) renvoie la matrice nulle à n lignes et p colonnes.
• [Link]([n,p]) renvoie la matrice à n lignes et p colonnes dont tous les coeffi-
cients sont des 1.
• [Link](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=[Link](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].
Si on écrit B=A, alors B • A[i,:] renvoie la (i + 1)ième ligne de A. Ainsi, pour accéder à la iième ligne de A,
contient la matrice A bien la commande est A[i-1,:].
sûr. Mais toute modifica- • A[:,j] renvoie la (j + 1)ième colonne de A. Ainsi, pour accéder à la j ième colonne
tion de la matrice A provo- de A, la commande est A[:,j-1].
quera la même modification
Ensuite on peut modifier des coefficients, des lignes et des colonnes en utilisant la syntaxe
sur la matrice que B implé-
usuelle pour l’affectation dans une variable.
mente (car c’est le même
objet en fait). Si on veut
Par exemple L[2]=5 remplace la 3ième coordonnée de L par 5, A[0,3]=-7 remplace
éviter cela, il faut remplacer
le coefficient d’indice (1, 4) de A par −7. Si A a 4 colonnes, alors A[1,:]=[Link](4)
par B=A par B=[Link](A)
met des 1 à tous les coefficients de la 2ième ligne de A.
ou B=[Link]() (mais ces
commandes ne sont pas exi- 3) Opérations matricielles
gibles) : les modifications de
Soient A et B deux matrices, c un réel et n un entier naturel implémentés en Python
la matrice A n’auront alors
par A, B, c et n.
pas d’effet sur la matrice B.
• Si A et B ont la même taille, alors A+B renvoie l’addition de A et B, A-B renvoie
la soustraction de A par B et c*B renvoie la multiplication de A par c.
• [Link](A,B) renvoie le produit matriciel de A par B, si celui-ci a un sens.
• [Link](A) renvoie la transposée de A.
La commande A*B ne ren- • [Link](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 • [Link](A) renvoie le rang de A.
coefficient par coefficient.
• Si A est carrée d’ordre n et B une matrice colonne à n lignes, la commande
[Link](A,B) renvoie la solution du système AX = B, s’il y en a une, et un
Cela fonctione aussi si B est message d’erreur sinon.
un vecteur ou une liste à n
coordonnées qui implémente 4) Opérations coefficient par coefficient
le second membre
Soient A et B deux matrices de même taille et n un entier naturel implémentés en
Python par A, B, n.
• On peut effectuer des opération coefficient par coefficient via les commandes
+,-,*,/,**. Par conséquent * n’est PAS le produit matriciel et ** n’est PAS le
passage à la puissance.
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.

16
 Par exemple, si A=[Link]([[1,-2,3],[0,-4,7]])
et B=[Link]([[-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]])

VI Analyse numérique
1) Résolution de manière approchée de l’équation f (x) = 0
a) 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
La fonction suivante prend en entrée f, a, b, ε (f étant une fonction continue sur [a ; b]
c par excès.
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 :
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

17
 b) 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. 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(ε)
pende de x. En effet, on ne Mn 6 ε ⇐⇒ n ln(M ) 6 ln(ε) ⇐⇒ n> .
ln(M )
connaît pas x et le but est de
 
l’approcher. On ne va donc ln(ε)
Par conséquent, si n0 = + 1, alors
pas utiliser x pour trouver ln(M )
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 :
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.

18
 2) 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 ?

a) 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

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

19
  
(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.
1
Exemple : La fonction f : t 7−→ est continue et décroissante sur [0 ; 1]. On a
Z 1 1+t
f (t) dt = [ln(1 + t)]10 = ln(2). Ainsi, pour tout ε > 0, si on prend
0
   
(1 − 0)(f (0) − f (1)) 1
n= +1= + 1,
ε 2ε

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 ln(2) 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 1/(1+ t )
4 n=i n t ( 1 / ( 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 ]

b) 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
1 −1
C’est exactement la même f : t 7−→ est de classe C 1 sur R. Sa dérivée f 0 : t 7−→ est borné
1+t (1 + t)2
valeur de n qu’avec la mé- par 1. Ainsi, on prend
thode précédente (ce qui
(1 − 0)2
   
n’est pas le cas en général a 1
n= ×1 +1= + 1.
priori). 2ε 2ε

On peut faire encore mieux avec plus d’hypothèses que f , comme on le verra en exercice.

20
 VII Probabilités avec Python
Pour faire des simulations de variables aléatoires avec Python, on commence par importer
la bibliothèque [Link] avec la commande

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

21
Cette deuxième possibilité, 1 i f r d . random ( )<p :
bien que plus compliquée 2 X=1
3 else :
au premier abord, est préfé-
4 X=0
rable car on peut facilement
l’adapter si on veut autre
chose que des 0 et 1 ou si on b) Loi binomiale
veut plusieurs alternatives à
l’expérience.
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 [Link]() (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 facile- 3 i f r d . random ( )<p :
ment l’adapter si on somme 4 X=X+1
des succès d’expériences non
indépendantes ou non iden- • on peut utiliser la commande U=[Link](n) qui renvoie un vecteur contenant
tiques. n réels choisis uniformément entre 0 et 1. La commande U<p renvoie un vecteur
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).

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) 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 facilement
l’adapter si on s’intéresse au Une autre possibilité est d’utiliser la commande U=[Link]() qui renvoie un réel
premier succès lors de la ré- choisi uniformément entre 0 et 1. La commande U<=p renvoie True avec fréquence p et
pétition d’expériences non False avec fréquence 1 − p. Tant qu’on obtient False (c’est-à-dire U>p), on fait appel
indépendantes ou non iden- à cette commande et on compte le nombre d’occurrences avant d’avoir True. Ainsi :
tiques.

22
 1 X=0
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. e) 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 para- On a aussi vu en cours que l’on peut approcher une loi Binomiale par une loi de Poisson.
graphe, nous superposerons Comme lois binomiales sont faciles à simuler avec un ordinateur. Cela nous permet donc
un 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 dia- 3 f o r k in range (n) :
4 i f r d . random ( )<p :
gramme à barre d’une loi
5 X=X+1
P(λ) pour illustrer cette ap-
proximation.
f) Et les autres lois discrètes
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 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 [Link], [Link], [Link] et [Link], 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 la partie VI. Pour • rajouter pour paramètre [n,m] à l’une de ces commandes et on obtient une matrice
faire simple, ce sont des ta- de taille n × m contenant des réalisations de variables aléatoires de la loi (que l’on
bleaux bidimensionnels (du peut considérer indépendantes).
type ndarray).
Exemples :
• [Link](10,0.3,7) renvoie array([2, 3, 3, 4, 5, 0, 3]).
• [Link](10,0.3,[3,5]) renvoie array([[4, 4, 5, 2, 4], .
[2, 2, 2, 3, 5],
[3, 3, 5, 3, 2]])
• [Link](0.2,8) renvoie array([10, 8, 1, 3, 3, 6, 11, 7]).
• [Link](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]])

23
 4) Diagrammes à barres d’une variable aléatoire discrète
a) Le cas des variables discrètes finies
Dans la partie IV, nous avons vu comment tracer le diagramme à barres d’une variable
aléatoire finie. Voyons l’exemple d’une variable aléatoire de loi binomiale.
Exemple : Soient n ∈ N∗ et p ∈ ]−1 ; 1[. Si X ,→ B(n, p), on a P(X = 0) = (1 − p)n
Il suffit de simplifier et on vérifie que, pour tout k ∈ J1 ; nK,
P(X = k) n−k+1 p
. P(X = k) = P(X = k − 1).
P(X = k − 1)
k 1−p
La fonction suivante prend n et p en entrée et trace le diagramme à barres d’une loi
L’option 0.2 qui se trouve binomiale de paramètres n et p (avec un exemple quand n = 20 et p = 0, 3) :
dans le [Link] permet 0.2
d’avoir des barres avec une 1 i m p o r t numpy a s np
plus petite largeur. 2 import m a t p l o t l i b . pyplot as p l t
0.15
3 def DiagBarreBin (n , p) :
4 X=np . z e r o s ( n+1)
5 X[0]=(1 − p ) ∗∗ n 0.1
6 f o r k i n r a n g e ( 1 , n+1) :
7 c=(n−k+1)∗p / ( k∗(1−p ) )
8 X [ k ]= c ∗X [ k −1] 5 · 10−2
9 p l t . b a r ( r a n g e ( n+1) ,X , 0 . 2 )
10 p l t . show ( ) 0
0 5 10 15 20

b) Le cas des variables discrètes infinies

Si X est une variable aléatoire discrèteXinfinie, 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.
n→+∞
Il suffit de ne tracer que les barres correspondant à des probabilités qui ne sont pas « trop
petites » (celles qui sont supérieures à ε = 10−3 par exemple).
Exemples :
• 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 ε
La fonction suivante prend p en entrée et trace le diagramme à barres d’une loi
géométrique de paramètre p (avec un exemple quand p = 0, 2) :
0.25
1 def DiagBarreGeo ( p ) :
0.2
2 e p s =10∗∗( −3)
3 n=i n t ( np . l o g ( e p s ) 0.15
4 / np . l o g (1−p ) )+1
5 X=[(1−p ) ∗ ∗ ( k −1)∗p 0.1
6 f o r k i n r a n g e ( n+1) ]
7 p l t . b a r ( r a n g e ( n+1) ,X , 0 . 2 ) 5 · 10−2

8 p l t . show ( ) 0
0 5 10 15 20 25 30

• Soient a > 0 et X ,→ P(a). 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 à ε.

24
 La fonction suivante prend a en entrée et trace le diagramme à barres d’une loi de
On a P(X = 0) = e −a
et,
Poisson de paramètre a (avec un exemple quand a = 5) :
pour tout k ∈ N∗ ,
1 def DiagBarrePoi ( a ) :
P(X = k) a 2 e s p =10∗∗( −3) 0.15
= .
P(X = k − 1) k 3 p r o b=np . exp (−a )
4 X=[ p r o b ]
5 k=0 0.1
6 w h i l e prob>e s p :
7 k=k+1
8 p r o b=p r o b ∗ a / k 5 · 10−2
9 X . append ( p r o b )
10 p l t . b a r ( r a n g e ( k+1) ,X , 0 . 2 )
11 p l t . show ( ) 0
0 2 4 6 8 10 12 14

5) 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
[Link](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 ]

[Link] ne figure pas dans • On utilise ensuite la commande [Link](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 : On reprend l’exemple du paragraphe précédent avec la loi binomiale que l’on
modifie légèrement pour tracer la fonction de répartition (avec un exemple quand n = 20
Les lignes verticales au ni- et p = 0, 3) :
veau des sauts sont dues au 1
1 d e f FoncRepBin ( n , p ) :
fonctionnement de la fonc-
2 X=np . z e r o s ( n+1)
tion [Link]. 3 F=np . z e r o s ( n+1) 0.8
4 X[0]=(1 − p ) ∗∗ n
5 F[0]=(1 − p ) ∗∗ n 0.6
6 f o r k i n r a n g e ( 1 , n+1) :
7 c=(n−k+1)∗p / ( k∗(1−p ) ) 0.4
8 X [ k ]= c ∗X [ k −1]
9 F [ k ]=F [ k−1]+X [ k ] 0.2
10 p l t . s t e p ( r a n g e ( 0 , n+1) , F ,
where= ’ p o s t ’ ) 0
11 p l t . show ( )
0 5 10 15 20

25
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 [Link] :
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 . plo t ( [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

On se limite dans ce paragraphe au cas d’une variable aléatoire discrète infinie X telle que
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 ).
Exemples : On reprend les exemples usuels du paragraphe précédent, que l’on modifie
légèrement pour tracer la fonction de répartition.
• Le cas d’une loi de Poisson (avec un exemple quand a = 5) :
1 d e f FoncRepPoi ( a ) :
1
2 p r o b=np . exp (−a )
3 f r e p=p r o b
0.8
4 F=[ f r e p ]
5 k=0
0.6
6 w h i l e prob >10∗∗( −3) :
7 k=k+1 0.4
8 p r o b=p r o b ∗ a / k
9 f r e p=f r e p+p r o b 0.2
10 F . append ( f r e p )
11 S=r a n g e ( k+1) 0
12 p l t . s t e p ( S , F , where= ’ p o s t ’ )
0 2 4 6 8 10 12 14
13 p l t . show ( )

26
 • Pour une loi géométrique, on peut faire la même modification mais ici, on connaît
une formule explicite pour la fonction de répartition d’une loi G(p). Il s’agit de :

1 − (1 − p)btc si t > 1

t 7−→
0 sinon.
D’où le script Python (avec un exemple quand p = 0, 2) :

1 d e f FoncRepGeo ( p ) :
2 def Frep ( t ) :
1
3 i f t >=1:
4 x=1−(1−p ) ∗∗ i n t ( t ) 0.8
5 else :
0.6
6 x=0
7 return x 0.4
8 n=i n t (−3∗np . l o g ( 1 0 )
9 / np . l o g (1−p ) )+1 0.2
10 Abs=np . l i n s p a c e ( 0 , n )
0
11 F=[ F r e p ( t ) f o r t i n Abs ]
0 5 10 15 20 25 30
12 p l t . s t e p ( Abs , F , where= ’ p o s t ’ )
13 p l t . show ( )

6) Statistiques d’échantillon
a) Statistiques descriptives
Soit A une liste, un vecteur ou une matrice de réels en Python.
• [Link](A) renvoie la somme des coordonnées de A.
• [Link](A) renvoie le produit des coordonnées de A.
• [Link](A) renvoie le vecteur des sommes cumulées des coordonnées de A.
Par exemple [Link]([1,4,2,7]) renvoie array([1,5,7,14]).
• [Link](A),[Link](A),[Link](A),[Link](A), renvoient respectivement
la moyenne, la variance, l’écart type et la médiane des coordonnées de A.
• [Link](A),[Link](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).

b) Statistiques d’échantillon
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 :

27
 • 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.

La convergence de la Voyons cela à travers un exemple : illustrons le fait que, si λ > 0 alors B(n, λ/n) est une
loi faible des grands approximation de la loi P(λ) lorsque n est grand (cf. paragraphe précédent).
nombres est très lente • Prenons n = 1000 et λ = 5 puis construisons un vecteur contenant N = 10000
en pratique (d’où le réalisations de X ,→ B(n, λ/n) :
N = 10000) tandis que
1 n =1000; lam =5; N=10000; X=r d . b i n o m i a l ( n , lam /n , N)
l’approximation Binomia-
le/Poisson est très rapide
• Créons le vecteur des fréquences d’apparition des entiers de 0 à n dans les données
(on l’utilise dès que n > 30
(mais on peut se limiter au maximum m des données au lieu de n). Pour cela on
dans la pratique).
crée un vecteur nul à m + 1 coordonnées, on parcourt les données une à une et on
incrémente de 1 la coordonnée qui lui correspond. Enfin on divise par N :

1 m=np . max (X) ; E f f=np . z e r o s (m+1)

2 for x in X:
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 utilise le fait que, pour • Maintenant créons un vecteur contenant les valeurs de P(Z = k) pour k ∈ J0 ; mK
tout k ∈ N, et Z ,→ P(λ) :
P(Z = k + 1) λ 1 L o i=np . z e r o s (m+1) ; L o i [ 0 ] = np . exp (−lam )
= .
P(Z = k) k+1 2 f o r k i n r a n g e (m) :
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 [Link], 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 [Link] 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 ’ ,
fonctions en escalier.
where= ’ p o s t ’ )
4 plt . legend ()
5 p l t . show ( )

Nous verrons en TP Voici les deux graphiques que l’on obtient (à gauche celui des fréquences et à droite des
une autre méthode pour fréquences cumulées). On constate bien qu’ils se superposent.
construire la courbe des
fréquences cumulées, que
nous appellerons plutôt
fonction de répartition
empirique.

28
 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 [Link] 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 c) Approche expérimentale de la loi de Gauss
la valeur (oui le left n’est
Soit p ∈ ]0 ; 1[. Pour tout n ∈ N∗ , considérons une variable aléatoire Xn de loi B(n, p).
pas intuitif. Enfin l’option
Un des théorèmes les plus importants de probabilités (qui sera vu en deuxième année)
rwidth = 0.7 sert à ré-
est le Théorème Central Limite. Un cas particulier est que, pour tous réels a et b tels
duire la largeur des barres.
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 2 Xn − np
ϕ : 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

29