Cartes de couleurs Matplotlib : Personnaliser vos jeux de couleurs

La visualisation des données est l’une des meilleures façons (sinon la meilleure) pour les analystes et les scientifiques des données de représenter des informations complexes et de générer des insights significatifs. Pour tirer le meilleur parti de votre opportunité de communication avec les parties prenantes, j’ai compilé des informations utiles sur les colormaps de Matplotlib. 

Comme vous le verrez dans cet article, Matplotlib est une bibliothèque de visualisation extrêmement polyvalente et étendable en Python. Elle offre toutes les options, des graphiques simples aux visuels entièrement interactifs. Si vous n’êtes pas généralement familier avec Python, je vous encourage à vous inscrire à notre cours Introduction à Python avant de commencer pour comprendre sa fondation. Personnellement, je garde également le Tableau de bord de Python à portée de main car c’est une référence utile pour les fonctions courantes.

Choisir la bonne colormap Matplotlib

Une des premières choses à considérer est de décider entre des colormaps séquentiels, divergents ou catégoriques. D’autres facteurs importants à prendre en compte lors du choix des colormaps incluent l’uniformité perceptuelle, c’est-à-dire que des différences égales dans les valeurs des données sont perçues comme des différences égales dans les couleurs, et l’utilisation d’options de colormaps compatibles avec daltonisme pour rendre vos visuels accessibles à tous les publics.

Vous devriez également considérer différentes normes de domaine lors du choix des colormaps. Par exemple, différentes teintes de bleu représentent des profondeurs d’eau différentes dans les études océanographiques. Si vous n’êtes pas sûr de la bonne colormap pour votre visualisation, différents outils et ressources sont disponibles pour vous guider. En particulier, notre propre cours Introduction à la Visualisation des Données avec Matplotlib vous aide à traverser de nombreux scénarios.

Différentes Colormaps dans Matplotlib

Dans Python, le module matplotlib.colormaps permet d’accéder aux colormaps intégrés, ce qui vous aide à sélectionner le meilleur schéma pour votre projet. Voici les catégories les plus courantes d’options :

Colormaps séquentiels

Les colormaps séquentielles représentent des données ordonnées qui progressent de valeurs faibles à élevées. Elles passent de teintes claires à sombres, montrant la magnitude des données à différents niveaux. Un exemple de colormap séquentielle est dans lescartes de chaleur pour les données de température, où les couleurs plus claires représentent des températures plus froides et les teintes plus sombres représentent des températures plus chaudes.

Supposons que vous avez un jeu de données avec des colonnes date et température. Le code suivant créera une carte de chaleur pour la température.

Importez les bibliothèques nécessaires
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import matplotlib.colors as mcolors

Étape 1 : Extrayez les informations sur le mois et le jour de la colonne date
calendar_data = temperature_data.copy()   Créez une copie pour travailler
calendar_data['Month'] = calendar_data['Date'].dt.strftime('%B')
calendar_data['Day'] = calendar_data['Date'].dt.day

Étape 2 : Définissez l'ordre des mois pour une séquence de calendrier naturel
month_names = ['January', 'February', 'March', 'April', 'May', 'June', 
               'July', 'August', 'September', 'October', 'November', 'December']

Convertissez la colonne 'Month' en type catégoriel avec l'ordre spécifié
calendar_data['Month'] = pd.Categorical(calendar_data['Month'], categories=month_names, ordered=True)

Étape 3 : pivotez les données pour créer un tableau structuré pour la carte thermique
monthly_temperature_table = calendar_data.pivot(index='Month', columns='Day', values='Temperature')

Étape 4 : Configurez le graphique pour la carte thermique
plt.figure(figsize=(12, 8))

Définissez une normalisation personnalisée pour la plage de températures (optionnel)
norm = mcolors.Normalize(vmin=15, vmax=35)

Créez la carte thermique avec une carte de couleurs séquentielle
heatmap = plt.imshow(monthly_temperature_table, cmap='YlOrRd', aspect='auto', norm=norm)

Ajoutez une barre de couleur pour représenter la température
colorbar = plt.colorbar(heatmap, orientation='horizontal')
colorbar.set_label('Temperature (°C)', labelpad=10)

Labellez les axes
plt.xlabel('Day of the Month')
plt.ylabel('Month')

Réglez les ticks y pour afficher les noms des mois au lieu de nombres
plt.yticks(ticks=np.arange(len(month_names)), labels=month_names)

Ajoutez un titre à la carte thermique
plt.title('Monthly Temperature Heatmap (Sequential Colormap)')

Affichez le graphique
plt.grid(False)
plt.show()

Exemple de visualisation des cartes de couleurs séquentielles Matplotlib. Image par l’auteur

Cartes de couleurs divergentes

Les colormaps divergentes mettent en évidence les données avec des écarts par rapport à une valeur centrale dans les deux sens. Les colormaps divergentes ont des couleurs contrastées pour les directions positives et négatives. Une application courante des colormaps divergentes est dans les données financières pour représenter les bénéfices et les pertes.

# Définir 'Month' comme index
profit_loss_df.set_index('Month', inplace=True)

# Définir la taille de la figure
plt.figure(figsize=(8, 4))

# Créer une colormap divergente
cmap = plt.cm.RdYlGn

# Afficher les données sous forme de carte thermique en utilisant imshow
im = plt.imshow(profit_loss_df.T, cmap=cmap, aspect='auto', vmin=-np.max(np.abs(profit_loss_data)), vmax=np.max(np.abs(profit_loss_data)))

# Ajouter une barre de couleurs avec un étiquette
cbar = plt.colorbar(im)
cbar.set_label('Profit/Loss ($)')

# Ajouter des annotations à chaque cellule
for i, month in enumerate(profit_loss_df.index):
    plt.text(i, 0, f'{profit_loss_df.loc[month, "Profit/Loss"]:.2f}', ha='center', va='center', color='black')

# Définir les étiquettes et les graduation des axes x et y
plt.xlabel('Month')
plt.ylabel('')  # Aucune étiquette nécessaire pour l'axe y
plt.xticks(ticks=range(len(profit_loss_df.index)), labels=profit_loss_df.index, rotation=45)
plt.yticks([])  # Cacher les graduation de l'axe y car nous n'avons qu'une seule rangée

# Ajouter un titre
plt.title('Profit/Loss Heatmap (Diverging Colormap)')

# Ajuster la mise en page pour une meilleure présentation
plt.tight_layout()

# Afficher le graphique
plt.show()

Exemple de visualisation de colormap divergente avec Matplotlib. Image par l’auteur.

Cartes de couleurs cyclographiques

Les cartes de couleurs cyclographiques sont utiles pour visualiser des données représentant un motif récurrent ou cyclique, telles que des angles, des phases d’onde ou des moments de la journée. Un exemple d’utilisation d’une carte de couleurs cyclographique est la visualisation des phases d’une fonction périodique, comme une onde sinusoïdale.

# Créer des données pour une onde sinusoïdale
x = np.linspace(0, 2 * np.pi, 100)  # Valeurs X de 0 à 2π (un cycle complet)
y = np.sin(x)  # Valeurs Y (sinus de X)

# Créer une figure et un axe
plt.figure(figsize=(10, 6))

# Créer un graphique en nuage de points avec une carte de couleurs cyclographique
# Colorer les points par leur position dans le cycle de l'onde sinusoïdale
points = plt.scatter(x, y, c=x, cmap='twilight', edgecolor='black')

# Ajouter une barre de couleur pour montrer la phase de l'onde
cbar = plt.colorbar(points)
cbar.set_label('Wave Phase (Radians)', rotation=270, labelpad=15)

# Labeliser les axes
plt.xlabel('Angle (Radians)')
plt.ylabel('Sine Value')

# Ajouter un titre
plt.title('Sine Wave with Cyclic Colormap (Twilight)')

# Afficher le graphique
plt.grid(True)
plt.show()

Exemple de visualisation de carte de couleurs cyclographique avec Matplotlib. Image par l’auteur.

Cartes de couleurs qualitatives

Les cartes de couleurs qualitatives sont idéales pour représenter des données catégorielles sans ordre particulier des catégories. Un cas d’utilisation courant des cartes de couleurs qualitatives est un diagramme circulaire dans lequel chaque segment représente une catégorie différente qui peut être facilement distinguée.

# Échantillon de données catégorielles
categories = ['Category A', 'Category B', 'Category C', 'Category D', 'Category E']
values = [20, 35, 25, 10, 10]

# Définir la taille de la figure
plt.figure(figsize=(8, 8))

# Définir manuellement une carte de couleurs qualitative
colors = ['#8dd3c7', '#ffffb3', '#bebada', '#fb8072', '#80b1d3']  # Codes hexadécimaux des couleurs sélectionnés manuellement

# Créer un camembert
plt.pie(values, labels=categories, autopct='%1.1f%%', startangle=90, colors=colors)

# Un rapport d'aspect égal garantit que le camembert est dessiné comme un cercle
plt.axis('equal')

# Ajouter un titre
plt.title('Pie Chart with Qualitative Colormap')

# Afficher le graphique
plt.show()

Exemple de visualisation de carte des couleurs qualitative de Matplotlib. Image par l’auteur.

Colormaps arc-en-ciel

Les colormaps arc-en-ciel comme hsv sont utilisées lorsqu’une large gamme de teintes est nécessaire.

# Générer des données cycliques
x = np.linspace(0, 2 * np.pi, 500)
y = np.sin(x)

# Créer un graphique avec une colormap arc-en-ciel
plt.scatter(x, y, c=x, cmap='hsv', s=50)

# Ajouter une barre de couleurs
plt.colorbar(label='Phase')

# Ajouter des étiquettes et un titre
plt.xlabel('Angle (radians)')
plt.ylabel('Sine Value')
plt.title('Cyclic Data Visualization using HSV Colormap')

# Afficher le graphique
plt.show()

Exemple de visualisation de colormap arc-en-ciel avec Matplotlib. Image par l’auteur.

Colormaps uniformes perceptuellement

Des colormaps comme inferno et plasma offrent une meilleure visibilité sur différents supports d’affichage.

# Générer des données d'élévation synthétiques
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)) * 100  # Données d'élévation

# Tracer les données d'élévation en utilisant la colormap 'plasma'
plt.contourf(X, Y, Z, cmap='plasma')

# Ajouter une barre de couleurs
plt.colorbar(label='Elevation (m)')

# Ajouter un titre et des étiquettes
plt.title('Topographic Map (Plasma Colormap)')
plt.xlabel('X Coordinate')
plt.ylabel('Y Coordinate')

# Afficher le graphique
plt.show()

Exemple de visualisation de colormap uniforme perceptuelle Matplotlib. Image par l’auteur.

Création et modification des colormaps Matplotlib

Bien que Matplotlib offre une grande variété de colormaps intégrés, il y a des situations où vous souhaitez personnaliser vos couleurs. Les outils clés pour créer des colormaps personnalisés dans Matplotlib sont ListedColormap et LinearSegmentedColormap.

Création d’une colormap personnalisée avec ListedColormap

ListedColormap vous permet de créer une colormap à partir d’une liste de couleurs spécifiques. Cette méthode est utile lors de l’assignation de couleurs spécifiques à des catégories distinctes dans les données catégorielles.

from matplotlib.colors import ListedColormap

# Données catégorielles
categories = ['Category A', 'Category B', 'Category C', 'Category D']
values = [25, 40, 35, 30]

# Liste de couleurs personnalisée pour la carte de couleurs (par exemple, dégradés de bleu, vert, rouge et violet)
custom_colors = ['#1f77b4', '#2ca02c', '#d62728', '#9467bd']

# Créer une ListedColormap en utilisant les couleurs personnalisées
custom_cmap = ListedColormap(custom_colors)

# Définir la taille de la figure
plt.figure(figsize=(8, 6))

# Créer un diagramme à barres avec la carte de couleurs personnalisée
bars = plt.bar(categories, values, color=custom_cmap.colors)

# Ajouter un titre
plt.title('Bar Chart with Custom ListedColormap')

# Labeliser les axes
plt.xlabel('Categories')
plt.ylabel('Values')

# Afficher le graphique
plt.show()

Carte de couleurs personnalisée Matplotlib avec ListedColormap. Image par l’auteur.

Créer une carte de couleurs personnalisée avec LinearSegmentedColormap

LinearSegmentedColormap permet de créer des cartes de couleurs avec des transitions progressives entre les couleurs. Cela est utile à savoir car les données continues nécessitent souvent des changements de couleur en dégradé. Ici, je spécifie également le nombre d’intervales que je veux pour ma représentation visuelle.

from matplotlib.colors import LinearSegmentedColormap

Créer une grille de valeurs pour une fonction gaussienne 2D
x = np.linspace(-2, 2, 500)
y = np.linspace(-2, 2, 500)
X, Y = np.meshgrid(x, y)
Z = np.exp(- (X**2 + Y**2))

Définir une carte de couleurs personnalisée qui passe du bleu au blanc au rouge
colors = ['blue', 'white', 'red']
custom_cmap = LinearSegmentedColormap.from_list('blue_white_red', colors)

Ajuster le nombre de classes de couleur (niveaux discrets)
Spécifier le nombre de niveaux (par exemple, 10 pour 10 bandes de couleur distinctes)
num_classes = 10
levels = np.linspace(Z.min(), Z.max(), num_classes)

Définir la taille de la figure
plt.figure(figsize=(8, 6))

Tracer la fonction gaussienne 2D avec la carte de couleurs ajustée
contour = plt.contourf(X, Y, Z, levels=levels, cmap=custom_cmap)

Ajouter une barre de couleurs pour montrer les classes de couleur discrets
plt.colorbar(contour, label='Gaussian Function Value')

Ajouter des étiquettes pour les axes
plt.xlabel('X')
plt.ylabel('Y')

Ajouter un titre
plt.title(f'2D Gaussian with {num_classes} Discrete Color Classes')

Afficher le graphique
plt.show()

Matplotlib personnalisation en ajustant le nombre de classes de couleur. Image par l’auteur.

Personnalisation des plages de couleurs et de l’intensité

Vous pouvez contrôler l’intensité ou la plage des couleurs dans une colormap existante en manipulant sa normalisation ou en la tronquant pour utiliser un sous-ensemble des couleurs disponibles. Dans l’exemple suivant, les plages de couleurs sont tronquées pour montrer les températures entre 16 et 40 degrés Celsius.

# Configurer le graphique pour la carte thermique
plt.figure(figsize=(12, 8))

# Définir une normalisation personnalisée pour la plage de températures
norm = mcolors.Normalize(vmin=16, vmax=40)

# Créer la carte thermique avec une colormap séquentielle
heatmap = plt.imshow(monthly_temperature_table, cmap='YlOrRd', aspect='auto', norm=norm)

# Ajouter une barre de couleurs pour représenter la température
colorbar = plt.colorbar(heatmap, orientation='horizontal')
colorbar.set_label('Temperature (°C)', labelpad=10)

# Labeliser les axes
plt.xlabel('Day of the Month')
plt.ylabel('Month')

# Définir les repères y pour afficher les noms des mois plutôt que des nombres
plt.yticks(ticks=np.arange(len(month_names)), labels=month_names)

# Ajouter un titre à la carte thermique
plt.title('Monthly Temperature Heatmap (Sequential Colormap)')

# Afficher le graphique
plt.grid(False)
plt.show()

Personnalisation des plages de couleurs et de l’intensité avec Matplotlib. Image par l’auteur.

Combinaison de colormaps existantes

Vous pouvez également combiner des cartes de couleurs existantes en mélangeant plusieurs cartes de couleurs pour créer des visualisations plus complexes.

from matplotlib.colors import LinearSegmentedColormap, Normalize

# Créez des données d'élévation synthétiques
x = np.linspace(-180, 180, 500)  # Longitude
y = np.linspace(-90, 90, 250)    # Latitude
X, Y = np.meshgrid(x, y)
Z = 5000 * np.sin(np.sqrt(X**2 + Y**2) * np.pi / 180)  # Données d'élévation synthétiques

# Définissez les cartes de couleurs de base ('viridis' et 'cividis')
cmap1 = plt.get_cmap('viridis')
cmap2 = plt.get_cmap('cividis')

# Créer une carte de couleurs personnalisée en mélangeant les deux cartes de couleurs de base
def blend_colormaps(cmap1, cmap2, blend_ratio=0.5):
    """Blend two colormaps together."""
    c1 = cmap1(np.linspace(0, 1, 256))
    c2 = cmap2(np.linspace(0, 1, 256))
    blended_colors = (1 - blend_ratio) * c1 + blend_ratio * c2
    return LinearSegmentedColormap.from_list('blended_cmap', blended_colors)

# Créer la carte de couleurs mélangée
custom_cmap = blend_colormaps(cmap1, cmap2, blend_ratio=0.5)

# Normaliser les données pour la visualisation
norm = Normalize(vmin=-5000, vmax=5000)

# Définir la taille de la figure
plt.figure(figsize=(12, 6))

# Tracer les données d'élévation synthétiques avec la carte de couleurs mélangées
contour = plt.contourf(X, Y, Z, levels=100, cmap=custom_cmap, norm=norm)

# Ajoutez une barre de couleur pour montrer la cartographie des couleurs mélangées
plt.colorbar(contour, label='Elevation (meters)')

# Ajoutez des étiquettes pour les axes
plt.xlabel('Longitude')
plt.ylabel('Latitude')

# Ajoutez un titre
plt.title('Geographical Elevation Data with Blended Colormap (Viridis + Cividis)')

# Affichez le tracé
plt.show()

Matplotlib Combining existing colormaps. Image par l’auteur.

Inverser les colormaps en utilisant le suffixe _r

Vous pouvez inverser n’importe quelle colormap dans Matplotlib en ajoutant le suffixe _r à son nom.

# Configurer le graphique pour le heatmap
plt.figure(figsize=(12, 8))

# Créer une normalisation personnalisée pour la plage de couleurs
norm = mcolors.Normalize(vmin=16, vmax=40)

# Tracer le heatmap en utilisant imshow avec la colormap séquentielle
im = plt.imshow(monthly_temperature_table, cmap='YlOrRd_r', norm=norm, aspect='equal')

# Ajouter une barre de couleurs avec une orientation horizontale
cbar = plt.colorbar(im, orientation='horizontal', pad=0.1)
cbar.set_label('Temperature (°C)', labelpad=10)

# Ajouter des étiquettes pour les axes
plt.xlabel('Day of the Month')
plt.ylabel('Month')

# Définir les repères y pour afficher les noms des mois au lieu des chiffres
plt.yticks(ticks=np.arange(len(month_names)), labels=month_names)

# Ajouter un titre
plt.title('Temperature Heatmap (Sequential Colormap)')

# Afficher le graphique
plt.show()

Matplotlib Inverser les colormaps en utilisant le suffixe _r. Image par l’auteur.

Gérer les erreurs courantes dans les colormaps de Matplotlib

Lorsque vous travaillez avec des cartographies de couleurs dans Matplotlib, vous pouvez rencontrer des erreurs qui affectent votre flux de travail. Voici quelques-unes de ces erreurs et comment les résoudre.

AttributeError : module ‘matplotlib’ n’a pas d’attribut ‘colormaps’

Cette erreur se produit lorsque vous utilisez des versions de Matplotlib antérieures à 3.4.0 pour accéder à matplotlib.colormaps. L’attribut colormaps a été introduit dans Matplotlib 3.4.0.Tout d’abord, vérifiez votre version de Matplotlib en utilisant le code ci-dessous pour résoudre cette erreur.

import matplotlib
print(matplotlib.__version__)

Mettez à jour en utilisant la commande pip suivante.

pip install --upgrade matplotlib

Si vous rencontrez des problèmes pour mettre à jour votre version de Matplotlib, essayez la méthode suivante pour accéder aux cartographies de couleurs.

plt.get_cmap('viridis')  # au lieu de matplotlib.colormaps['viridis']

Affectations de couleur incorrectes

Vous pourriez avoir des affectations de couleurs incorrectes lorsque vous passez une valeur en dehors de la plage attendue ou lorsque la colormap est appliquée incorrectement. Une affectation de couleur incorrecte peut également survenir si la colormap est destinée aux données continues mais est appliquée aux données catégorielles ou inversement.

Pour vous assurer que vos données sont dans la plage attendue, normalisez ou scalisez-les toujours en utilisant les paramètres vmax et vmin.

import matplotlib.colors as mcolors

# Créer un jeu de données de température exemple
data = np.random.rand(10, 10) * 100  # Ajuster la plage pour correspondre à vos données

# Créer une instance de normalisation des couleurs pour skaliser les données à la plage de la colormap
norm = mcolors.Normalize(vmin=0, vmax=100)

# Créer une carte thermique en utilisant la colormap 'viridis' et la normalisation spécifiée
plt.imshow(data, cmap='viridis', norm=norm, interpolation='nearest')
plt.colorbar()
plt.show()

Pour un contrôle plus fin, vous pouvez définir explicitement les limites de couleur en utilisant les paramètres boundaries ou norm dans les fonctions de tracé.

Artéfacts visuels et résultats inattendus

Lorsque vous travaillez avec des données discrètes ou à faible résolution, vous pourriez expérience des bandes de couleur non intentionnelles, un contraste excessif ou un déversement de couleur. Le problème se produit lorsque vos données ont une plage limitée mais sont affichées avec une colormap continue.

Pour résoudre ce problème, utilisez plus de points de données ou ajustez le nombre de niveaux de couleur pour adoucir les transitions.

# Augmenter le nombre de bins dans la colormap
cmap = plt.get_cmap('viridis', 256)
plt.imshow(data, cmap=cmap)

<diy8Vous pouvez diviser la colormap en niveaux fixes pour gérer les données discrètes lorsque cela est approprié.

cmap = plt.get_cmap('inferno', 10)  # Diviser la colormap en 10 niveaux discrets
plt.imshow(data, cmap=cmap)

<diy12Vous pouvez également vérifier les paramètres d’affichage et ajuster la résolution, en particulier lors de l’enregistrement des visualisations, pour éviter les graphiques à faible résolution

plt.savefig('plot.png', dpi=300)  # Enregistrer la figure avec une plus haute résolution

Distorsion de couleur due au rognage

La distortion des couleurs se produit lorsque les données contiennent des valeurs extrêmes en dehors de la plage de couleurs attendue. Cela entraîne que certaines parties des données sont rognées et affectées de la couleur minimale ou maximale de la carte de couleurs.

Pour éviter la distortion des couleurs, ajustez les limites de couleur en utilisant vmin et vmax pour correspondre à la plage de vos données, ce qui empêche le rognage.

plt.imshow(data, cmap='plasma', vmin=0, vmax=100)

Vous devriez également utiliser un scaling robuste pour gérer les valeurs extrêmes en définissant des limites personnalisées qui excluent les valeurs extrêmes.

import numpy as np
robust_vmin, robust_vmax = np.percentile(data, [2, 98])  # Utilisez les percentiles pour éliminer les valeurs extrêmes
plt.imshow(data, cmap='inferno', vmin=robust_vmin, vmax=robust_vmax)

Carte de couleurs qui ne s’affiche pas correctement dans les graphiques 3D

Si هناك un problème avec la way les données sont cartographiées sur la surface 3D, les cartes de couleurs peuvent ne pas s’afficher correctement dans les visualisations 3D. Pour résoudre ce problème, assurez-vous que les données de l’axe z sont normalisées pour s’adapter à la plage attendue de la carte de couleurs. Utilisez également les limites appropriées de la carte de couleurs pour capturer l’intégralité de la plage des valeurs z.

from mpl_toolkits.mplot3d import Axes3D

 Générer des données d'échantillonnage pour un tracé de surface 3D 
X, Y = np.meshgrid(np.linspace(-5, 5, 50), np.linspace(-5, 5, 50))
Z = np.sin(np.sqrt(X**2 + Y**2))

 Créer un objet d'axes 3D 
ax = plt.axes(projection='3d')

 Tracer la surface en utilisant la colormap 'viridis' et en ajustant les limites de couleur 
ax.plot_surface(X, Y, Z, cmap='viridis', vmin=np.min(Z), vmax=np.max(Z))
plt.show()

Conclusion

Choisir la bonne colormap est une étape importante car elle influence réellement la manière dont les utilisateurs voient et comprennent vos données. À mon avis, passer beaucoup de temps sur l’analyse des données tout en étant négligent dans la dernière étape, qui est la partie où vous communiquez vos résultats, est une grande erreur.

Heureusement, Matplotlib offre de nombreuses options pour s’assurer que vos visuels racontent une histoire convaincante. Inscrivez-vous à notre cours, Introduction à la Visualisation des Données avec Matplotlib, pour devenir un expert. Et si vous êtes un utilisateur de Python qui utilise également Seaborn pour la visualisation (il est excellent de connaître les deux), lisez notre Guide Rapide pour Choisir les Couleurs dans Seaborn et suivez avec notre cours Introduction à la Visualisation des Données avec Seaborn.