Initiation à Python

Wilson Toussile

Introduction

Qu'est-ce que Python

Python est un langage de programmation interprété, multi-paradigme et multiplateformes (Windows, xOS,

Linux, Android,...).
Il devient un outil du quotidien pour les ingénieurs et chercheurs de toutes les disciplines scientifiques.
Grâce a de très nombreuses librairies d'une grande qualité, il permet aujourd'hui d'égaler, voire de
surpasser des solutions propriétaires les plus performantes du marché (MatLab, Maple, Mathematica,
Statistica, SAS...).
Il est un des outils incontournables des Data Scientists !

Avantages

Gratuit, open-source et rapide :

La plupart des librairies scientifiques de Python, généralement implémentées en C, peuvent être
compilées pour tirer partie des architectures vectorielles et multicoeurs/multithread des processeurs
modernes.
De nombreuses librairies permettant d'aborder plusieurs domaines comme : les Mathématiques, la
Statistique, Le traitement du signal, la Chimie, la Génétique, l'Apprentissage Automatique, La science des
données, la Cartographie ...
Python peut être déployé en production
Il est relativement facile, même pour les non informaticiens
Il est en grande partie développé par la communauté scientifique elle-même
Les distributions Python pour la « data science »

Anaconda : distribution la plus répandue, cross-plateform, Elle inclue plus de 100 librairies pré-installées
et en propose 600 de plus en téléchargement.
WinPython : distribution Python qui est entièrement libre mais spécifique à Windows.
Python Anywhere : offre un environnement Python hébergé en ligne et donc accessible de toute part.
Python (x,y) : offre un environnement de développement libre pour le calcul scientifique, basé sur Python
Qt et Spyder
Enthought Canopy : propose une distribution Python et un environnement d'analyse intégré (un peu
comme MatLab).

Les librairies incontournables

Math : propose les fonctions mathématiques usuelles.

Numpy : librairie d'Algèbre linéaire.
Pandas : librairie de manipulation des données statistiques.
Statsmodels : analyse de modèles statistiques.
Scipy : propose un ensemble de librairies mathématiques regroupées par disciplines (analyse numérique,
algèbre linéaire, statistiques, traitement du signal, traitement d'images, …).
Matplotlib : MatplotLib est une librairie de tracé de courbes en 2D et 3D.
scikit-learn (sklearn) : pour l'apprentissage automatique (Machine Learning).
Jupyter Notebook : pour rédiger des rapports.

Démarrer Python

Lancer l'interpréteur Python dans un terminal par

python # ou python3

Lancer l'interpréteur IPython dans un terminal par

ipython # on ipython3

Lancer Jupyter Notebook ou IPython notebook

jupyter notebook # ipython notebook

Les IDEs pour Python

Spyder (https://spyder-ide.github.io/) : bonne intégration de IPython, explorateur de variables,

documentation intégrée, editeur IPython notebook.
IPython notebook (https://ipython.org/) : exploite les navigateurs tels que FireFox comme éditeur, permet
de rédiger des rapports contenant du code Python.
Anaconda (https://www.anaconda.com/distribution/) : distribution + IDE
PyCharm (https://www.jetbrains.com/pycharm/)

Les types de base et quelques conteneurs

Fonction de base pour afficher à l'écran :

print("Hello world)
print("Bonjour Mr/Mme {}".format("Jacques"))
x = 9
print("La valeur de {} = {}.format("x", x))

Les nombres

print(2+7) # Des simples calculs dans la console

a = 10 # Créer une variable nommé a et lui affecter une valeur

print("La valeur de la variable a = {} et elle est de type {}".format(a, type(a
)))

b = 1.5+3j # Créer un nombre complexe

print("La valeur de la variable b = {} et elle est de type {}".format(b, type(b
)))
print("|b| = {}".format(abs(b)))

Quelques conteneurs
 In [5]: import IPython.core.display as di # Pour formater les sorties

list1 = [1, 7, "X", 3, [0, 2]] # Conteneur de base: la liste

di.display_html("<h5>Exemples de listes</h5>", raw = True)

print("Le contenu de list1 = {}".format(list1))
print("La longueur de list1 = {}".format(len(list1)))
print("L'élément d'indice 0 de list1 est {}".format(list1[0]))

# Ensemble : ne peut contenir que des types de base

di.display_html("<h5>Exemples d'ensembles</h5>", raw = True)
set1 = {2, 7, 9, "c", 6, 2, 9}
print("Le contenu de set1 = {}. Remarquer qu'il n'y a pas de doublons.".form
at(set1))

Exemples de listes
Le contenu de list1 = [1, 7, 'X', 3, [0, 2]]
La longueur de list1 = 5
L'élément d'indice 0 de list1 est 1

Exemples d'ensembles
Le contenu de set1 = {'c', 9, 2, 6, 7}. Remarquer qu'il n'y a pas de doublo
ns.

In [5]: # Tuple : Comme une liste mais pas modifiable

t1 = (8, 5, 60, [0,1], 8)
di.display_html("<h5>Exemple de Tuple</h5>", raw = True)
print("Le contenu de t1 = {} et sa longueur = {}. Le nombre de 8 = {}".forma
t(t1, len(t1), t1.count(8)))

# Dictionnaire : Comme des ensembles mais avec des index

d1 = {"a" : 0, "b" : 8, "c" : 5, "d" : [3, 7, "x"]}
di.display_html("<h5>Exemple de Dictionnaire</h5>", raw = True)
print("Le contenu de d1 = {} et sa longueur = {}. L'élement 'd'= {}".format(
d1, len(d1), d1.get("d")))

Exemple de Tuple
Le contenu de t1 = (8, 5, 60, [0, 1], 8) et sa longueur = 5. Le nombre de 8
= 2

Exemple de Dictionnaire
Le contenu de d1 = {'d': [3, 7, 'x'], 'b': 8, 'c': 5, 'a': 0} et sa longueu
r = 4. L'élement 'd'= [3, 7, 'x']

Exercice d'application

1. Créer une liste a contenant les entiers naturels pairs $\leq 100$. Indication : Utiliser la fonction range .
2. Créer une liste b contenant les racines carrées des éléments de a .
 # Première question
a = [i for i in range(0, 101, 2)]
print("a = {}".format(a))

# Deuxième question
import math
b = [math.sqrt(i) for i in a]
print("b = {}".format(b))

Notes sur la programmation orientée objet (POO)

1. Pour afficher les attributs et les méthodes d'un objet x , on exécute dir(x) .
2. Pour lire l'aide d'une méthode meth de x , on exécute help(x.meth) .
3. Pour appliquer une méthode meth de x , on exécute x.meth(...) où ... représente les
arguments.
4. L'accès à un attribut att de x se fait par x.att .

# Exemple d'utilisation de count

c = [2, "a", [2, 4], "a", {"a": 10, "b": 20}, [2, 4], "a", {7, "a", "b", "a"}]

# Longueur de c
print("c est une liste de {} d'éléments".format(len(c)))

# Les types des éléments de c

print("Types : {}.".format([type(xx) for xx in c]))

# Nombre d'occurences de 'a' dans c

print("Nombre de {} dans c : {}".format("'a'", c.count("a")))

Conditions, branchements et boucles

Branchements: if, elif, else

Examiner ce qui suit et dites ce qui sera afficher à l'écran :

# Code 1
a = 3
b = 2
if a < b:
print("a = {} est strictement inférieur à b = {}".format(a, b))
elif a > b:
print("b = {} est strictement inférieur à a = {}".format(b, a))
else:
print("a = {} est égal à b = {}".format(a, b))

# Code 2
statement1 = a < b
statement2 = a > b
if statement1: # On peut ne pas écrire "is True"
print("a est strictement inférieur à b")
elif statement2:
print("b est strictement inférieur à a")
else:
print("b est égal à a")

Note : L'indentation est obligatoire en Python

Même question :

statement1 = False
statement2 = False
if statement1:
print("statement1 is True")
elif statement2:
print("statement2 is True")
else: print("statement1 and statement2 are False")

Note : L'indentation est obligatoire en Python

Boucles
Exemple 1 de boucle for :

for x in [0, 1, 2 ,3]:

print("x = {}".format(x))

Exemple 2 de boucle for avec range :

for x in range(4):
print("x = {}".format(x))

Exemple 3 de boucle for :

for word in ["calcul","scientifique","en","python"]:

print(word)

Exemple de while :

i = 0
while i < 5:
print("i = {}".format(i))
i = i + 1
print("Fin de la bouble avec i = {}".format(i))

Fonctions python

Une fonction est une suite d'instructions que l'on peut appeler avec un nom.

Exemples simples de fonctions

 def hello_word():
'''
Mon aide
========
Ma toute première fonction.

Bref:
-----
Écrire "Hello word !"

Liste des arguments :

---------------------
Aucun argument

Sortie:
-------
Aucune sortie
'''
print("Hello word !")
return

Exécution :

hello_word()

Commentaires sur l'indentation :

Conseils :

1. Utiliser un éditeur approprié pour écrire les fonctions dans des fichiers que l'on peut importer par la
commande

import mon_fichier

2. Noter que lorsqu'un module a déjà été importer, la commande précédente n'a aucun effet. Si vous
modifiez votre fichier et souhaite importer à nouveau, il tout d'abord supprimer le module par

del(mon_fichier)

puis importer à nouveau.

3. Feuiller à l'indentation : les blocks de code se distinguent les uns des autres par le niveau d'indentation.
4. Il est important de rédiger une aide pour chaque fonction. Par la suite, l'aide d'une fonction peut être
affichée par

help(hello_word)
Ma première fonction avec argument

def bonjour(nom = ""):

'''
Aide
====
Dire bonjour à 'nom'.

Arguments:
----------
nom : le nom de celui à qui dire bonjour. La valeur par défaut est "".

Sortie:
-------
Aucune sortie.
'''
if len(nom) == 0:
nom = "Mme ou Mr"
print("Bonjour {}!".format(nom))
return

bonjour()
bonjour("Toussile")

Commentaires sur les valeurs par défaut!

Nombre indéderminé d'arguments récupérés dans une liste

def parametres(*param):
'''
Les paramètres sont renseignés séparés par des virgules.
'''
for idx, x in enumerate(param):
print("param[{}] = {}".format(idx, x))
return

Exemple :

parametres("bonjour", "Mr", "Mme", "Mle")

Autre exemple

def ma_fiche(prenom, nom, *reste):

'''
Paramètres obligatoires: prenom et nom
Paramètres facultatif: reste
'''
for idx, x in enumerate(reste):
print("param[{}] = {}".format(idx, x))
return (prenom + " " + nom)

Sans argument supplémentaire

print(ma_fiche("Jean", "Pierre"))

Avec paramètres supplémentaires

print(ma_fiche("Licence", "Master", "Doctorat", "Dr"))

In [15]: def dictionnaire(** param):

'''
Récupérer un dictionnaire et afficher les valeurs
'''
for key, value in param.items():
print("param['{}'] = {}".format(key, value))
return

dict = {"a":1, "b":2, "c":3}

dictionnaire(**dict)

param['b'] = 2
param['c'] = 3
param['a'] = 1
 In [12]: import numpy as np

def my_norm(**args):
if len(args) == 0:
return(np.random.normal(loc = 0, scale = 1, size = 1))
if len(args) == 1:
return(np.random.normal(loc = args["mu"], scale = 1, size = 1))
if len(args) == 2:
return(np.random.normal(loc = args["mu"], scale = args["std"], size
= 1))
if len(args) == 3:
return(np.random.normal(loc = args["mu"], scale = args["std"], size
= args["n"]))
else:
print("Invalide argument!")
return

In [15]: my_norm(std = 1, n = 5, mu = 0)

Out[15]: array([-0.08592087, 0.12866117, -0.7650374 , -0.13020987, 0.07763123])

Portée des variables

Une variable déclarée à la racine d'un module est visible dans tout ce module. On parle alors de variable
globale au module.
Une variable déclarée dans une fonction ne sera visible que dans cette fonction. On parle alors de
variable locale.
Les listes se comportent différemment : une liste en argument d'une fonction se comporte comme une
référence.

In [13]: x = 2

def ajouter_x_a(a):
x = a
print("Valeur locale de x = {}.".format(x))
return(a)

ajouter_x_a(5)
print("Valeur globale de x = {}.".format(x))

Valeur locale de x = 5.
Valeur globale de x = 2.

Les classes

Python est un langage qui permet la programmation orientée objet (POO).

La POO sous Python est flexible.
Brève introduction à la POO

La notion de classe va en quelque sorte permettre de généraliser la notion de type afin de créer de
nouvelles structures de données.
Une classe définit des attributs et des méthodes.
Un objet est une instance d'une classe.
Exemple

class Point:
'''
Classe Point
============
Point géométrique dans le plan muni d'un repère orthonormé.
'''

def __init__(self, x = 0, y = 0):

self.x = x
self.y = y
return

# Instanciation d'un objet de type Point

A = Point()
B = Point(1, 2)
print("B.x = {}, B.y = {}".format(B.x, B.y))

Les attributs sont publiques (on peut les rendre privés par le biais des properties).
Exemple de classe (Suite)

class Point:
'''
Point géométrique dans le plan muni d'un repère orthonormé.
'''
def __init__(self, x = 0, y = 0):
'''
Construteur
'''
self.x = x
self.y = y
return

def __str__(self):
'''
Une méthode utilisée par la fonction 'print'
'''
return("A.x = " + str(self.x) + ", A.y = " + str(self.y))

def deplacer(self, dx, dy):

self.x = self.x + dx
self.y = self.y + dy
return

# Instanciation d'un objet de type Point

A = Point() # Sans argument
B = Point(1, 2) # Avec arguments
print(A) ; print(B)
Rendre des attributs privés

class Point:
'''
Point géométrique dans le plan muni d'un repère orthonormé.
'''
def __init__(self, x = 0, y = 0):
'''
Construteur
'''
self.__x = x
self.y = y
return

def __str__(self):
'''
Une méthode utilisée par la fonction 'print'
'''
return("A.__x = " + str(self.__x) + ", A.y = " + str(self.y))

def deplacer(self, dx, dy):

self.__x = self.__x + dx # On peut aussi écrire self.__x += dx
self.y = self.y + dy
return

B = Point(1, 2) # Instanciation
B.deplacer(3, 5.5) # deplacer le point à l'aide de la méthode 'deplacer'
print(B.__x) # N'est plus publique
print(B.y) # Est toujours publique
Les properties pour encapsuler des attributs

class Point:
'''
Point géométrique dans le plan muni d'un repère orthonormé.
'''
def __init__(self, x = 0, y = 0):
'''
Construteur
'''
self.__x = x
self.y = y
return

@property
def x(self):
return(self.__x) # Get self.__x

@x.setter
def x(self, x): # Set self.__x
self.__x = x
return

def __str__(self):
'''
Une méthode utilisée par la fonction 'print'
'''
return("__x = " + str(self.__x) + ", y = " + str(self.y))

def deplacer(self, dx, dy):

self.__x = self.__x + dx # On peut aussi écrire self.__x += dx
self.y = self.y + dy
return

A = Point(1,2)
print(A.x) # Afficher l'attribut __x
A.x = 10 # Modifier l'attribut __x
Les modules et les packages en python

Nous avons réussi jusqu'à présent à créer des petits morceaux de code sans grand intérêt car très peu
ambitieux. Le problème de l'interpréteur c'est qu'une fois celui-ci fermé votre travail est perdu.
L'idée d'un programme c'est d'enregistrer votre travail dans un fichier et ensuite de l'exécuter. Cela
augmente votre productivité mais possède de nombreux avantages comme le copier-coller massif ou tout
simplement le travail collaboratif.
Lorsque du code est enregistré dans un fichier exécutable on parle de script.

Créer son premier script python

Tout d'abord vous devez créer un fichier avec l'extension .py

Dans notre exemple on le nommera fiche.py
Dans le dossier que vous voulez (l'emplacement n'a aucune importance).
Ouvrez ensuite le fichier.
Ajouter les lignes suivantes :

#!/usr/bin/python3.5
#-*- coding: utf-8 -*-
print("Bonjour Mr ou Mme")

La première ligne indique qu'il s'agit de code python.

La deuxième ligne indique le type d'encodage utilisé. Je vous conseille toujours quelque soit votre
projet et votre langage de programmation de passer par de l'UTF-8 et la troisème ligne vous
connaissez déjà.
Exécuter un script python à partir d'un terminal

python /chemin_vers_votre_script/fiche.py

Importer des fonctions d'autres fichiers

Pour les projets les plus ambitieux il sera vite important d'organiser son travail.
Les fonctions vont se multiplier et il faudra les enregistrer dans des fichiers distincts pour plus de
flexibilité.
Créons un autre fichier que nous nommons 'fonctions.py' dans le même dossier que le fichier 'fiche.py'
 Créons un autre fichier que nous nommons 'fonctions.py' dans le même dossier que le fichier 'fiche.py'

#!/usr/bin/python3.5
#-*- coding: utf-8 -*-

def dire_bonjour(nom):
'''
Donner votre nom et je vous gentillement bonjour.
'''
print("Bonjour Mr ou Mme {}!".format(nom))
return

def addition(x, y):

'''
Additionner deux nombres.
'''
return(x+y)

Enregistrer le fichier et importer dans un autre fichier ou à la console par

Toutes les fonctions du fichier :

from func import *

Juste la fonction 'addition'

from func import addition

Instructions, fonctions, modules, packages

L'orsqu'on regroupe des fonctions dans un fichier on appelle le fichier "module".

Lorsqu'on regroupe des modules, on parle de "package".

Créer un package

1. Créer un dossier portant le nom de votre package. Dans notre exemple, nous le nommerons
"monPackage". Faites le par exemple dans le même dossier que celui contenant les fichiers précédents.
2. Dans ce dossier, créer fichier fichier nommé 'init.py', cela indique à python qu'il s'agit d'un package. Ce
fichier peut être vide, seule sa présence est importante.
3. Créer un "module" nommé 'operations.py' dans le dossier 'monPackage'.
4. Éditer le fichier 'operations.py' et ajouter :
Créer un package (suite)

#!/usr/bin/python3.5
#-*- coding: utf-8 -*-

def addition(x, y):

'''
Addition de deux nombres.
'''
return(x + y)

def produit(x, y):

'''
Produit de deux nombres.
'''
return(x*y)

1. Importer une fonction du package

import monPackage
from monPackage.operations import addition

Les modules de python

La liste des principaux modules :

NumPy (http://www.numpy.org/) : package pour l'algèbre linéaire.

Pandas (https://pandas.pydata.org/) : package pour la manipulation des données statistiques.
matplotlib (https://matplotlib.org/) : package pour les figures
random (https://docs.python.org/2/library/random.html) : fonctions permettant de simuler des valeurs
aléatoires.
math (https://docs.python.org/2/library/math.html?highlight=math#module-math) : toutes les fonctions
utiles pour les opérations mathématiques (cosinus,sinus,exp,etc...).
sys (https://docs.python.org/2/library/sys.html?highlight=sys#module-sys) : fonctions systèmes.
os (https://docs.python.org/2/library/os.html?highlight=os#module-os) : fonctions permettant d'interagir
avec le système d'exploitation.
time (https://docs.python.org/2/library/time.html?highlight=time#module-time) : fonctions permettant de
travailler avec le temps.
calendar (https://docs.python.org/2/library/calendar.html?highlight=calendar#module-calendar) : fonctions
de calendrier
profile (https://docs.python.org/2/library/profile.html?highlight=profile#module-profile) : fonctions
permettant d'analyser l'execution des fonctions
Module NumPy (http://www.numpy.org/)

La bibliothèque NumPy (http://www.numpy.org/) permet d’effectuer des calculs numériques avec Python. Elle
introduit une gestion facilitée des tableaux de nombres.

Il faut au départ importer le package numpy avec l’instruction suivante :

import numpy as np

Les bases

In [17]: # Importer le module

import numpy as np

# Des variables prédéfinies

print("pi = {}.".format(np.pi))

# Type de base : array = Tableau d'éléments de base de même type

a = np.array([0,3,4,6,8, 10]) # A partir d'une liste
print("Contenu de a = {}. type(a) = {}. Les dimensions de a = {}".format(a,
type(a), a.shape))
print("Changer de dimension en (3,2):\n a = {}".format(a.reshape(3, 2)))

#Tableau de dimension 2
b = np.array([[1, 2, 3], [4, 5, 6]])
print("b = {} ; dim(b) = {}".format(b, b.shape))

# np.mat : créer uns matrice

np.matrix(a.reshape(2, 3))

pi = 3.141592653589793.
Contenu de a = [ 0 3 4 6 8 10]. type(a) = <class 'numpy.ndarray'>. Les
dimensions de a = (6,)
Changer de dimension en (3,2):
a = [[ 0 3]
[ 4 6]
[ 8 10]]
b = [[1 2 3]
[4 5 6]] ; dim(b) = (2, 3)

Out[17]: matrix([[ 0, 3, 4],

[ 6, 8, 10]])
In [18]: di.display_html("<p>numpy.linspace(start, end, n) tableau 1D de 'n' éléments
de 'start' à 'end'</p>", raw = True)
print(np.linspace(0, 10, 20))

di.display_html("<p>numpy.arange(start, end, by)</p>", raw = True)

print(np.arange(0, 10, 0.5))

di.display_html("<p>Appliquer une fonction à un array</p>", raw = True)

x = np.arange(0, 10, 0.5)
y = np.sin(x)
print(y)

numpy.linspace(start, end, n) tableau 1D de 'n' éléments de 'start' à 'end'

[ 0. 0.52631579 1.05263158 1.57894737 2.10526316

2.63157895 3.15789474 3.68421053 4.21052632 4.73684211
5.26315789 5.78947368 6.31578947 6.84210526 7.36842105
7.89473684 8.42105263 8.94736842 9.47368421 10. ]

numpy.arange(start, end, by)

[ 0. 0.5 1. 1.5 2. 2.5 3. 3.5 4. 4.5 5. 5.5 6. 6.5 7.

7.5 8. 8.5 9. 9.5]

Appliquer une fonction à un array

[ 0. 0.47942554 0.84147098 0.99749499 0.90929743 0.59847214

0.14112001 -0.35078323 -0.7568025 -0.97753012 -0.95892427 -0.70554033
-0.2794155 0.21511999 0.6569866 0.93799998 0.98935825 0.79848711
0.41211849 -0.07515112]

In [19]: di.display_html("<h4>Attention à l'affection!</h4>", raw = True)

x = np.arange(0,10)
print("x = {}".format(x))

y = x # Attention : c'est juste une autre vue de x

print("y = {}".format(y))

y[0:5] = 0 # Modification de valeurs aux indices 0, 1, 2, 3, 4

print("Nouveau y = {}".format(y))
print("Nouveau x = {}".format(x))

di.display_html("<h4>Copier un tableau</h4>", raw = True)

z = x.copy() # Copie
x[0:10] = 1
print("Nouveau x = {}".format(x))
print("z = {}".format(z))

Attention à l'affection!
x = [0 1 2 3 4 5 6 7 8 9]
y = [0 1 2 3 4 5 6 7 8 9]
Nouveau y = [0 0 0 0 0 5 6 7 8 9]
Nouveau x = [0 0 0 0 0 5 6 7 8 9]

Copier un tableau
Nouveau x = [1 1 1 1 1 1 1 1 1 1]
z = [0 0 0 0 0 5 6 7 8 9]
 In [20]: di.display_html("<h5>Produit matriciel</h5>", raw = True)
M = np.matrix([[1,2], [3,4]])
b = np.matrix(np.arange(0,2).reshape(2, 1))
print("M*b = {}".format(M*b))
print("M.dot(b) = {}".format(M.dot(b)))

di.display_html("<h5>Inverser une matrice</h5>", raw = True)

print("numpy.linalg.inv(M) = {}".format(np.linalg.inv(M)))

Produit matriciel
M*b = [[2]
[4]]
M.dot(b) = [[2]
[4]]

Inverser une matrice

numpy.linalg.inv(M) = [[-2. 1. ]
[ 1.5 -0.5]]

Autres opérations

import numpy as np
from numpy import linagl # Module pour l'Algèbre linéaire

A = np.array([[1.0, 2.0], [3.0, 4.0]]) # Tableau 2x2

M = np.matrix(A) # Matrix 2x2
b = np.matrix(np.array([1,2]).reshape(2,1)) # Matrice 2x1

linalg.det(M) # Déterminent de M
linalg.trace(M) # Trace de M
M.transpose() # Transposée de M
linalg.inv(M) # Inverse de M
linalg.eig(M) # Valeurs propres et vecteurs propres
linalg.solve(M,b) # Résolution du système linéaire MX = b
Package matplotlib (https://matplotlib.org/index.html)

Introduction

Package permettant de tracer des graphiques

Deux façons de l'utiliser :

- Approche objet : plus compliquée, mais plus évoluée.

- Via des appels de fonctions, avec pyplot : plus simple. pyplot fournit ain
si des raccourcis qui évitent la formulation objet plus longue à écrire.

Permet de faire des graphes qui peuvent être comlètement adaptés si besoin. Sur une figure, on peut
tracer plusieurs graphes.
permet aussi de dessiner.
matplotlib rend ainsi possible la création de graphes à l'intérieur d'applications complexes autorisées par
le langage python, et ceci sans quitter le langage python.

Notions principales pour les graphes sous matplotlib (https://matplotlib.org/index.html)

figure : peut être sauvée dans un fichier.

axe : un graphe (graphique) individuel appartenant à une figure qui peut en compter plusieurs. Attention,
ce n'est pas un axe de coordonnées !
axis : un axe de coordonnées appartenant à un objet axe.
divers objets graphiques qui dérivent de la classe Artist et qui participent au graphe. Ce sont par exemple
des rectangles, des lignes, du texte. Ces différents objets peuvent être totalement configurés (y compris
individuellement) pour adapter le graphe aux besoins en appelant dessus des méthodes pour modifier
leurs propriétés !
In [3]: import matplotlib.pyplot as plt # Importation
import IPython.core.display as di
import numpy as np

di.display_html("<h5>Notre premier graphique</h5>", raw = True)

x = np.linspace(-5, 5, 100)
y_sin = np.sin(x)
y_cos = np.cos(x)

plt.plot(x, y_sin, color = "steelblue", linewidth = 2, linestyle = "--", lab

el='sin')
plt.plot(x, y_cos, color = "red", linewidth = 2, linestyle = "-", label='co
s')
plt.grid()
plt.legend()
plt.title("Les fonctions sin et cos")
plt.show()

Notre premier graphique

In [22]: di.display_html("<h5>My first barplot</h5>", raw = True)
N = 5
menMeans = (20, 35, 30, 35, 27)
womenMeans = (25, 32, 34, 20, 25)
menStd = (2, 3, 4, 1, 2)
womenStd = (3, 5, 2, 3, 3)
ind = np.arange(N) # the x locations for the groups
width = 0.35 # the width of the bars: can also be len(x) sequence

p1 = plt.bar(ind, menMeans, width, yerr=menStd, color = "steelblue")

p2 = plt.bar(ind, womenMeans, width, bottom=menMeans, yerr=womenStd, color =
"pink")

plt.ylabel('Scores')
plt.title('Scores by group and gender')
plt.xticks(ind, ('G1', 'G2', 'G3', 'G4', 'G5'))
plt.yticks(np.arange(0, 81, 10))
plt.legend((p1[0], p2[0]), ('Men', 'Women'))

plt.show()

My first barplot
In [23]: di.display_html("<h5>My first pie</h5>", raw = True)
labels = ['Frogs', 'Hogs', 'Dogs', 'Logs']
fracs = [15, 30, 45, 10]

explode = (0, 0.05, 0, 0)

plt.pie(fracs, explode=explode, labels=labels, autopct='%.0f%%', shadow=True

)
plt.show()

My first pie

In [24]: di.display_html("<h5>Deux graphes dans une figure</h5>", raw = True)

x = np.linspace(-5, 5, 100)

plt.figure(1) # Une figure

plt.subplot(211) # 2 lignes, 1 colonne, graphe 1
plt.plot(x, np.sin(x), color = "steelblue", linewidth = 2, label = "sin")
plt.legend()

plt.subplot(212)
plt.plot(x, np.cos(x), color = "red", linewidth = 2, label = "cos")
plt.legend()
plt.show()

Deux graphes dans une figure

Histogramme

In [25]: import random # Package pour simuler selon certaines loi de probabilité

x = np.array([random.gauss(0, 1) for i in range(1000)]) #Simuler 100 N(0,1)

plt.hist(x, bins = 20, color = "coral")
plt.title("Histogramme")
plt.grid()
plt.show()
In [18]: import numpy as np
from matplotlib import cm
import matplotlib.pyplot as plt
from mpl_toolkits import mplot3d

def f(x, y):

return np.sin(np.sqrt(x ** 2 + y ** 2))

x = np.linspace(-6, 6, 30)
y = np.linspace(-6, 6, 30)

X, Y = np.meshgrid(x, y)
Z = f(X, Y)

fig = plt.figure(figsize=(19,6))
ax = fig.add_subplot(1, 2, 2, projection='3d')
p = ax.plot_surface(X, Y, Z, rstride=1, cstride=1, cmap=cm.coolwarm, linewid
th=0, antialiased=False)
cb = fig.colorbar(p, shrink=0.75)

ax.set_xlabel('x')
ax.set_ylabel('y')
ax.set_zlabel('z')
plt.show()
Un autre package pour les graphiques : Seaborn
(https://seaborn.pydata.org/)

Seaborn est une bibliothèque pour créer des graphiques statistiques attrayants et informatifs en Python.
Il est construit au-dessus de matplotlib (https://matplotlib.org/) et étroitement intégré avec la pile PyData
(https://pydata.org/downloads.html), y compris le support des structures de données NumPy
(http://www.numpy.org/) et pandas (https://pandas.pydata.org/) et des routines statistiques de scipy
(https://www.scipy.org/) et statsmodels (http://www.statsmodels.org/stable/index.html).
Plusieurs thèmes intégrés pour le stylisme des graphiques matplotlib
Des outils pour choisir des palettes de couleurs
Des fonctions de visualisation de distributions univariées et bivariées ou de comparaison entre sous-
ensembles de données
Des outils pour adapter et visualiser les modèles de régression linéaire pour différents types de variables
indépendantes et dépendantes
Des fonctions qui visualisent des matrices de données et utilisent des algorithmes de clustering pour
découvrir la structure de ces matrices
Une fonction pour les graphiques des séries chronologiques avec une estimation flexible et une
représentation de l'incertitude autour de l'estimation
Des abstractions de haut niveau pour structurer des grilles de tracés qui vous permettent de construire
facilement des visualisations complexes.

Boxplot et Violinplot

In [45]: import seaborn as sns # Importer la librairie

data = np.random.normal(size=(20, 6)) + np.arange(6) / 2 # Données simulées

sns.set_style("whitegrid") # Possibilité de choix du style

sns.boxplot(data=data)
plt.show()
 In [46]: # Violinplot

sns.violinplot(data=data)
sns.despine(offset=10, trim=True)
plt.show()

Plot d'une régression linéaire

 In [47]: sns.set(style="darkgrid", color_codes=True) # Le style

tips = sns.load_dataset("tips") # Charger un jeu de données existant

g = sns.jointplot("total_bill", "tip", data=tips, kind="reg",\

xlim=(0, 60), ylim=(0, 12), color="r", size=7)

PairPlot
 In [48]: sns.set(style="ticks")

iris = sns.load_dataset("iris") # Données iris

sns.pairplot(iris, hue="species")
plt.show()

Barplots pour un facteur

 In [49]: sns.set(style="whitegrid")

# Load the example Titanic dataset

titanic = sns.load_dataset("titanic")

# Draw a nested barplot to show survival for class and sex

g = sns.factorplot(x="class", y="survived", hue="sex", data=titanic,
size=6, kind="bar", palette="muted")
g.despine(left=True)
g.set_ylabels("survival probability")
plt.show()

Package Pandas (https://pandas.pydata.org/)

A fast and efficient DataFrame object for data manipulation with integrated indexing;
Tools for reading and writing data between in-memory data structures and different formats: CSV and text
files, Microsoft Excel, SQL databases, and the fast HDF5 format;
Intelligent data alignment and integrated handling of missing data: gain automatic label-based alignment
in computations and easily manipulate messy data into an orderly form;
Flexible reshaping and pivoting of data sets;
Time series-functionality: date range generation and frequency conversion, moving window statistics,
moving window linear regressions, date shifting and lagging. Even create domain-specific time offsets and
join time series without losing data;
Intelligent label-based slicing, fancy indexing, and subsetting of large data sets;
Python with pandas is in use in a wide variety of academic and commercial domains, including Finance,
Neuroscience, Economics, Statistics, Advertising, Web Analytics, and more.
...
Structures de données

Structure de
Dimension Description
données

Series 1 1D labeled homogeneous array, sizeimmutable.

General 2D labeled, size-mutable tabular structure with potentially heterogeneously

DataFrame 2
typed columns.

Panel 3 General 3D labeled, size-mutable array.

First operations

import pandas as pd

s = pd.Series([1,2,3,np.nan,6,7]) # A Series from a list

dates = pd.date_range('20171225', periods=10) # 6 dates from 25/12/2017

df = pd.DataFrame(np.random.randn(10,4), index=dates, columns=list('ABCD')) # N

(0,1)
df.head(5) # See the first 5 lines
df.tail(3) # See the lats 3 lines

df.dtypes # See the different types of columns

df.index # The indexes

df.columns # Nmes of columns

df.describe() # Description statistics

df.T # Transposing the DataFrame

First operations

df1 = pd.DataFrame({'A' : ['foo', 'bar', 'foo', 'bar',

'foo', 'bar', 'foo', 'foo'],
'B' : ['one', 'one', 'two', 'three',
'two', 'two', 'one', 'three'],
'C' : np.random.randn(8),
'D' : np.random.randn(8)}) # Another DataFrame

df1['A'] # Get Series of the colum named 'A'

df1.groupby('A').sum() # Sum of numeric columns grouped by categories in 'A'

df1.groupby(['A','B']).mean() # Mean of numeric columns grouped by categories in

'A'*'B'

Pour d'autres opérations, voir ici (http://pandas.pydata.org/pandas-docs/stable/10min.html).

Séries temporelles
In [50]: ts = pd.Series(np.random.randn(1000), index=pd.date_range('1/1/2000', period
s=1000))

ts = ts.cumsum() # Marche aléatoire gaussienne

plt.figure(figsize=(10, 6))
ts.plot(color = "coral")
plt.show()

In [51]: # Simulation de 4 marches aléatoires gaussiennes

# Les index sont ceux de ts précédent
df = pd.DataFrame(np.random.randn(1000, 4), index=ts.index, columns=['A',
'B', 'C', 'D'])
df = df.cumsum()

plt.figure(figsize=(10, 6)); df.plot(); plt.legend(loc='best')

plt.show()

<matplotlib.figure.Figure at 0x7fb3ece31588>
Module Scikit-Learn (http://scikit-
learn.org/stable/index.html)

Librairie Python dédiée à l'apprentissage automatique (App. Statistique, Machine learning) :

Modèles linéaires généralisés, ridge, lasso
CART (Classification and Regresison Tree)
Forêts aléatoires
Machines à vecteurs de support
Algo des k-plus proches voisins
K-means, Agglomerative clustering, Gaussian mixture, Spectral clustering
Analyse en Composantes Principales (ACP)
Sélection de modèles
...

Exemple de régression linéaire

 In [52]: import sklearn
from sklearn import linear_model
from sklearn import datasets
from sklearn.model_selection import cross_val_predict

boston = datasets.load_boston()
X = pd.DataFrame(boston.data, columns = boston.feature_names)
y = np.array(boston.target)

print("Dimensions du jeu de données boston = {}".format(X.shape))

lm = linear_model.LinearRegression()
predicted = cross_val_predict(lm, boston.data, y, cv=10)# Par validation cro
isée 10-folds
R2 = lm.fit(X, y).score(X, y) # Sur toutes les données

xx = np.linspace(0, 50, 100)

plt.scatter(y, predicted, color = "coral", edgecolors="coral")
plt.plot(xx, xx, color = "coral")
plt.text(0, 50, "R2 = " + str(R2))
plt.xlabel("y"); plt.ylabel("predicted y")
plt.show()

Dimensions du jeu de données boston = (506, 13)

Exemple de régression avec l'algo des k-nn

Données simulées suivant :

$Y_i = \ln\left(2*X_i\right) + \epsilon_i$ avec $\epsilon_i\sim\mathcal{N}\left(0,1\right)$
Où $X_i\sim\mathcal{U}_{[0,10]}$
Illustration de la sélection du nombre de voisins
In [53]: from sklearn import neighbors, datasets, metrics
from sklearn.model_selection import train_test_split
from prettytable import PrettyTable

def f(x):
return(2*np.log(2*x))

n = 200
X = np.array([np.random.uniform(1, 30) for i in range(n)])
y = f(X) + np.random.normal(0, 0.25, n)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.4)

X_train = np.c_[X_train] ; X_test = np.c_[X_test]

k_grid = np.arange(2, 25)
accuracy_train = np.zeros(len(k_grid), float) ; accuracy_test = np.zeros(len
(k_grid), float)
regressors = [neighbors.KNeighborsRegressor(n_neighbors = k).fit(X_train, y_
train) for k in k_grid]
i = 0
for reg in regressors:
accuracy_train[i] = metrics.mean_squared_error(y_train, reg.predict(X_tr
ain))
accuracy_test[i] = metrics.mean_squared_error(y_test, reg.predict(X_test
))
i += 1

idx_best = accuracy_test.argmin()
 In [54]: xx = np.arange(1, 30, 0.1)
yy = regressors[idx_best].predict(np.c_[xx])

fig, (axe1, axe2) = plt.subplots(1, 2, figsize = (15,6))

axe1.scatter(X_test.ravel(), y_test, color = "steelblue", label = "Scatter o
f train data")
axe1.plot(xx, f(xx), color = "steelblue", label = "Target function")
axe1.plot(xx, yy, color = "coral", label = "Estimated")
axe1.legend(loc = "best")

axe2.plot(k_grid, accuracy_train, color = "steelblue", label = "On train dat

a")
axe2.plot(k_grid, accuracy_test, color = "coral", label = "On test data")
axe2.axvline(k_grid[idx_best], color = "grey", label = "Best k = " + str(k_g
rid[idx_best]), linewidth = 0.5)
axe2.legend(loc = "best")

plt.show()
plt.close()

Exemple de classification supervisée

Jeu de données iris

D'abord une vusualisation des données
Les classifieurs testés : LDA, QDA, 10-nn et l'arbre de classification.
In [30]: import sklearn
from sklearn import datasets
import pandas as pd
import seaborn as sns

iris = datasets.load_iris()
tab = pd.DataFrame(iris.data, columns = iris.feature_names)
tab["species"] = iris.target

sns.pairplot(tab, hue = "species")

plt.show()
 In [32]: from sklearn.discriminant_analysis import LinearDiscriminantAnalysis
from sklearn.discriminant_analysis import QuadraticDiscriminantAnalysis
from sklearn import neighbors, tree, datasets, metrics
from sklearn.model_selection import train_test_split
from prettytable import PrettyTable

iris = datasets.load_iris()
X_train, X_test, y_train, y_test = train_test_split(iris.data, iris.target,
test_size = 0.3)

classifiers_names = np.array(["LDA", "QDA", "10-nn", "Tree"], str)

classifiers = [LinearDiscriminantAnalysis(), QuadraticDiscriminantAnalysis
(), \
neighbors.KNeighborsClassifier(n_neighbors = 10),\
tree.DecisionTreeClassifier()]
accuracies = PrettyTable(["Classifier", "Accuracy"])
for idx, clf in zip(classifiers_names, classifiers):
clf.fit(X_train, y_train)
accuracy = metrics.accuracy_score(y_test, clf.predict(X_test))
accuracies.add_row([idx, accuracy])

di.display_html(accuracies.get_html_string(), raw = True)

Classifier Accuracy

LDA 1.0

QDA 1.0

10-nn 0.933333333333

Tree 0.911111111111

Réduction de la dimension : ACP

Application sur le jeu de données 'digits' du package 'sklearn'

In [33]: from sklearn import datasets
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
from numpy import random
digits = datasets.load_digits()
X = digits.data; y = digits.target; images = digits.images
digits_pd = pd.DataFrame(np.c_[X, y])
idx = np.random.randint(0, X.shape[0], 100)

plt.figure(figsize=(10,10))
f, axes = plt.subplots(10, 10)
for i, ax in enumerate(axes.reshape(100)):
ax.imshow(images[idx[i]])
ax.axis('off')

plt.show()
plt.close()

<matplotlib.figure.Figure at 0x7fb3f45ee940>
In [34]: from sklearn.decomposition import PCA
from sklearn.preprocessing import scale # Pour centrer et réduire
import seaborn as sns

#np.random.seed(42)
data = scale(digits.data)
pca = PCA(n_components=2); pca.fit(data)
data_pca = pca.fit_transform(data)

data_pd = pd.DataFrame(np.c_[data_pca, digits.target], columns = ["pca1", "p

ca2", "digits"])

groups = data_pd.groupby('digits')

# Plot
plt.figure(figsize=(10, 10))
for name, group in groups:
plt.plot(group.pca1, group.pca2, marker='o', linestyle='', ms=12, label=
name)
plt.legend(loc = "best")

plt.show()
Classification non-supervisée (clustering)

Reprenons les données 'digits' et considérons les deux axes prinipaux de l'ACP précédente.
Nous appliquons l'algorithme Kmeans.

In [35]: from sklearn import metrics

from sklearn.cluster import KMeans
n_digits = 10
kmeans = KMeans(init='k-means++', n_clusters=n_digits, n_init=10)
kmeans.fit(data_pca)

Out[35]: KMeans(algorithm='auto', copy_x=True, init='k-means++', max_iter=300,

n_clusters=10, n_init=10, n_jobs=1, precompute_distances='auto',
random_state=None, tol=0.0001, verbose=0)
In [36]: # Step size of the mesh. Decrease to increase the quality of the VQ.
h = .02 # point in the mesh [x_min, x_max]x[y_min, y_max].

# Plot the decision boundary. For that, we will assign a color to each
x_min, x_max = data_pca[:, 0].min() - 1, data_pca[:, 0].max() + 1
y_min, y_max = data_pca[:, 1].min() - 1, data_pca[:, 1].max() + 1
xx, yy = np.meshgrid(np.arange(x_min, x_max, h), np.arange(y_min, y_max, h))

# Obtain labels for each point in mesh. Use last trained model.
Z = kmeans.predict(np.c_[xx.ravel(), yy.ravel()])

# Put the result into a color plot

Z = Z.reshape(xx.shape)
plt.figure(figsize=(10,10))
plt.clf()
plt.imshow(Z, interpolation='nearest',
extent=(xx.min(), xx.max(), yy.min(), yy.max()),
cmap=plt.cm.Paired,
aspect='auto', origin='lower')

#plt.plot(data_pca[:, 0], data_pca[:, 1], 'k.', markersize=2)

for name, group in groups:

plt.plot(group.pca1, group.pca2, marker='o', linestyle='', ms=12, label=
name)

# Plot the centroids as a white X

centroids = kmeans.cluster_centers_
plt.scatter(centroids[:, 0], centroids[:, 1],
marker='x', s=169, linewidths=3,
color='w', zorder=10)
plt.title('K-means clustering on the digits dataset (PCA-reduced data)\n'
'Centroids are marked with white cross')
plt.xlim(x_min, x_max)
plt.ylim(y_min, y_max)
plt.xticks(())
plt.yticks(())
plt.show()
In [ ]: