Article original : How to Get Started with Matplotlib – With Code Examples and Visualizations

L'une des tapes cls de l'analyse de donnes est la visualisation des donnes, car elle vous aide a remarquer certaines caractristiques, tendances et motifs pertinents qui peuvent ne pas tre vidents dans les donnes brutes. Matplotlib est l'une des bibliothques les plus efficaces pour Python, et elle permet de tracer des graphiques statiques, animes et interactifs.

Ce guide explore les capacits de Matplotlib, en se concentrant sur la rsolution de problmes spcifiques de visualisation de donnes et en offrant des exemples pratiques a appliquer a vos projets.

Voici ce que nous allons couvrir dans cet article :

Importance de la visualisation des donnes dans l'analyse de donnes

Supposons que vous traitez les donnes de ventes d'une grande chane de magasins. Les donnes brutes peuvent contenir des centaines ou des milliers de lignes, avec des colonnes possibles telles que les catgories de produits, les rgions de vente et les revenus mensuels. Ces concepts utiles et approches analytiques de donnes brutes prsentent les donnes de manire trs complexe, ce qui peut tre tranger pour quiconque de les entreprendre.

Cependant, en visualisant les donnes, vous pouvez avoir une vue d'ensemble de ce qui se passe probablement, comme quelle catgorie de produit russit, ou quelle rgion est a la trane.

La visualisation des donnes est un processus de transformation des donnes en des formes plus facilement comprhensibles et analysables pour la prise de dcision. Matplotlib est particulirement efficace pour rsoudre ces dfis pour les scientifiques des donnes et les analystes, grce au grand nombre de types de graphiques et d'altrations possibles qui sont disponibles.

Aperu de Matplotlib

Matplotlib, qui est maintenant l'un des logiciels de traage les plus populaires actuellement en cours d'excution dans l'environnement Python, a t initi par John Hunter en 2003. Avec lui, on peut obtenir diverses formes de graphiques statiques, dynamiques et mme animes, ce qui en fait un outil indispensable pour tout scientifique, ingnieur ou analyste de donnes.

Certains problmes courants que Matplotlib peut aider a rsoudre incluent :

  • Visualiser de grands ensembles de donnes pour identifier des motifs et des valeurs aberrantes.

  • Concevoir des graphiques complexes exemplaires pour la publication d'articles acadmiques.

  • Combiner des donnes recueillies a partir de diffrentes sources en illustrations interactives et informatives.

  • Adapter les tendances dans les graphiques pour rendre claire l'information qui est dcrite.

Commencer avec Matplotlib

Installation et configuration

Avant de nous plonger dans la cration de graphiques, installons et configurons Matplotlib. Vous pouvez installer Matplotlib en utilisant pip ou conda :

pip install matplotlib

Alternativement, si vous utilisez Anaconda :

conda install matplotlib

Pour vrifier l'installation :

import matplotlib
print(matplotlib.__version__)

Comment creer votre premier graphique

Commenons par rsoudre un problme courant : supposons que vous avez un ensemble de donnes qui enregistre la temprature quotidienne pour un mois donn, et vous voulez tudier la variation de la temprature.

Voici comment vous pouvez creer un simple graphique en ligne pour visualiser cette tendance :

import matplotlib.pyplot as plt
import numpy as np

# Simulation des donnes de temprature quotidienne
jours = np.arange(1, 20)
temperature = np.random.normal(loc=25, scale=5, size=len(jours))

plt.plot(jours, temperature, marker='o')
plt.title('Tempratures quotidiennes en aot')
plt.xlabel('Jour')
plt.ylabel('Temprature (C)')
plt.grid(True)

Un simple graphique

  • Nous avons utilis np.arange pour construire une srie de jours.

  • np.random.normal modlise les donnes de temprature avec une moyenne (loc) gale a 20 degrs Celsius et un cart-type (scale) gal a 5 degrs Celsius.

  • plt.plot cre un graphique en ligne avec des marqueurs pour chaque jour.

  • Des titres et des tiquettes ont t ajouts pour rendre le graphique informatif.

Exploration des diffrents types de graphiques

Matplotlib prend en charge divers types de graphiques, chacun adapt a des problmes spcifiques de visualisation de donnes.

Graphiques en ligne

Les graphiques en ligne sont idaux pour visualiser les tendances au fil du temps ou les donnes continues. Par exemple, suivre les ventes mensuelles d'un produit :

mois = np.arange(1, 13)
ventes = np.random.randint(2000, 4000, size=len(mois))
plt.plot(mois, ventes, color='red', linestyle='--', marker='o')
plt.title("Ventes mensuelles du produit")
plt.xlabel("Mois")
plt.ylabel("Ventes (Units)")
plt.grid(True)
plt.show()

Utilisation de graphiques en ligne pour suivre les ventes mensuelles

Graphiques de dispersion

Ils sont utiliss pour la construction de relations simples entre deux variables de donnes o l'apparence des points est compare. Par exemple, visualiser la relation entre les dpenses publicitaires et les ventes :

depenses_pub = np.random.randint(50, 1000, size=50)
ventes = depenses_pub * np.random.uniform(0.8, 1.2, size=50)

plt.scatter(depenses_pub, ventes, color='blue')
plt.title("Dpenses publicitaires vs. Ventes")
plt.xlabel("Dpenses pub (USD)")
plt.ylabel("Ventes (Units)")
plt.show()

Une reprsentation de graphique de dispersion

Graphiques a barres

Les graphiques a barres sont efficaces pour comparer des donnes catgorielles. Par exemple, visualiser le revenu total gnr par plusieurs regroupements de produits :

regroupements = ['Instruments de musique', 'Meubles', 'Vtements', 'Nourriture']
revenu = [50000, 30000, 20000, 40000]

plt.bar(regroupements, revenu, color='green')
plt.title("Revenu par regroupement de produits")
plt.xlabel("Groupe")
plt.ylabel("Revenu (EURO)")
plt.show()

Une visualisation de graphique a barres

Histogrammes

Ils sont utiliss pour voir la distribution des donnes numriques bases sur la frquence. Par exemple, visualiser la distribution des ges des clients dans une enqute :

ages = np.random.randint(18, 65, size=2000)

plt.hist(ages, bins=10, color='purple', edgecolor='black')
plt.title("Distribution des ges des participants a l'enqute")
plt.xlabel("ge")
plt.ylabel("Nombre de participants")
plt.show()

Histogramme montrant la distribution des ges des clients

Graphiques circulaires

Les graphiques circulaires sont utiliss pour afficher les pourcentages des donnes sous forme graphique. Par exemple, visualiser la part de march de diffrentes entreprises :

entreprises = ['Entreprise W', 'Entreprise X', 'Entreprise Y', 'Entreprise Z']
part_de_marche = [40, 30, 20, 10]

plt.pie(part_de_marche, labels=entreprises, autopct='%1.1f%%', colors=['blue', 'orange', 'green', 'red'])
plt.title("Part de march par entreprise")
plt.show()

Une reprsentation de graphique circulaire

Personnalisations avances des graphiques

Comment travailler avec plusieurs graphiques

Dans certaines situations, vous devrez comparer plusieurs ensembles de donnes dans une seule figure. Par exemple, comparer les tendances de vente dans diffrentes rgions. Cela peut tre ralis en utilisant des sous-graphiques :

regions = ['Nord', 'Sud', 'Est', 'Ouest']
donnees_ventes = np.random.randint(500, 5000, size=(4, 12))

fig, axs = plt.subplots(2, 2, figsize=(10, 8))
fig.suptitle('Ventes mensuelles par rgion')

for i, region in enumerate(regions):
    ax = axs[i // 2, i % 2]
    ax.plot(mois, donnees_ventes[i], marker='o')
    ax.set_title(region)
    ax.set_xlabel("Mois")
    ax.set_ylabel("Ventes (Units)")

plt.tight_layout()
plt.show()

Diagrammes de plusieurs graphiques comparant la tendance des ventes

Comment amliorer l'esthtique des graphiques

Parmi les options typiques pour le traage commun, il y a la possibilit de contrr l'apparence d'un graphique pour le rendre informatif et esthtiquement agrable.

Voici un exemple :

plt.plot(jours, temperature, color='orange', marker='x', linestyle='-')
plt.title("Tempratures quotidiennes en aot", fontsize=16)
plt.xlabel("Jour", fontsize=12)
plt.ylabel("Temprature (C)", fontsize=12)
plt.grid(True)
plt.legend(['Temprature'], loc='upper right')
plt.annotate('Jour le plus froid', xy=(5, 10), xytext=(7, 5),
             arrowprops=dict(facecolor='black', arrowstyle='->'))
plt.show()

Image montrant un graphique esthtiquement agrable

Le code change les couleurs et les marqueurs, les styles de ligne, les titres et les tiquettes des axes de la taille de police dsire, la grille active, ajoute une lgende et annote le jour le plus froid par une flche. Ces amliorations rendent le graphique informatif et soign et, par consquent, un message professionnel et clair serait transmis.

Comment sauvegarder et exporter des graphiques

Une fois que vous avez cre un graphique, vous pourriez avoir besoin de l'enregistrer dans un format spcifique pour un rapport ou une prsentation. Voici un exemple de la faon d'enregistrer des graphiques efficacement :

plt.plot(jours, temperature)
plt.title("Tempratures quotidiennes en aot")
plt.xlabel("Jour")
plt.ylabel("Temprature (C)")

# Enregistrement du graphique
plt.savefig("daily_temperatures_august.png", dpi=300, bbox_inches='tight')
plt.savefig("daily_temperatures_august.pdf", format='pdf', bbox_inches='tight')

Le paramtre dpi contrrole la rsolution du graphique enregistr, et bbox_inches='tight' garantit que le graphique est enregistr sans espace blanc supplmentaire.

Trac interactif et animation

Fonctionnalits interactives dans Matplotlib

Vous pouvez galement rendre vos graphiques interactifs. Par exemple, plutr que de visualiser un graphique entier, on pourrait se rapprocher d'une rgion d'intrt, ou lorsque le graphique doit tre modifi d'une manire ou d'une autre en raison de l'entre de l'utilisateur.

import matplotlib.pyplot as plt
import numpy as np

x = np.linspace(0, 10, 100)
y = np.cos(x)

fig, ax = plt.subplots()
ax.plot(x, y)

def on_click(event):
    # Cette fonction est appele lorsque le graphique est cliqu
    print(f"Les coordonnes ont t cliques a : ({event.xdata}, {event.ydata})")

fig.canvas.mpl_connect('button_press_event', on_click)
plt.show()

Le code gnre un graphique d'onde cosinus et dfinit un gestionnaire d'vnement de clic avec le nom on_click. Une fois que vous cliquez n'importe o sur le graphique, le gestionnaire imprime les coordonnes du clic sur la console Python.

Comment creer des animations

Les animations peuvent tre pratiques pour montrer comment les choses voluent. Par exemple, l'augmentation du prix d'une action ou la priode d'incubation d'une maladie :

import matplotlib.animation as animation

fig, ax = plt.subplots()
line, = ax.plot(x, y)

def update(frame):
    line.set_ydata(np.cos(x + frame / 10))
    return line,

ani = animation.FuncAnimation(fig, update, frames=range(100), blit=True)
plt.show()

Le code forme une onde cosinus anime, qui au fil du temps semble se dplacer horizontalement et cre une impression d'une onde se dplaant de gauche ou de droite. De telles animations peuvent galement tre utiles si les donnes doivent tre reprsentes en termes de changement avec le temps.

Comment optimiser les graphiques pour les grands ensembles de donnes

La taille de l'ensemble de donnes considr lors de la manipulation de grandes donnes est caractrise par la quantit de donnes, ainsi, l'importance de la performance doit tre exprime. Il est souvent trop lent et prend beaucoup de mmoire pour tracer de grandes quantits de donnes. Voici quelques conseils que vous devez employer pour tirer le meilleur parti de vos graphiques.

Techniques de traage efficaces pour les grands ensembles de donnes

Sous-chantillonnage

Dans ce processus, vous chantillonnez moins de points que ce que le graphique original a.

import matplotlib.pyplot as plt
import numpy as np

# Gnrer un grand ensemble de donnes
x_huge = np.linspace(0, 100, 10000)
y_huge = np.sin(x_huge) + np.random.normal(0, 0.1, size=x_huge.shape)

# Sous-chantillonner les donnes
x_downsampled = x_huge[::10]
y_downsampled = y_huge[::10]

plt.plot(x_downsampled, y_downsampled)
plt.title("Graphique sous-chantillonn")
plt.xlabel("X")
plt.ylabel("Y")
plt.show()

Une image de graphique sous-chantillonn

Avec cela, nous rduisons le nombre de points a tracer sur le graphique et traons un point aprs un intervalle de 10 points. Cela rduit la charge a rendre mais le fait sans dformer la structure gnrale des donnes.

Agrgation des donnes

L'agrgation des donnes est un processus o les donnes recueillies sous forme numrique sont regroupes en classes pour arriver a des tabulations des observations sous une classe donne.

import matplotlib.pyplot as plt
import numpy as np

# Gnrer un grand ensemble de donnes
x_huge = np.linspace(0, 100, 10000)
y_huge = np.sin(x_huge) + np.random.normal(0, 0.1, size=x_huge.shape)

# Agrger les donnes en bacs
bins = np.linspace(0, 100, 100)
y_aggregated = [np.mean(y_huge[(x_huge >= bins[i]) & (x_huge < bins[i+1])]) for i in range(len(bins)-1)]

plt.plot(bins[:-1], y_aggregated)
plt.title("Graphique agrg")
plt.xlabel("X")
plt.ylabel("Moyenne Y")
plt.show()

Une image de graphique agrg

Ce processus rduit le nombre de points de donnes ncessaires pour reprsenter la distribution des donnes, rendant le graphique plus facile a lire et a interprter tout en capturant la tendance gnrale des donnes originales.

Visualisation des donnes statistiques

Les graphiques statistiques sont utiles pour rsumer et comprendre de grands ensembles de donnes, dont certains incluent les suivants :

Graphiques en bote

Il affiche la distribution des donnes base sur un rsum en cinq nombres : minimum, premier quartile, mdiane, troisime quartile et maximum.

import matplotlib.pyplot as plt
import numpy as np

# Gnrer des donnes alatoires
data = np.random.randn(1000)
plt.boxplot(data)
plt.title("Graphique en bote")
plt.ylabel("Valeurs")
plt.show()

Une reprsentation de graphique en bote

Ils sont particulirement utiliss dans la dtection des valeurs aberrantes positionnelles et la comparaison de la dispersion et de la symtrie de deux variables.

Graphique en violon

Il emploie un graphique en bote ainsi qu'un graphique de densit pour prsenter des informations plus spcifiques concernant la distribution des valeurs des variables donnes.

import matplotlib.pyplot as plt
import numpy as np

# Gnrer des donnes alatoires
data = np.random.randn(1000)
plt.violinplot(data)
plt.title("Graphique en violon")
plt.ylabel("Valeurs")
plt.show()

Une reprsentation de graphique en violon

Les graphiques en violon peuvent tre utiliss lorsqu'il y a un besoin de reprsenter des distributions compltes.

Piges courants de visualisation et comment les viter

Sur-trac

Une valeur est rendue sur-trace lorsque de nombreuses observations sont superposes dans le mme premier plan, ce qui rend les figures dsordonnes, et les points ou motifs deviennent obscurs. Cela est particulirement courant dans les graphiques de dispersion ou les graphiques en ligne avec de grands ensembles de donnes.

import matplotlib.pyplot as plt
import numpy as np

# Gnrer un grand ensemble de donnes
x = np.random.rand(10000)
y = np.random.rand(10000)

# Tracer sans transparence (sur-trac)
plt.scatter(x, y)
plt.title("Graphique de dispersion avec sur-trac")
plt.xlabel("X")
plt.ylabel("Y")
plt.show()

# Tracer avec transparence pour rduire le sur-trac
plt.scatter(x, y, alpha=0.1)  # Dfinir alpha pour la transparence
plt.title("Graphique de dispersion avec sur-trac rduit")
plt.xlabel("X")
plt.ylabel("Y")
plt.show()

Une image de sur-trac et de sur-trac rduit

Dans le premier graphique, sans transparence, les points de donnes se chevauchent considrablement, rendant difficile l'identification de motifs ou de zones de densit. Dans le deuxime graphique, la transparence (alpha=0.1) est applique aux points de donnes, permettant aux rgions plus denses de devenir plus apparentes tout en rduisant l'encombrement. Cette technique facilite l'interprtation de la distribution des donnes du graphique.

chelles et axes trompeurs

Il est possible de choisir les chelles et les axes de manire a ce qu'ils modifient la perception globale du graphique. Les chelles trompeuses faussent l'image relle qu'un analyste obtient des donnes et conduisent a des conclusions impropres.

import matplotlib.pyplot as plt
import numpy as np

# Gnrer des donnes
x = np.arange(10)
y1 = np.random.randint(50, 100, size=10)
y2 = y1 + np.random.randint(-5, 5, size=10)

# Tracer avec un axe y tronqu
plt.plot(x, y1, label='Donnes 1')
plt.plot(x, y2, label='Donnes 2')
plt.ylim(90, 100)  # Axe y tronqu
plt.title("Graphique avec axe Y tronqu")
plt.xlabel("X")
plt.ylabel("Y")
plt.legend()
plt.show()

# Tracer avec un axe y complet
plt.plot(x, y1, label='Donnes 1')
plt.plot(x, y2, label='Donnes 2')
plt.title("Graphique avec axe Y complet")
plt.xlabel("X")
plt.ylabel("Y")
plt.legend()
plt.show()

Axe Y tronqu vs Axe Y complet

Ce qui peut tre recueilli du premier graphique est que la plage de l'axe y est fixe. Cela produit un graphique qui est assez trompeur. Le deuxime graphique utilise l'axe y complet, fournissant une reprsentation plus prcise des donnes.

Mauvaise utilisation des couleurs

Le lien quelque peu faible dans la visualisation des donnes est la faon dont les couleurs sont choisies et, plus souvent qu'autrement, utilises de manire impropre. Les problmes sont les faibles contrastes, le choix de couleurs qu'une personne daltonienne ne peut pas diffrencier, et la cration d'une importance des couleurs l o il n'y en a pas.

import matplotlib.pyplot as plt
import numpy as np

# Gnrer des donnes
x = np.linspace(0, 10, 100)
y1 = np.sin(x)
y2 = np.cos(x)

# Tracer avec une palette non adapte aux daltoniens
plt.plot(x, y1, color='red', label='sin(x)')
plt.plot(x, y2, color='green', label='cos(x)')
plt.title("Graphique avec des couleurs non adaptes aux daltoniens")
plt.xlabel("X")
plt.ylabel("Y")
plt.legend()
plt.show()

# Tracer avec une palette adapte aux daltoniens
plt.plot(x, y1, color='#0072B2', label='sin(x)')  # Bleu
plt.plot(x, y2, color='#D55E00', label='cos(x)')  # Orange
plt.title("Graphique avec des couleurs adaptes aux daltoniens")
plt.xlabel("X")
plt.ylabel("Y")
plt.legend()
plt.show()

Image mettant en vidence l'importance des couleurs

Le premier graphique emploie le rouge et le vert qui sont notoirement difficiles pour les utilisateurs avec une dficience de vision des couleurs rouge-vert. Le deuxime graphique utilise une palette adapte aux daltoniens pour s'assurer que tout le monde peut comprendre le graphique sans tre confus par les couleurs.

Utilisation trompeuse des graphiques 3D

Les graphiques 3D peuvent tre visuellement attrayants mais ajoutent souvent des complexits inutiles et peuvent tre trompeurs s'ils ne sont pas utiliss de manire approprie. Ils sont les plus efficaces lorsque la troisime dimension ajoute rellement de la valeur a la visualisation, comme lors de l'affichage de donnes multivaries. Cependant, les graphiques 3D rendent un peu difficile la comparaison des valeurs dans les graphiques.

import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d import Axes3D
import numpy as np

# Gnrer des donnes
x = np.linspace(-5, 5, 100)
y = np.linspace(-5, 5, 100)
X, Y = np.meshgrid(x, y)
Z = np.sin(np.sqrt(X**2 + Y**2))

# Graphique 3D
fig = plt.figure()
ax = fig.add_subplot(111, projection='3d')
ax.plot_surface(X, Y, Z, cmap='viridis')
plt.title("Graphique 3D")
plt.show()

# Graphique de contour 2D
plt.contourf(X, Y, Z, cmap='viridis')
plt.colorbar(label='Valeur Z')
plt.title("Graphique de contour 2D")
plt.xlabel("X")
plt.ylabel("Y")
plt.show()

Graphique 3D vs Graphique de contour 2D

Le graphique 3D aide a tracer les donnes en trois dimensions, mais il n'est pas facile de comprendre la diffrence exacte de hauteur des rgions en raison de la perspective. Le graphique de contour 2D, cependant, utilise des couleurs varies pour reflter les donnes de dimension (valeurs Z), rendant plus facile et plus prcis la comparaison des zones dans le graphique. Plus souvent qu'autrement, les graphiques 2D utiliss sont de meilleures reprsentations et plus faciles a comprendre compar aux graphiques 3D.

Utilisation trompeuse des graphiques en aires

Les graphiques en aires peuvent montrer efficacement les tendances au fil du temps ou la distribution d'un tout en parties. Cependant, ils peuvent tre confus si certaines des aires se croisent ou si le schma d'accumulation du graphique n'est pas clair.

import matplotlib.pyplot as plt
import numpy as np

# Gnrer des donnes
x = np.arange(0, 10, 1)
y1 = np.array([1, 2, 3, 4, 5, 6, 7, 8, 9, 10])
y2 = np.array([1, 3, 2, 5, 4, 6, 5, 7, 6, 8])

# Graphique en aires empiles (potentiellement trompeur)
plt.fill_between(x, y1, color='skyblue', alpha=0.5)
plt.fill_between(x, y2, color='orange', alpha=0.5)
plt.title("Graphique en aires empiles trompeur")
plt.xlabel("X")
plt.ylabel("Y")
plt.show()

# Graphique en aires amlior avec des aires non chevauchantes
plt.fill_between(x, y1, color='skyblue', alpha=0.5)
plt.fill_between(x, y1 + y2, y1, color='orange', alpha=0.5)
plt.title("Graphique en aires empiles amlior")
plt.xlabel("X")
plt.ylabel("Y")
plt.show()

Une reprsentation de l'utilisation des graphiques en aires

Dans le premier graphique en aires, les aires se chevauchent, ce qui peut crer de la confusion sur la contribution de chaque catgorie au tout. Le deuxime graphique amlior la clart en empilant les aires les unes sur les autres sans chevauchement, montrant clairement la nature cumulative des donnes.

Conclusion

Avec Matplotlib, on dispose de nombreuses fonctionnalits pour rsoudre des problmes de visualisation particuliers dans le domaine de l'analyse de donnes. Vous pouvez l'utiliser pour des graphiques en ligne, la gestion de donnes complexes, le traitement de grandes donnes, la cration de graphiques animes, et bien plus encore.

Dans ce guide, nous avons explor les aspects importants de Matplotlib et avons essay de les rapprocher de la rsolution de problmes rels que vous pourriez rencontrer dans votre travail de programmation quotidien.

Nous avons galement inclus des exemples dtaills pour soutenir ces applications. Dans quelque capacit que vous engagiez avec les donnes, que ce soit en tant que scientifique des donnes, ingnieur ou analyste, Matplotlib vous permet de raconter le rcit de vos donnes de la meilleure manire possible.