Python-numérique - visualisation des données

introduction¶

→

https://matplotlib.org/api/pyplot_summary.html

pour se familiariser avec des données, rien ne remplace - quand elle est possible - la visualisation

nous allons voir quelques fonctionnalités de la librairie matplotlib.pyplot
ou plt par convention

pourquoi matplotlib ?
parcequ’en en 2003, des développeurs veulent une alternative à la visu sous matlab pour l’écosystème Python

elle est devenue la librairie la plus populaire pour le dataviz en Python avec

une communauté de développeurs/utilisateurs très active
les autres librairies sont, le plus souvent, dérivées de matplotlib

la syntaxe se veut simple
la librairie est très complète et très optimisée
elle peut traiter de grandes quantités de données

les fonctions ont été empaquetées afin d’être utilisées facilement en pandas

vous allez y trouver toutes les fonctions classiques:

courbes, histogrammes, box-plots, nuages de points, plot3D, grilles de figures ...
que vous allez pouvoir les personnaliser avec des textes, titres, étiquettes, légendes ...
dont vous allez pouvoir contrôler les couleurs, styles de ligne, propriétés de police ...

from matplotlib import pyplot as plt

# pour l'instant on va utiliser le mode par défaut
#%matplotlib inline

# pour changer la taille par défaut
plt.rcParams['figure.figsize'] = (4, 2)

import numpy as np
import pandas as pd

`plt.figure()`, `plt.show()`¶

→

dans ce premier notebook nous allons utiliser le driver inline - qui est le défaut

en fait il en existe plusieurs autres, et pour bien voir les différences je vous invite à consulter les deux notebooks suivants

à retenir principalement, c’est que si on voulait être complètement propre, on ferait pour chaque figure

un appel à plt.figure() au début
un appel à plt.show() à la fin

toutefois c’est trop de boilerplate, surtout quand il s’agit simplement de plotter une fonction !

du coup il est fréquent qu’on élude tout ce qui est possible, et là ça devient potentiellement confusant, car

en mode inline, ce n’est pas nécessaire de créer les figures avec plt.figure() mais il faut utiliser plt.show() si on veut afficher plusieurs figures dans la même cellule
mais en mode ipympl c’est un peu le contraire, on est incité/obligé d’utiliser plt.figure() à chaque fois, et pas vraiment besoin de plt.show()

enfin, vous noterez que df.plot() fait un appel à plt.figure() ! bref c’est un peu le bazar...

tracer une courbe avec `plt.plot`¶

→

avec matplotlib.pyplot.plot
(ou plt.plot puisqu’elle importée sous ce nom)

pour les abcisses, 50 nombres réels entre 0 et $2\pi$
linéairement espacés

x = np.linspace(0, 2*np.pi, 50)

pour les ordonnées, les sinus de ces points
vous remarquez l’application de la fonction vectorisée numpy.sin au numpy.ndarray

y = np.sin(x)

la fonction plot trace les 50 couples de points (abscisse, ordonnée) et relie les points entre eux

plt.plot(x, y)

de nombreux réglages ont pris leurs valeurs par défaut
(taille de la figure, tailles et polices des caractères, couleurs du fond et de la courbe...)

par exemple

pour voir les points en plus des segments les reliant
utilisez le paramètre marker 'o' ou '^' etc.

plt.plot(x, y, marker='s')

pour modifier l’épaisseur du trait
utilisez le paramètre linewidth

plt.plot(x, y, linewidth=5)

pour changer la couleur du trait
utilisez le paramètre color

plt.plot(x, y, color='red')

pour changer le style du trait
utilisez le paramètre linestyle
dotted, dashed...

plt.plot(x, y, linestyle='dashed')

une chaîne de caractères formattée permet de donner plus facilement ces paramètres:

plt.plot(x, y, 'r-') # ligne rouge continue
plt.show()
plt.plot(x, y, 'b.') # ligne bleue pointillée
plt.plot(x, y, 'g--') # ligne verte en traits

# le code
x = np.linspace(0, 2*np.pi, 50)
y = np.sin(x)
plt.plot(x, y); # le ; est là afin que la dernière expression du notebook (celle qui est affichée) soit None

#le code
plt.plot(x, y, marker='s');

# le code
plt.plot(x, y, linewidth=5, color='red', linestyle='dotted');

plt.plot(x, y, 'r-') # ligne rouge continue
plt.show()
plt.plot(x, y, 'b.') # ligne bleue pointillée
plt.show()
plt.plot(x, y, 'g--'); # ligne verte pointillée

attention aux valeurs manquantes¶

→

on peut ne donner que deux points
plt.plot les relie
comme ici (10, 10) à (20, 20)

plt.plot([10, 20], [10, 20])

mais attention si on ne donne qu’un point
plt.plot ne sait plus tracer de segment !

plt.plot([10], [10])
-> figure toute vide

il en est de même si des points sont manquants

exercice

créez une liste de points en alternant entiers et np.nan
par exemple

l = [10, np.nan, 20, 30, np.nan, 40, np.nan]

affichez la en abscisse et en ordonnée
que constatez-vous ?

plt.plot doit avoir des points à relier... pour qu’on voit les segments

naturellement si vous utilisez le paramètre marker
les points sont alors affichés

exercice

affichez un marker de points
(par exemple 'v'),
dans le plt.plot de l’exercice ci-dessus (avec les np.nan)

# le code
plt.plot([10, 20], [10, 20]);

# le code
plt.plot([10], [10]);

ajouter un titre `plt.title`¶

→

avec la fonction plt.title on ajoute un titre à la figure

avec son paramètre fontsize on fixe la taille des caractères

avec son paramètre loc et ses valeurs 'center', 'left' et 'right'
on positionne le titre

x = np.linspace(0, 2*np.pi, 50)
y = np.sin(x)
plt.plot(x, y)
plt.title('sinus(X)', fontsize=20, loc='left')

vous remarquez que matplotlib a la notion de figure courante
i.e. celle sur laquelle s’appliquent les fonctions
ici plt.title et plt.plot s’appliquent sur la même figure

pensez à utiliser le help

plt.title?

# le code
x = np.linspace(0, 2*np.pi, 50)
y = np.sin(x)

plt.plot(x, y)
plt.title('sinus(X)', fontsize=20, loc='left');

donner une taille à une figure¶

→

la fonction plt.figure permet

de créer une nouvelle figure ou d’en activer une existante
et aussi de passer différents paramètres à la figure courante
dont sa taille

x = np.linspace(0, 2*np.pi, 50)
plt.figure(figsize=(10, 2)) # 10 pour les abscisses et 2 pour les ordonnées
plt.plot(x, np.sin(x))

plt.figure?

# le code
x = np.linspace(0, 2*np.pi, 50)
plt.figure(figsize=(10, 2)) # 10 pour les abscisses et 2 pour les ordonnées
plt.plot(x, np.sin(x));

#plt.figure?

ajouter des labels aux axes `plt.xlabel` et `plt.ylabel`¶

→

avec la fonction plt.xlabel on ajoute un label aux abscisses de la figure

avec la fonction plt.ylabel on ajoute un label aux ordonnées de la figure

plt.xlabel('X')
plt.xlabel('Y');

naturellement les paramètre fontsize, loc... s’appliquent
et pour voir tous les paramètres

plt.xlabel?

# le code
x = np.linspace(0, 2*np.pi, 50)
y = np.sin(x)

plt.plot(x, y)
plt.xlabel('X')
plt.xlabel('Y');

#le code
#plt.xlabel?

nuages de points (`plt.scatter`)¶

→

plt.scatter permet d’afficher des points dispersés
(i.e. non reliés)

x = np.linspace(0, 2*np.pi, 50)
z = np.cos(x)
plt.scatter(x, z)

help pour plus d’information sur tous les paramètres

plt.scatter?

# le code
x = np.linspace(0, 2*np.pi, 50)
z = np.cos(x)
plt.scatter(x, z);

donner une légende à plusieurs plots sur la même figure `label`¶

x = np.linspace(0, 2*np.pi, 50)
plt.scatter(x, np.sin(x), label='sinus')
plt.scatter(x, np.cos(x), label='cosinus')
plt.legend();

fixer la limite des axes (`plt.xlim` et `plt.ylim`)¶

→

avec x = np.linspace(0, 2*np.pi, 50)
y=sin(x) est calculé entre 0 et $2\pi$

quand on demande plt.plot(x, y)
par défaut tous les couples de points $(x_i, y_i)$ sont tracés

on peut n’affiche qu’une partie des points

par exemple ici entre 0 et $\pi$ en abscisse
et 0 et 1 en ordonnées

plt.xlim(0, np.pi)
plt.ylim(0,1)
plt.plot(x, np.sin(x))

# le code
plt.xlim(0, np.pi)
plt.ylim(0,1)
plt.plot(x, np.sin(x))

préciser les ticks des axes (`plt.xticks` et `plt.yticks`)¶

→

avec plt.xtick et plt.ytick on peut donner des listes de valeurs à afficher sur les axes
ici les abscisses et les ordonnées

x = np.linspace(0, 2*np.pi, 50)
plt.xticks([0, np.pi/2, np.pi, 3*np.pi/2, 2*np.pi])  
plt.yticks([-1, -0.5, 0, 0.5, 1])
plt.plot(x, np.sin(x))

les valeurs seront espacées régulièrement sur les axes

il est possible de donner des noms aux ticks indiqués
et même d’utiliser latex

x = np.linspace(0, 2*np.pi, 50)

plt.xticks([0, np.pi/2, np.pi, 3*np.pi/2, 2*np.pi],
           [0, 'pi/2', 'pi', '3pi/2', '2pi'])

plt.plot(x, np.sin(x), label='sinus');

il est possible d’utiliser des formules latex
en markdown entre deux $ :

plt.xticks([0, np.pi/2, np.pi, 3*np.pi/2, 2*np.pi],
           [0, r'$\pi/2$', r'$\pi$', r'$3\pi/2$', r'$2\pi$'])

plt.title(r"$sin(x)$ entre $0$ et $2\pi$ ")
plt.plot(x, np.sin(x))

# le code
x = np.linspace(0, 2*np.pi, 50)

plt.xticks([0, np.pi/2, np.pi, 3*np.pi/2, 2*np.pi])
plt.yticks([-1, -0.5, 0, 0.5, 1])
plt.plot(x, np.sin(x));

# le code
x = np.linspace(0, 2*np.pi, 50)

plt.xticks([0, np.pi/2, np.pi, 3*np.pi/2, 2*np.pi],
           [0, 'pi/2', 'pi', '3pi/2', '2pi'])

plt.plot(x, np.sin(x));

# le code
plt.xticks([0, np.pi/2, np.pi, 3*np.pi/2, 2*np.pi],
           [0, r'$\pi/2$', r'$\pi$', r'$3\pi/2$', r'$2\pi$'])

plt.title(r"$sin(x)$ entre $0$ et $2\pi$ ")
plt.plot(x, np.sin(x));

x = np.linspace(0, 2*np.pi, 50)
plt.figure(figsize=(10, 2))
plt.plot(x, np.sin(x))

exercice de plot¶

%matplotlib notebook

# votre code ici

exercice sauver une figure dans un fichier¶

pour en savoir plus¶

ceux qui veulent approfondir la question liront avec intérêt ce livre en ligne très complet sur la visualisation en Python, en français

Python-numérique - visualisation des données

introduction¶

plt.figure(), plt.show()¶

tracer une courbe avec plt.plot¶

attention aux valeurs manquantes¶

ajouter un titre plt.title¶

donner une taille à une figure¶

ajouter des labels aux axes plt.xlabel et plt.ylabel¶

nuages de points (plt.scatter)¶

donner une légende à plusieurs plots sur la même figure label¶

fixer la limite des axes (plt.xlim et plt.ylim)¶

préciser les ticks des axes (plt.xticks et plt.yticks)¶