Matplotlib De quoi dessiner des courbes et débuter en Python . . .

Matplotlib
De quoi dessiner des courbes
et
débuter en Python . . .
Gilles Menez
Université de Nice – Sophia-Antipolis
email : [email protected]
www : www.i3s.unice.fr/˜menez
24 janvier 2012: V 1.1
1
Back
Previous Next First Last Back Forward Index
c G.Menez
2
2
Back
Table des matières
1
Matplotlib
1.1 Un petit exemple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
1.1.1 Au petit angle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
1.1.2 Classiquement : C et Gnuplot . . . . . . . . . . . . . . . . . . . . . .
4
4
4
5
2
Python + Matplotlib
2.1 Qui est quoi ? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
2.2 Votre travail . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
8
9
11
3
Un autre exemple simple
12
4
Un besoin ? . . . Une réponse.
4.1 ”Afficher une courbe” . . . . . . .
4.2 ”Afficher le contenu d’un fichier”
4.3 ”Afficher une image” . . . . . . .
4.4 ”Afficher en 3D” . . . . . . . . .
13
13
14
16
18
c G.Menez
.
.
.
.
TABLE DES MATIÈRES
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
3
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
Back
1
Matplotlib
Pour explorer efficacement des problèmes scientifiques traitables informatiquement, il est indispensable de pouvoir visualiser ses résultats [?].
ã Cela fait partie intégrante du processus de développement.
Python excelle en cela, car il dispose d’un excellent module de visualisation 2D : matplotlib.
ã Avoir des méthodes de visualisation intégrées au langage, sans faire appel à des outils
extérieurs comme par exemple gnuplot, est un grand gain, car il n’est plus nécéssaire de
maı̂triser un environnement hétérogène et de traduire les types de données.
ã De plus, la visualisation et le traitement informatique de données sont deux problèmes
difficilement séparables.
Pour ceux qui ont déjà été formés à Matlab, c’est
Python c’est aussi un langage.
1.1
pareil . . . du moins presque parce que
Un petit exemple
Le problème est simple, résoudre numériquement l’équation différentielle de l’équilibre dynamique d’un pendule :
θ” (t) = −(g/l) ∗ sin(θ(t))
(1)
avec
ã θ(t) est l’angle du pendule avec la verticale,
ã l = 1 la longueur de la corde,
ã et g = 9.81 la gravité.
1.1.1
Au petit angle
Si on bouscule légèrement le pendule : on lâche (donc vitesse nulle) le pendule l’instant t = 0
avec un angle initial θ0 :
θ(0) = θ0
0
θ (0) = 0
on se doute que le pendule va osciller et pour le prouver on peut s’autoriser à linéariser sin(θ(t))
par θ(t) l’équation(1) devient :
θ” (t) = −(g/l) ∗ θ(t)
On peut résoudre formellement cette équation et la solution est :
p
θ(t) = θ0 ∗ sin( g/l ∗ t + φ)
c G.Menez
(2)
4
Back
En tenant compte des conditions initiales,
θ(0) = θ0
0
θ (0) = 0
la solution exacte est :
θ(t) = θ0 ∗ cos(
p
g/l ∗ t)
(3)
Pour l’instant, il n’y a pas d’algorithme particulier à développer mais en faisant l’hypothèse que
je n’ai jamais vu la courbe d’un cos j’aimerais légitimement voir ce que donne cette résolution.
1.1.2
Classiquement : C et Gnuplot
Ce que j’appelle ”classiquement”, c’est ”en utilisant un langage de programmation n’intégrant
pas de module de visualisation” : le langage C par exemple, ou Fortran ou Java ou . . .
Attention : Il ne s’agit absolument pas de discréditer un langage quelconque mais de montrer que dans certaines situations avec un problème et des contraintes données et particulières
certains outils sont plus aisés et performants que d’autres.
ã Prétendre faire de l’informatique, c’est aussi choisir les outils adaptés au problème !
Bref, en C par exemple, pour faire cela il faut commencer par faire calculer, en échantillonnant
le temps, certains points de l’équation puis communiquer ces points à un outil externe.
ã La façon la plus simple (mais pas unique) de communiquer étant d’utiliser un fichier, on
crée un code C qui produira des valeurs dans un fichier :
#include < s t d i o . h>
#include <math . h>
#define g
9 . 8 1 / ∗ Gravite */
int main ( int argc , char ∗ argv [ ] ) {
FILE ∗ f ;
double l = 1 . 0 ; / ∗ L o n g u e u r de l a c o r d e ∗ /
f=fopen ( "datapendule.xyz" , "w" ) ;
if ( f ! = NULL ) {
double theta = M_PI / 1 0 . 0 ; / ∗ t h e t a 0 ∗ /
int N = 1 0 ;
/ ∗ S i m u l a t i o n de 10 s e c o n d e s ∗ /
double t ;
for ( t=0 ; t<N ; t += 1 . 0 / N ) / ∗ Te = 1 /N ∗ /
fprintf ( f , "%f %f\n" , t , theta∗cos ( sqrt ( g / l ) ∗ t ) ) ;
fclose ( f ) ;
}
}
c G.Menez
1.1
Un petit exemple
5
Back
Ensuite :
À On le compile,
Á On l’exécute,
 On constate que le fichier datapendule.xyz contient bien les positions (angle) du
pendule toutes les dizièmes de seconde pendant 10 secondes.
c G.Menez
1.1
Un petit exemple
6
Back
Pour afficher la courbe ainsi échantillonnée, et puisque le C n’intègre pas de module de visualisation, nous allons utiliser un excellent (mais externe) outil : gnuplot.
Comme on peut le voir sur cette capture d’écran, l’invocation de gnuplot ouvre un interpréteur de commandes gnuplot, dont ”plot” est la plus commune.
ã Il existe un trés grand nombre et une très grande variété de commandes gnuplot.
c G.Menez
1.1
Un petit exemple
7
Back
2
Python + Matplotlib
En Python, le fait que nous soyons dans un environnement (calcul/affichage) intégré permet de
regrouper dans un même script des commandes de calcul et des commandes de tracé.
# !/usr/bin/python
import math
import pylab as pl
# Calcul
g =9.81
l = 1
N = 10.0
theta = math . pi / 1 0 . 0
t = pl . linspace ( 0 , N , 1 0 0 ) # t : de 0 a N avec 100 valeurs
y = theta∗pl . cos ( math . sqrt ( g / l ) ∗ t )
#Affichage
pl . plot ( t , y , "g." )
pl . show ( )
Dès que vous avez édité le fichier python resolutionpendule.py, vous pouvez obtenir :
c G.Menez
8
Back
2.1
Qui est quoi ?
Lorsqu’on commence à utiliser les fonctions d’un langage, on est tout suite amené à mettre des
”invocations” au début des programmes.
ã Tâchons d’identifier les composants intervenant dans la fabrication du programme.
D’après http://www.scipy.org/Getting_Started,
ã Python est un langage de programmation ”general purpose”.
Il est interprété et dynamiquement typé. Il convient aussi bien à un travail interactif et à
un protoypage rapide, qu’à des applications plus importantes.
ã Numpy est une extension du langage (i.e. bibliothèque) qui définit les types (donc aussi
des opérations) tableau (numerical array) et matrice (matrix).
ã Scipy est une autre extension du langage qui utilise numpy pour proposer des fonctions
de mathématiques avancées, de traitement du signal, d’optimisation, des statistiques, . . .
ã Matplotlib est une bibliothèque python permettant de réaliser des tracés 2D/3D.
On peut générer :
á des courbes de points,
á des histogrammes,
á des nuages de points,
á des camemberts, . . .
http://matplotlib.sourceforge.net/gallery.html
Cette bibliothèque est utilisable dans des scripts python, depuis des shells python (python
et ipython) , des serveurs d’applications Web, et des GUI toolkits.
D’après http://matplotlib.sourceforge.net/faq/usage_faq.html,
matplotlib est le package (paquetage en français) global.
Les fonctions mises à disposition par ce paquetage peuvent être invoquées de plusieurs façons.
Deux seulement sont ”recommandées” :
À ” A la pyplot” :
pyplot est un module de matplotlib qui fournit une interface ”style MATLAB” à la
bibliothèque orientée-objets de matplotlib.
import matplotlib . pyplot as plt
import numpy as np
x = np . arange ( 0 , 1 0 , 0 . 2 )
y = np . sin ( x )
plt . plot ( x , y )
plt . show ( )
c G.Menez
2.1
Qui est quoi ?
9
Back
La notation pointée fait référence à l’espace de noms (namespace) de chaque package et
distingue bien les contributions de numpy et celles de pyplot.
Á ”A la pylab” :
pylab est un module de matplotlib qui combine les fonctionnalités de tracé avec celle de
numpy (pour les mathématiques et les tableaux) dans un seul espace de nom (namespace)
qui ressemble encore plus à celui de MATLAB.
from pylab import ∗
x = arange ( 0 , 1 0 , 0 . 2 )
y = sin ( x )
plot ( x , y )
show ( )
On obtient un code très synthétique qui ne fait plus référence à la notation pointée.
Vous avez donc plusieurs façon d’écrire la même chose :
ã Le choix de la compacité du code dépend de l’objectif et des contraintes : lisibilité,
compréhension, fonctions avancées . . .
Néanmoins, l’approche objet devrait être privilègiée car elle a une puissance d’expression
supérieure :
import matplotlib . pyplot as plt
import numpy as np
x = np . arange ( 0 , 1 0 , 0 . 2 )
y = np . sin ( x )
fig = plt . figure ( )
ax = fig . add_subplot ( 1 1 1 )
ax . plot ( x , y )
plt . show ( )
Par exemple, la création d’une figure, qui permettra de placer plusieurs tracés dans le même
plot, est obtenue par pyplot.
Puis, on accède aux méthodes de la figure par l’utilisation du paradigme objet : fig.add subplot(...
c G.Menez
2.1
Qui est quoi ?
10
Back
2.2
Votre travail
À Comprendre et s’approprier en refaisant les exemples sur votre machine.
Á Faire un affichage un peu joli (avec des titres par exemple) de deux pendules (avec des
cordes de longueur différentes) sur la même figure.
Ceci en ”C/gnuplot” et en ”python/matplotlib”.
c G.Menez
2.2
Votre travail
11
Back
3
Un autre exemple simple
# !/usr/bin/env python
”””
C r e a t e d on 26 j a n v . 2010
@author : menez
Example : Show how t o make and s a v e a s i m p l e
c o s i n u s p l o t WITH l a b e l s , t i t l e and g r i d .
”””
import matplotlib . pyplot as plt
import numpy as np
if __name__ == ’__main__’ :
print ’Affichage d\’une sinusoide’
t = np . arange ( 0 . 0 , 1 . 0 + 0 . 0 1 , 0 . 0 1 )
print type ( t )
print t
s = np . cos ( 2 ∗ np . pi∗t )
print type ( s )
print s
plt . plot ( t , s , "o" )
# Labels, title, grid
plt . xlabel ( ’time (s)’ )
plt . ylabel ( ’voltage (mV)’ )
plt . title ( ’About as simple as it gets, folks’ )
plt . grid ( True )
plt . savefig ( ’simple_plot’ )
plt . show ( )
c G.Menez
12
Back
4
4.1
Un besoin ? . . . Une réponse.
”Afficher une courbe”
Afficher une courbe dont on connait la définition formelle.
’’’
C r e a t e d on 16 j a n v . 2012
@author : menez
Draw a p r o b a b i l i t y d e n s i t y f u n c t i o n
: Gaussian
’’’
import matplotlib . pylab as plt
import numpy as np
import math
def imageOf ( x , mu , sigma ) :
return ( 1 . 0 / ( sigma∗math . sqrt ( 2 ∗ math . pi ) ) ) ∗ \
math . exp( −0.5 ∗ math . pow ( ( x−mu ) / sigma , 2 ) )
def imagesOf ( x , mu , sigma ) :
return ( 1 . 0 / ( sigma∗math . sqrt ( 2 ∗ math . pi ) ) ) ∗ \
np . exp( −0.5 ∗ np . power ( ( x−mu ) / sigma , np . zeros ( x . size ) + 2 ) )
if __name__ == ’__main__’ :
x = np . arange ( − 1 0 . 0 , + 1 0 . 0 , 0 . 1 )
# 1) Si le tableau est cree comme un tableau Python
y = []
for i in range ( x . size ) :
y . append ( imageOf ( x [ i ] , 0 , 1 . 0 ) )
# 2) Si le tableau est cree sous numpy
ynp = np . zeros ( ( x . size ) )
for i in range ( x . size ) :
ynp [ i ] = imageOf ( x [ i ] , 1 . 0 , 2 . 0 )
# 3) En utilisant la vectorisation ... plus de boucle !
yv = imagesOf ( x , − 3 . 0 , 3 . 0 )
# plot data
plt . figure ( )
plt . plot ( x , y , color="r" , label=’Gaussian Law 1’ )
plt . plot ( x , ynp , color="b" , label=’Gaussian Law 2’ )
plt . plot ( x , yv , color="g" , label=’Gaussian Law 3’ )
plt . title ( ’Probability Density Function’ )
plt . legend ( )
plt . show ( )
c G.Menez
13
Back
4.2
”Afficher le contenu d’un fichier”
Le programme qui suit montre comment charger des données depuis un fichier texte et tracer
une courbe.
â A analyser et à comprendre . . .
’’’
C r e a t e d on 20 s e p t . 2011
@author : menez
Example : Read from f i l e d a t a and p l o t them a s a c u r v e
’’’
import numpy as np
import pylab as pl
if __name__ == ’__main__’ :
print "Lire un fichier et tracer une courbe ..."
#Write data :
id = np . ones ( ( 3 , 3 ) )
np . savetxt ( "myfile1.txt" , id )
m=np . arange ( 1 6 )
m= m . reshape ( 4 , 4 )
np . savetxt ( "myfile2.txt" , m , fmt=’%.3e’ )
#Read :
data = np . genfromtxt ( "myfile2.txt" )
print ( type ( data ) )
print ( data ) , "\n"
print ( data [ 1 ] ) , "\n"
print ( data [ : , 2 ] ) , "\n"
# use names=True if the first row contains column names.
data = np . genfromtxt ( "myfile3.txt" , comments=’#’ )
print ( type ( data ) )
print ( data ) , "\n"
# Choose x/y and plot
x = data [ : , 0 ]
y = data [ : , 2 ]
pl . plot ( x , y )
pl . plot ( x , y , "ro" , hold=True ) # overplot with red o
pl . xlabel ( ’x’ )
pl . ylabel ( ’y = f (x)’ )
Pi=N
pl . title ( ’Mettre des formules dans les titres ...
i=1 1/N ’ )
c G.Menez
4.2
”Afficher le contenu d’un fichier”
14
Back
pl . grid ( True )
pl . savefig ( ’readfromfile’ )
# To show the plot !
pl . show ( )
avec les fichiers :
4 myfile1.txt
1 . 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 e+00 1 . 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 e+00 1 . 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 e+00
1 . 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 e+00 1 . 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 e+00 1 . 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 e+00
1 . 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 e+00 1 . 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 e+00 1 . 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 e+00
4 myfile2.txt
0 . 0 0 0 e+00
4 . 0 0 0 e+00
8 . 0 0 0 e+00
1 . 2 0 0 e+01
1 . 0 0 0 e+00
5 . 0 0 0 e+00
9 . 0 0 0 e+00
1 . 3 0 0 e+01
2 . 0 0 0 e+00
6 . 0 0 0 e+00
1 . 0 0 0 e+01
1 . 4 0 0 e+01
3 . 0 0 0 e+00
7 . 0 0 0 e+00
1 . 1 0 0 e+01
1 . 5 0 0 e+01
4 myfile3.txt
# Fichier de test
#xyz
1. 1. 1.
2. 2. 2.
3. 3. 3.
4. 4. 4.
5. 5. 5.
c G.Menez
4.2
”Afficher le contenu d’un fichier”
15
Back
4.3
”Afficher une image”
La bibliothèque PIL (Python Imaging Librairie) permet la manipulation de tout type d’images
et fournit quelques fonctions de traitement d’images de base.
http://python.developpez.com/cours/pilhandbook/
Exemple :
# !/usr/bin/env python
’’’
C r e a t e d on 19 j a n v . 2011
@author : GM f r o m
h t t p : / / m a t p l o t l i b . sourceforge . net / examples /
p y l a b e x a m p l e s / image demo3 . h t m l
’’’
import matplotlib . pyplot as plt
try :
from PIL import Image
except ImportError , exc :
raise SystemExit ( "PIL must be installed to run this example" )
if __name__ == ’__main__’ :
”””
L i r e une image d e p u i s un f i c h i e r ,
A p p l i q u e r un t r a i t e m e n t a c h a q u e p i x e l ,
c G.Menez
4.3
”Afficher une image”
16
Back
E c r i r e l ’ image d a n s un f i c h i e r .
”””
im = Image . open ( "Lena.pgm" )
print im . format , im . size , im . mode
# Process each pixel
out = im . point ( lambda i : 255 if ( i>128) else 0 )
out . save ( "Lenaout.pgm" )
”””
F a i r e a f f i c h e r une image
”””
dpi = plt . rcParams [ ’figure.dpi’ ]
figsize = im . size [ 0 ] / dpi , im . size [ 1 ] / dpi
plt . figure ( figsize=figsize )
ax = plt . axes ( [ 0 , 0 , 1 , 1 ] , frameon=False )
ax . set_axis_off ( )
im = plt . imshow ( im , cmap=plt . cm . gray , origin=’lower’ )
plt . show ( )
c G.Menez
4.3
”Afficher une image”
17
Back
4.4
”Afficher en 3D”
’’’
C r e a t e d on 17 j a n v . 2012
@author : menez
=> Drawing 3D P l o t
’’’
from mpl_toolkits . mplot3d import axes3d
from matplotlib import cm
import matplotlib . pyplot as plt
import numpy as np
def generatef ( X , Y , phi ) :
R = 1 − np . sqrt ( X∗∗2 + Y ∗ ∗ 2 )
fxy = np . cos ( 2 ∗ np . pi ∗ X + phi ) ∗ R
print type ( fxy ) , " => " , fxy . shape
return fxy
if __name__ == ’__main__’ :
plt . ion ( )
fig = plt . figure ( )
ax = axes3d . Axes3D ( fig )
xs = np . arange( −1 , 1 , 0 . 1 )
ys = np . arange( −1 , 1 , 0 . 1 )
X , Y = np . meshgrid ( xs , ys )
Z = generatef ( X , Y , 0 . 0 )
ax . plot_wireframe ( X , Y , Z , rstride = 2 , cstride = 2 )
ax . plot_surface ( X , Y , Z , rstride=1 , cstride=1 , cmap=cm . jet )
plt . draw ( )
plt . show ( )
c G.Menez
4.4
”Afficher en 3D”
18