Table des matières

Table des matières . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . I

Liste des tableaux . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . III

Table des figures . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . IV

1 Introduction générale . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1
1.1 Python-modules 1
1.1.1 les fonctions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2
1.1.2 les chaînes de caractères . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2
1.1.3 les listes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
1.1.4 modification des listes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
1.2 Lindentation, for, while, if 4
1.2.0.1 Comment choisir entre boucle for et boucle while . . . . . . . . . . . . . . . 5
1.2.0.2 Les instructions break et continue, et la clause else dans les boucles 7
1.2.0.3 La clause else dans une boucle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
1.3 Vecteurs, matrices et tableaux 9
1.4 Tracé de courbes 12
1.4.1 Création d’une courbe : Utilisation de plot() . . . . . . . . . . . . . . . . . . . . . 12
1.5 Le module statistics python 15
1.5.1 Calcul de la moyenne, la médiane, la variance, et le mode . . . . . . . 16
1.5.2 Les quantile . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16
1.6 Fréquence, histogramme 17
1.7 Lois de probabilités 17
1.7.1 lois discrètes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
1.7.2 loi continues . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
2 Statistiques descriptives . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20
2.1 histogrammes et densités 20
2.1.1 Tracer un diagramme en bâtons avec Matplotlib . . . . . . . . . . . . . . . . . 20
2.2 histogramme 22
Liste des tableaux
Table des figures

2.1 Diagramme en bâton . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21

2.2 Diagramme en bâton . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22
2.3 histograme . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
2.4 histograme . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24
Liste des Algorithmes
Chapitre 1

Introduction générale

1.1 Python-modules

Pour commencer avec python 3 , dans la fenêtre de saisie, on importe certains outils appelés
modules qui vont nous permettre de faire des statistiques et des graphiques. Ainsi, dans la fenêtre
de saisie, on écrit :

1. import matplotlib.pyplot as plt

2. import scipy.stats
3. import numpy as np
4. import pylab
5. import pandas as pd
6. import seaborn as sns
7. import statistics
8. import statsmodels.api as smi
9. import math
De brèves présentations de ces modules sont données ci-dessous :

1. matplotlib est un module offrant une bibliothèque complète pour créer des visualisations
statiques, animées et interactives.
2. scipy est un module offrant un grand nombre de lois de probabilité, et doutils statistiques.
3. It’s an open language. A Python script doesn’t need to be compiled in order to be executed,
unlike languages such as C or C++.
4. numpy est un module offrant des fonctions mathématiques complètes, des générateurs de
nombres aléatoires, et diverses routines dalgèbre linéaire.
5. pylab est un module permettant dutiliser de manière aisée les modules NumPy et matplotlib.
6. pandas est un module offrant des structures de données adaptées à lanalyse statistique et
des fonctions facilitant laccès aux données, lorganisation des données et la manipulation
1.1 Python-modules 2

des données.
7. scipy est un module offrant un grand nombre de lois de probabilité, et doutils statistiques.
8. seaborn est un module offrant une interface de haut niveau et concise pour lobtention de
graphiques statistiques informatifs et attractifs.
9. statistics est un module offrant des fonctions pour calculer des statistiques mathématiques
de données numériques (à valeur réelle).
10. statsmodels est un module offrant des classes et des fonctions pour lestimation de divers
modèles statistiques, pour les tests statistiques et pour lexploration des données. Pour une
description détaillée de ces modules, on peut faire, par exemple : help(scipy).

1.1.1 les fonctions

pour les fonction Il sufait d’importer le module de math :
Importer le contenu dun module
import math
b = math.sqrt(a)
Importer une partie dun module
from math import sqrt
Importer tout un module
from math import *
Pratique déconseillée sauf exceptions car rempli lespace des noms car tous les identifiants du
module sont chargés (exceptés ceux qui commencent par le caractère ) example :
import math
b = math.sqrt(5)

1.1.2 les chaînes de caractères

Une chaîne de caractères (string en anglais) est un objet de la classe (ou de type) str. Une
chaîne de caractères peut être définie de plusieurs façons :
"je suis une chaine"
Affichage : ’je suis une chaine’
Les caractères qui composent une chaîne sont numérotés à partir de zéro. On peut y accéder
individuellement en faisant suivre le nom de la chaîne dun entier encadré par une paire de
crochets :
≫ ”bon jour”[3]; ”bon jour”[5]
a f f ichage :
j
u
≫ ”bon jour”[2 :]; ”bon jour”[: 3]; ”bon jour”[3 : 5]
n jour
1.1 Python-modules 3

bon
jo
≫ ”bon jour”[−1 :: −1];
ruo jnob

Méthodes propres
len(s) : renvoie la taille dune chaîne,
s.find : recherche une sous-chaîne dans la chaîne,
s.rstrip : enlève les espaces de fin,
s.replace : remplace une chaîne par une autre,

1.1.3 les listes

Une liste consiste en une succession ordonnée dobjets, qui ne doivent pas nécessairement
être du même type. Les termes dune liste sont numérotés à partir de 0 (comme pour les chaînes
de caractères).
≫ []; list();
Affichage :
[]
[]
≫ l = [1, 2, 3, 4, 5]
[1, 2, 3, 4, 5]
≫ range(10)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
range(2, 10, 2)
[2, 4, 6, 8]

1.1.4 modification des listes

Contrairement aux chaînes de caractères, on peut modifier les éléments dune liste :
≫ l = [1, 2, 3, 4, 5]
≫ l[2 :] = [2, 2, 2]
l
[1, 2, 2, 2, 2]
concaténation
≫ [0] ∗ 7
[0, 0, 0, 0, 0, 0, 0]
≫ L1, L2 = [1, 2, 3], [4, 5]
L1
1.2 Lindentation, for, while, if 4

[1, 2, 3]
L2
[4, 5]
≫ L1 + L2
[1, 2, 3, 4, 5]
len(L) : renvoie la taille de la liste L,
L.sort : trie la liste L,
L.append : ajoute un élément à la fin de la liste L,
L.reverse : inverse la liste L,
L.index : recherche un élément dans la liste L,
L.remove : retire un élément de la liste L,
L.pop : retire le dernier élément de la liste L

1.2 Lindentation, for, while, if

Les fonctions Python nont pas de begin ou end explicites, ni daccolades qui pourraient
marquer là où commence et où se termine le code de la fonction. Le seul délimiteur est les
deux points ( : ) et lindentation du code lui-même. Les blocs de code (fonctions, instructions
if, boucles for ou while etc) sont définis par leur indentation. Lindentation démarre le bloc et la
désindentation le termine. Il ny a pas daccolades, de crochets ou de mots clés spécifiques. Cela
signifie que les espaces blancs sont significatifs et quils doivent être cohérents.
Condition if et else
Exemple :
a = 10.
if a > 0 :
print("a est strictement positif")
if a >= 10 :
print ("a est un nombre ")
else :
print (" a est un chiffre ")
a+ = 1
elif a is not 0 :
print(" a est strictement negatif ")
else :
print(" a est nul ") la condition if Un autre exemple :
≫ L = [1, 3, 6, 8]
if 9 in L :
print ("9 est dans la liste L")
else :
1.2 Lindentation, for, while, if 5

L.append(9)
La boucle conditionnelle
La forme générale dune boucle conditionnelle est
while < test1 >:
< blocs dinstructions 1 >
if < test2 > : break
if < test3 > : continue
else :
< blocs dinstructions 2 >
où lon a utilisé les méthodes suivantes :
break : sort de la boucle sans passer par else,
continue : remonte au début de la boucle,
pass : ne fait rien.
La structure finale else est optionnelle. Elle signifie que linstruction est lancée si et seulement si
la boucle se termine normalement.
Example
x=1
while x < 10 :
print("x a pour valeur", x)
x = x∗2
print("Fin")
Affichage après exécution :

x a pour valeur 1
x a pour valeur 2
x a pour valeur 4
x a pour valeur 8
Le mot-clé while signifie tant que en anglais. Le corps de la boucle (cest-à-dire le bloc dins-
tructions indentées) sera répété tant que la condition est vraie. Dans lexemple ci-dessus, x sera
multiplié par 2 tant que sa valeur reste inférieure à 10.
Remarque : Si la condition est fausse au départ, le corps de la boucle nest jamais exécuté. Si la
condition reste toujours vraie, alors le corps de la boucle est répété indéfiniment.

1.2.0.1 Comment choisir entre boucle for et boucle while

En général, si on connaît avant de démarrer la boucle le nombre ditérations à exécuter, on

choisit une boucle for. Au contraire, si la décision darrêter la boucle ne peut se faire que par un
test, on choisit une boucle while.
for i in range(4) :
print("i a pour valeur", i)
1.2 Lindentation, for, while, if 6

Le programme ci-dessus est équivalent à :

i=0
while i < 4 :
print("i a pour valeur", i)
i = i+1
boucle inconditionnelle
La forme générale dune boucle inconditionnelle est
for < cible > in < ob jet > :
< blocs dinstructions 1 >
if < test1 > : break
if < test2 > : continue
else :
< blocs dinstructions 2 >
Quelques exemples :
Exapmle 1 :
for i in [0, 1, 2, 3] :
print("i a pour valeur", i)
Affichage après exécution :
i a pour valeur 0
i a pour valeur 1
i a pour valeur 2
i a pour valeur 3
Exapmle 2 :

c = [”ROOMS”, ”MF”, ”MSS”, ”ANALY SE”, ”RO”]

for i in range(len(c)) :
print("i vaut", i, "et c[i] vaut", c[i])
Affichage après exécution :
i vaut 0 et c[i] vaut ROOMS
i vaut 1 et c[i] vaut MF
i vaut 2 et c[i] vaut MSS
i vaut 3 et c[i] vaut ANALYSE
i vaut 4 et c[i] vaut RO

Rappel : La fonction len() renvoie le nombre déléments : c = [”ROOMS”, ”MF”, ”MSS”, ”ANALY SE”, ”RO”]
len(c)
5
1.2 Lindentation, for, while, if 7

1.2.0.2 Les instructions break et continue, et la clause else dans les boucles

Linstruction break
Linstruction break permet de « casser » lexécution dune boucle (while ou for). Elle fait sortir de
la boucle et passer à linstruction suivante.
Exemple :

for i in range(10) :
print("debut iteration", i)
print("bonjour")
if i == 2 :
break
print("fin iteration", i)
print("apres la boucle")

Affichage après exécution :

debut iteration 0
bonjour
fin iteration 0
debut iteration 1
bonjour
fin iteration 1
debut iteration 2
bonjour
apres la boucle
Note :Dans le cas de boucles imbriquées, linstruction break ne fait sortir que de la boucle la plus
interne.

Linstruction continue
Linstruction continue permet de passer prématurément au tour de boucle suivant. Elle fait
continuer sur la prochaine itération de la boucle.
Linstruction continue permet de passer prématurément au tour de boucle suivant. Elle fait
continuer sur la prochaine itération de la boucle.
Exemple :

for i in range(4) :
print("debut iteration", i)
print("bonjour")
if i < 2 :
continue
1.2 Lindentation, for, while, if 8

print("fin iteration", i)
print("apres la boucle")
Affichage après exécution :

debut iteration 0
bonjour
debut iteration 1
bonjour
debut iteration 2
bonjour
fin iteration 2
debut iteration 3
bonjour
fin iteration 3
apres la boucle

1.2.0.3 La clause else dans une boucle

La clause else dans un boucle permet de définir un bloc dinstructions qui sera exécuté à la fin
seulement si la boucle sest déroulée complétement sans être interrompue par un break.
Autrement dit, le bloc de la clause else est exécuté lorsque la boucle se termine par épuisement
de la liste (avec for) ou quand la condition devient fausse (avec while), mais pas quand la boucle
est interrompue par un break. Ceci est illustré dans la boucle suivante, qui recherche des nombres
premiers :

for n in range(2, 8) :
for x in range(2, n) :
if n%x == 0 :
print(n, "egale", x, "*", n/x)
break
else :
print(n, "est un nombre premier")

Affichage après exécution :

2 est un nombre premier

3 est un nombre premier
4 egale 2 ∗ 2.0
5 est un nombre premier
6 egale 2 ∗ 3.0
1.3 Vecteurs, matrices et tableaux 9

7 est un nombre premier

1.3 Vecteurs, matrices et tableaux

umpy ajoute le type array qui est similaire à une liste (list) avec la condition supplémentaire
que tous les éléments sont du même type. Nous concernant ce sera donc un tableau d’entiers, de
flottants voire de booléens.
Une première méthode consiste à convertir une liste en un tableau via la commande array. Le
deuxième argument est optionnel et spécifie le type des éléments du tableau.
vecteur
a = np.array([1, 4, 5, 8], float)
a
array([1., 4., 5., 8.])
type(a)
type ’numpy.ndarray’
matrice
a = np.array([[1, 2], [1, 2]])
Affichage après exécution :
a
array([[[1, 2],
[1, 2]],

Nous limiterons notre étude aux tableaux (uni,bi)-dimensionnels. En Python modifier une
donnée dune extraction dun tableau entraîne aussi une modification du tableau initial ! Si néces-
saire la fonction np.copy(a) ou a.copy() permet de faire une copie dun tableau a.
a = np.array([1, 2, 3, 4, 5])
c = np.array([1, 2, 3, 4, 5])
b = a[1 : 3]
b
array([2, 3])
b[1] = 0
a
array([1, 2, 0, 4, 5]) a modifié
b = c[1 : 3].copy() première méthode
b[1] = 0 bb = np.copy(c[1 : 3]) seconde méthode
b[1] = 0
c
array([1, 2, 3, 4, 5]) c non modifié
la fonction arange
1.3 Vecteurs, matrices et tableaux 10

a = np.arange(10)
array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
a[2 : 9 : 3] [début :fin :pas]
array([2, 5, 8])
a[2 : 8 : 3] le dernier élément n’est pas inclus
array([2, 5])
a[: 5] le dernier élément n’est pas inclus
array([0, 1, 2, 3, 4]
la fonction linspace(premier,dernier,n) renvoie un array commençant par premier, se terminant
par dernier avec n éléments régulièrement espacés.

np.linspace(1., 4., 6)
array([1., 1.6, 2.2, 2.8, 3.4, 4.])
Numpy propose le redimensionnement dun tableau avec la fonction reshape. Il faut tout de même
respecter une condition : le nombre déléments doit être le même ! :
a = np.arange(16)
a
array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15])
a.reshape(4, 4)
array([[0, 1, 2, 3],
[4, 5, 6, 7],
[8, 9, 10, 11],
[12, 13, 14, 15]])
a.reshape(2, 8)
array([[0, 1, 2, 3, 4, 5, 6, 7],
[8, 9, 10, 11, 12, 13, 14, 15]])

Matrices particulières
np.zeros(n)((n, p)) vecteur nul de taille n, matrice nulle de taille n, p
np.eye(n)((n, p)) matrice de taille n, (n, p) avec des 1 sur la diagonale et des zéros ailleurs
np.ones(n)((n, p)) vecteur de taille n, matrice de taille n, p remplie de 1
np.diag(v) matrice diagonale dont la diagonale est le vecteur v
np.diag(v, k) matrice dont la diagonale décalée de k est le vecteur v (k est un entier relatif)
np.random.rand(n)((n, p)) vecteur (taille n), matrice (taille n, p) à coefficients aléatoires uni-
formes sur [0, 1].
Matrices : Opérations
Lopérateur * ne fait que multiplier terme à terme deux tableaux de même dimension :
4 ∗ np.ones((4, 4)) ∗ np.diag([2, 3, 4., 5])
array([[8., 0., 0., 0.],
[0., 12., 0., 0.],
1.3 Vecteurs, matrices et tableaux 11

[0., 0., 16., 0.],

[0., 0., 0., 20.]])
ans le même ordre a ∗ ∗3 renvoie le vecteur/matrice de même dimension dont tous les éléments
sont ceux de a élévés à la puissance 3
Pour le produit matriciel (le vrai) la commande np.dot est là
np.dot(4 ∗ np.ones((4, 4)), np.diag([2, 3, 4., 5]))
array([[8., 12., 16., 20.],
[8., 12., 16., 20.],
[8., 12., 16., 20.],
[8., 12., 16., 20.]])

Le "slicing" permet dextraire des éléments dun vecteur ou matrice. Il existe aussi la com-
mande np.take qui extrait lignes/colonnes dun array. Loption axis détermine une extraction selon
les lignes/colonnes. La syntaxe se comprend aisément.
a = np.arange(16).reshape(4, 4)
a.take([0, 3], axis = 1) array([[0, 3],
[4, 7],
[8, 11],
[12, 15]])

p.append(A, B) : fusionne les vecteurs A et B ;

s’il s’agit de matrices ou de tenseurs, la fonction les « aplatit », les transforme en vecteur ;
si l’on veut intégrer B dans A, on utilise A = np.append(A, B) ;
np.append(A, B, axis = i) : fusionne les tenseurs selon l’indice i (0 pour le premier indice, 1
pour le deuxième) ;
np.insert(A, i, m) : insère le vecteur m dans le vecteur A (ou la matrice A aplatie) à l’emplace-
ment i ;
np.insert(A, i, M, axis = j) : insère le tenseur M dans le tenseur A à l’emplacement i de l’indice
j;
np.delete(A, I) : efface les éléments définis par le tranchage I du vecteur A (ou de la matrice A
aplatie) ;
np.delete(A, I, axis = j) : efface les éléments définis par le tranchage I selon l’indice j du tenseur
A.
Avec la méthode reshape(), on peut utiliser la valeur 1 pour une des dimensions ; sa valeur est
alors automatiquement calculée en fonction du nombre d’éléments et de l’autre dimension. On
peut aussi utiliser une dimension vide ; cela crée alors un vecteur. Par exemple, pour une matrice
M quelconque :
M.reshape(-1, 1) crée une matrice colonne
M.reshape(1, -1) crée une matrice ligne
M.reshape(-1,) crée un vecteur
1.4 Tracé de courbes 12

1.4 Tracé de courbes

our tracer des courbes, Python nest pas suffisant et nous avons besoin de la bibliothèque
Matplotlib utilisée dans ce cours

1.4.1 Création d’une courbe : Utilisation de plot()

Linstruction plot() permet de tracer des courbes qui relient des points dont les abscisses et
ordonnées sont fournies en arguments.
Exemple 1 :
import numpy as np
import matplotlib.pyplot as plt
plt.plot([1, 3, 4, 6], [2, 3, 5, 1])
plt.show() affiche la figure à l’écran Exemple 1 :

fig, ax = plt.subplots()
ax.plot([1, 3, 4, 6], [2, 3, 5, 1])
plt.show() affiche la figure à l’écran
import numpy as np
import matplotlib.pyplot as plt

fig, ax = plt.subplots()
ax.plot([1, 3, 4, 6], [2, 3, 5, 1])
plt.show() affiche la figure à l’écran

Exemple 3 :
Dans cet exemple, nous allons tracer la fonction cosinus.
import numpy as np
import matplotlib.pyplot as plt
x = np.linspace(0, 2 ∗ np.pi, 30)
y = np.cos(x)
plt.plot(x, y)
plt.show() affiche la figure à l’écran

Définition du domaine des axes - xlim(), ylim() et axis()

Dans le style pyplot, il est possible fixer les domaines des abscisses et des ordonnées en utilisant
les fonctions xlim(), ylim() ou axis().
1.4 Tracé de courbes 13

xlim(xmin, xmax)
ylim(ymin, ymax)

axis() permet de fixer simultanément les domaines des abscisses et des ordonnées.
Avec axis(), les limites du domaine doivent être données dans une liste où les valeurs sont
entourées par des crochets [et].

axis([xmin, xmax, ymin, ymax]) Example :

import numpy as np
import matplotlib.pyplot as plt
x = np.linspace(0, 2 ∗ np.pi, 30)
y = np.cos(x)
plt.plot(x, y)
plt.xlim(-1, 5)
plt.show()

Exemple avec axis() :

import numpy as np
import matplotlib.pyplot as plt
x = np.linspace(0, 2 ∗ np.pi, 30)
y = np.cos(x)
plt.plot(x, y)
plt.axis([−1, 5, −2, 2])
plt.show()

Ajout d’un titre, legend, Labels sur les axes - xlabel() et ylabel() - title()
Dans le style pyplot, on peut ajouter un titre grâce à linstruction title().
import numpy as np
import matplotlib.pyplot as plt
x = np.linspace(0, 2 ∗ np.pi, 30)
y = np.cos(x)
plt.plot(x, y)
plt.xlabel("abscisses")
plt.ylabel("ordonnées")
plt.title("Fonction cosinus")
plt.legend()
plt.show()
1.4 Tracé de courbes 14

Affichage de plusieurs courbes

Pour afficher plusieurs courbes sur un même graphe, on peut procéder de la façon suivante :
import numpy as np
import matplotlib.pyplot as plt
x = np.linspace(0, 2 ∗ np.pi, 30)
y1 = np.cos(x)
y2 = np.sin(x)
plt.plot(x, y1, label="cos(x)")
plt.plot(x, y2, label="sin(x)")
plt.show()

Formats de courbes :
Il est possible de préciser la couleur, le style de ligne et de symbole (marker) en ajoutant une
chaîne de caractères de la façon suivante :
Exemple :

x = np.linspace(0, 2 ∗ np.pi, 20)

y = np.sin(x)
plt.plot(x, y, "o-", label="ligne -", linewidth=4))
plt.plot(x, y-0.5, "o–", label="ligne –", linewidth=4.5))
plt.plot(x, y-1, "o :", label="ligne :", linewidth=1.8))
plt.plot(x, y-1.5, "o-.", label="ligne -.")
plt.plot(x, y-2, "o", label="pas de ligne")
plt.legend()
plt.show()import numpy as np
import matplotlib.pyplot as plt

x = np.linspace(0, 2 ∗ np.pi, 20)

y = np.sin(x)
plt.plot(x, y, "o-", label="ligne -", linewidth=4))
plt.plot(x, y-0.5, "o–", label="ligne –", linewidth=4.5))
plt.plot(x, y-1, "o :", label="ligne :", linewidth=1.8))
plt.plot(x, y-1.5, "o-.", label="ligne -.")
plt.plot(x, y-2, "o", label="pas de ligne")
plt.legend()
plt.show()
Couleur
Les chaînes de caractères suivantes permettent de définir la couleur :
b blue
g green vert
1.5 Le module statistics python 15

r red rouge
c cyan cyan
m magenta magenta
y yellow jaune
k black noir
w white blanc

Affichage de plusieurs tracés dans la même figure

Style « pyplot » - Utilisation de subplot()
La fonction subplot() permet dorganiser différents tracés à lintérieur dune grille daffichage. Il
faut spécifier le nombre de lignes, le nombre de colonnes ainsi que le numéro du tracé.
Exemple
import numpy as np
import matplotlib.pyplot as plt
def f(t) :
return np.exp(−t) ∗ np.cos(2 ∗ np.pi ∗ t)
t1 = np.arange(0.0, 5.0, 0.1)
t2 = np.arange(0.0, 5.0, 0.02)
plt.subplot(211)
plt.plot(t1, f(t1), "bo")
plt.plot(t2, f(t2), "k")
plt.subplot(212)
plt.plot(t2, np.cos(2 ∗ np.pi ∗ t2), "r–")
plt.show()

1.5 Le module statistics python

Vue l’importance des statistiques dans le domaine informatique, le langage Python propose
de nombreux modules pour les statistiques, le module que nous proposons dans ce tutoriel
s’appelle le module ’statistics’. Il s’agit d’un module simple et qui traite rapidement les données
statistiques. Le module python ’statistics’ fournit des fonctions simples pour calculer les valeurs
statistiques d’un ensemble de données. Ils affirment qu’ils ne sont pas en concurrence avec
NumPy, SciPy ou d’autres logiciels tels que SPSS, SAS et Matlab. Et en effet, c’est un module
très simple. Il ne fournit pas de tests paramétriques ou même non paramétriques. Au lieu de cela,
il peut être utilisé pour effectuer des calculs simples. Ils affirment en outre qu’ils prennent en
charge int, float, décimals et fractions.
Le module statistics est doté d’un certain nombre de méthodes permettant le calcul de tous les
paramètres statistiques comme : moyenne , mode, mediane, variance, ecart-type..
1.5 Le module statistics python 16

mean() : moyenne arithmétique («moyenne») des données.

fmean() : moyenne arithmétique rapide en virgule flottante.
median() : médiane (valeur moyenne) des données.
mode() : mode unique (valeur la plus courante) de données discrètes ou nominales.
multimode() : liste des modes (valeurs les plus courantes) de données discrètes ou nomimales.
quantiles() : divisez les données en intervalles avec une probabilité égale.
pstdev() : écart type des données de population.
pvariance() : Variance des données de la population.
stdev() : d’écart-type de données.
variance() : Variance de l’échantillon de données.

1.5.1 Calcul de la moyenne, la médiane, la variance, et le mode

Example :
import statistics as st
valeurs = [17, 21, 22, 18, 19, 17, 21]
print("La moyenne des valeurs est : " , st.mean(valeurs))
print("La mediane des valeurs est : " , st.median(valeurs))
print("La variance est : " , st.variance(valeurs))
Le mode :
from statistics import mode
valeurs =[21, 7, 2, 7, 3, 7, 5]
print("Le mode des valeurs est : " , mode(valeurs))

1.5.2 Les quantile

NumPy fournit la fonction np.quantile() qui détermine les quantiles avec la syntaxe :
np.quantile(M, q)
où M est une matrice (ou une liste, un n-uplet, bref un itérable de nombres) et q est un quantile
ou un vecteur de quantiles sous la forme d’un nombre entre 0 et 1. Par exemple, pour avoir les
quartiles :
np.quantile(M, [0, 0.25, 0.5, 0.75, 1])
Notons que pour toutes les fonctions, il est possible d’indiquer l’axe selon lequel on effectue le
calcul. Par exemple :
M = np.arange(9).reshape(3, 3)
[[0, 1, 2]
[3, 4, 5]
[6, 7, 8]]
print(np.quantile(M, [0.25, 0.5], 0))
1.6 Fréquence, histogramme 17

[[1.52.53.5] : 1er quartile des colonnes

[3.4.5.]] : médiane des colonnes
print(np.quantile(M, [0.25, 0.5], 1))
[[0.53.56.5] : 1er quartile des lignes
[1.4.7.]] : médiane des lignes

1.6 Fréquence, histogramme

On peut générer une matrice aléatoire avec les fonctions np.random.rand(), qui utilise une loi
uniforme sur [0; 1], et np.random.randn() qui utilise une loi normale centrée réduite.
Lorsque l’on dispose d’une série de données aléatoires, qu’elles aient été mesurées ou bien
générées par une fonction aléatoire, on peut ensuite les mettre dans des classes (bins). Les classes
sont définies par un vecteur (ou une liste, un n-uplet) [c1 , c2 , c3 , ..., cn ]. La classe 0 désigne les va-
leurs inférieures à c1 ; la classe 1 désigne les valeurs c1 = x < c2 ; la classe n(n == len(classes))
désigne les valeurs supérieures à cn . La fonction np.digitize() indique dans quelle classe se
trouve un nombre. Si on lui donne une matrice (ou un vecteur, une liste, un n-uplet), il renvoie
une matrice de même dimension, np.digitize(M, classes)[i, j] étant la classe de l’élément M[i, j].
Par exemple :
M = np.random.rand(10)
classes = (0, 0.2, 0.4, 0.6, 0.8, 1)
print(M)
print(np.digitize(M, classes))
La fonction np.histogram() détermine n classes de même taille et renvoie deux vecteurs : le
premier contient le nombre d’éléments dans chaque classe et le second décrit les classes (c’est-à-
dire les bornes des classes). Pour tracer l’histogramme, nous disposons de la fonction plt.hist() :
Example :
M = np.random.randn(50)
plt.plot(M, np.onesl ike(M), ”|”)
plt.hist(M, bins = 10, density = 1)
La fonction np.bincount() travaille sur les listes de nombres entiers. Elle renvoie un n-uplet,
np.bincount(M)[i] est le nombre de fois que le nombre i revient dans la matrice M rappel, le
premier élément du n-uplet np.bincount(M) a l’indice 0 donc correspond au nombre de fois que
le nombre 0 apparaît dans la matrice M.

1.7 Lois de probabilités

Le module scipy.stats fournit un grand nombre de lois de probabilités. Ces lois sont des
objets ayant toutes les mêmes méthodes. Par exemple, on dispose des lois suivantes :
1.7 Lois de probabilités 18

1.7.1 lois discrètes

bernoulli : loi de Bernoulli,
scipy.stats.binom : loi binomiale,
scipy.stats.poisson : loi de Poisson,
scipy.stats.randint : loi discrète uniforme ;

1.7.2 loi continues

scipy.stats.chi2 : loi du ?2 (khi carré),
scipy.stats.norm : loi normale,
scipy.stats.t : loi de Student,
scipy.stats.uniform : loi continue uniforme ;
et des méthodes suivantes :
.mean() : calcule la moyenne, l’espérance de la loi ;
.median() : calcule la médiane de la loi ;
.var() : calcule la variance de la loi ;
.std() : calcule l’écart type (standard deviation) de la loi ;
.moment() : calcule les moments de la loi ;
.rvs() : effectue des tirages aléatoires (random variables) ;
.pdf() : fonction densité de probabilité (probability density function) pour les lois continues ;
.mdf() : fonction de masse (mass density function) pour les lois discrètes ;
.cdf() : fonction de répartition (cumulative density function) ;
.ppf() : fonction quantile (percent-point function) ;
.fit() : calcule les paramètres de la loi correspondant au mieux à un échantillon, au sens du
maximum de vraisemblance ; uniquement pour les lois continues.
Par exemple
from scipy import stats
print(stats.norm.pdf(1), " ;", stats.norm.cdf(0.5), " ;", stats.norm.ppf(0.99))
x = np.linspace(-6, 6, 100)
y1 = stats.norm.pdf(x)
y2 = stats.norm.cdf(x)
plt.plot(x, y1, label="densité")
plt.plot(x, y2, label="répartition")
plt.legend()
Par défaut, les lois continues sont centrées réduites (de moyenne nulle et d’écart type unité). Les
objets disposent des paramètres loc (location, position) et scale (échelle) ; par exemple pour un
tirage aléatoire de 100 échantillons avec une loi normale de moyenne 10 et d’écart type 5 :
1.7 Lois de probabilités 19

stats.norm.rvs(100, loc = 5, scale = 10)

L’exemple suivant consiste à vérifier qu’un échantillon suit bien une loi normale centrée réduite
en traçant sa droite de Henry :
import numpy as np
from scipy import stats
import matplotlib.pyplot as plt
X = stats.norm.rvs(size = 100)
p = np.arange(0.1, 1, 0.1)
qexp = np.quantile(X, p)
qth = stats.norm.pp f (p)
extr = stats.norm.pp f ([0.1, 0.9])

plt.plot(extr, extr, "–r")

plt.plot(qth, qexp, "*")
plt.title("diagramme quantiles-quantiles")
plt.xlabel("quantiles théoriques")
plt.ylabel("quantiles expérimentaux")
Pour les lois discrète, il est nécessaire d’indiquer leurs paramètres.
pour la loi de Bernoulli, la probabilité p : stats.bernoulli(p) ;
pour la loi binomiale, les facteurs de forme n et p : stats.binom(n, p) ;
pour la loi de Poisson : le paramètre µ(mu) : stats.poisson(mu), l est également possible de
décaler la loi, stats.poisson(mu, loc) ;
pour la loi discrète uniforme, les valeurs minimales et maximales : stats.randint(low, high).
Chapitre 2

Statistiques descriptives

2.1 histogrammes et densités

2.1.1 Tracer un diagramme en bâtons avec Matplotlib
Example 1 :
import matplotlib.pyplot as plt
import numpy as np
x = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
height =[8, 12, 8, 5, 4, 3, 2, 1, 0, 0]
width = 1.0
plt.bar(x, height, width, color =′ b′ )
plt.save f ig(′ SimpleBar.png′ )
plt.show()
Changer de style d’un diagramme en bâtons avec Matplotlib :
On peut ensuite modifier le style :
width = 0.05 pour modifier la largeur des bâtons
plt.xlim(0, 11) pour modifier les limites sur x
plt.ylim(0, 14) pour modifier les limites sur y
pylab.xticks(x, BarName, rotation = 40) pour ajouter des labels aux bâtons
plt.scatter(x, height, color =′ k′ , s = 40) pour ajouter un cercle au sommet du bâton
Example 2 :
import matplotlib.pyplot as plt
import numpy as np
import pylab
f ig = plt. f igure()
x = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
height = [8, 12, 8, 5, 4, 3, 2, 1, 2, 4]
width = 0.05
BarName = [′ a′ ,′ b′ ,′ c′ ,′ d ′ ,′ e′ ,′ f ′ ,′ g′ ,′ h′ ,′ i′ ,′ j′ ]
2.1 histogrammes et densités 21

htp

F IGURE 2.1 – Diagramme en bâton

plt.bar(x, height, width, color = ”b”)

plt.scatter(x, height, color = ”k”, s = 40)
plt.xlim(0, 11)
plt.ylim(0, 14)
plt.grid()
plt.ylabel(′Counts′ )
plt.title(′ DiagrammeenBatons′ )
pylab.xticks(x, BarName, rotation = 40)
plt.save f ig(′ SimpleBar.png′ )
plt.show()
Resultats :

Example 3 :
Méthode de base améliorée : on peut ajouter autant de catégories que désiré (+ tracé d’une
légende) Categories = [”Echantillon1”, ”Echantillon2”, ”Echantillon3”] 3 échantillons
Sous − categories = [′ Qualit ′ ,′ Environnement ′ ,′ Social ′ ,′ Bien − tre′ ] comparés selon 4 critères
Valeurs pour chaque catégories
import math
import numpy as np
import pandas as pd
import seaborn as sns
import matplotlib.pyplot as plt
import pylab
categories = [”Echantillon1”, ”Echantillon2”, ”Echantillon3”]
sous − categories = [′ Qualit ′ ,′ Environnement ′ ,′ Social ′ ,′ Bien − tre′ ]
y1 = [1, 2, 5, 2]
y2 = [1, 6, 4, 2]
y3 = [1, 6, 4, 2]
nb − categories = len(y1)
largeur − barre = 0.2
2.2 histogramme 22

F IGURE 2.2 – Diagramme en bâton

x1 = range(len(y1))
x2 = [i + largeur − barre f oriinx1]
x3 = [i + 2 ∗ largeur − barre f oriinx1]
plt.bar(x1, y1, width = largeur − barre, color =′ red ′ , edgecolor =′ black′ , linewidth = 2)
plt.bar(x2, y2, width = largeur − barre, color =′ blue′ , edgecolor =′ black′ , linewidth = 2)
plt.bar(x3, y3, width = largeur − barre, color =′ green′ , edgecolor =′ black′ , linewidth = 2)
pylab.xticks(x1, sous − categories, rotation = 40)
plt.legend(categories, loc = 2)
plt.show()
plt.save f ig(′ baton2.png′ )

Resultats :

2.2 histogramme
Soit un ensemble de nombre réels. Dans la plupart des cas les échantillons sont construit :
soit à partir de simulation successive de v.a (ex : v.a gaussienne) soit à partir d’observations (ex :
tailles des gens dans la rue). Dresser l’histogramme dun échantillon consiste à découper les réel
en sous-interavalles, puis d’afficher des batons qui ont pour base ces sous-intervallse, et comme
hauteur le nombre d’élément de l’échantillon contenu dans chaque sous-intervalles.
Example :
import math
import numpy as np
import pandas as pd
import seaborn as sns
import matplotlib.pyplot as plt
import pylab
2.2 histogramme 23

F IGURE 2.3 – histograme

x = [1, 2, 2, 3, 4, 4, 4, 4, 4, 5, 5]
plt.hist(x, range = (0, 5), bins = 5, color = ’yellow’, edgecolor = ’red’)
plt.xlabel(’valeurs’)
plt.ylabel(’nombres’)
plt.title(’Exemple dh́istogramme simple’)
plt.savefig(’b3.png’)

Example 3 :

import math
import numpy as np
import matplotlib.pyplot as plt
x=[1, 3, 4, 6]
la loi beta
nbData=10000
X1=np.random.beta(3,1,size=nbData)
X2=np.random.beta(2,3,size=nbData)
X3=np.random.beta(1,0.5,size=nbData)
plt.hist([X1,X2,X3],bins=20,label=["a=3,b=1","a=2,b=3","a=1,b=0.5"]) ;
plt.legend()
plt.savefig(’b4.png’)
2.2 histogramme 24

F IGURE 2.4 – histograme

2.2 histogramme 25