Python pour le Data Analytics : Matplotlib, Seaborn et visualisation pour les entretiens techniques

Les processus de recrutement en data analytics accordent une place centrale a la visualisation de donnees. Au-dela de la production de graphiques fonctionnels, les evaluateurs cherchent a mesurer la capacite d'un candidat a structurer du code lisible, a selectionner le format graphique le plus adapte a chaque jeu de donnees et a communiquer des insights de maniere limpide. Python reste en 2026 l'ecosysteme de reference pour ces epreuves, grace a la complementarite de Matplotlib -- qui offre un controle pixel par pixel sur chaque element du graphique -- et de Seaborn, dont les fonctions de haut niveau simplifient considerablement la production de visualisations statistiques. Que l'entretien prenne la forme d'un live coding, d'un projet a realiser chez soi ou d'une discussion approfondie sur les bonnes pratiques, ces deux bibliotheques couvrent la quasi-totalite des scenarios rencontres.

Le present article parcourt chaque etape du parcours technique attendu par les recruteurs : installation de l'environnement, prise en main de l'API orientee objet, construction de panneaux comparatifs, graphiques de distribution statistique, matrices de correlation, application d'un style professionnel et realisation d'un dashboard complet sous contrainte de temps. Tous les extraits de code sont directement executables.

Configuration de l'environnement Python

Avant toute production graphique, la creation d'un environnement isole constitue un prealable que les recruteurs interpretent comme un signe de maturite technique. Isoler les dependances dans un environnement virtuel garantit que le code reste reproductible d'une machine a l'autre, un critere valorise dans les equipes data ou la collaboration sur des notebooks partages est la norme.

# setup.sh
python -m venv venv
source venv/bin/activate
pip install matplotlib==3.10.8 seaborn==0.13.2 pandas numpy

Une fois l'installation terminee, un script de verification rapide confirme que les bonnes versions sont disponibles. Ce reflexe, anodin en apparence, evite les surprises liees a des incompatibilites de versions lors d'un exercice ou chaque minute est comptee.

# verify_install.py
import matplotlib
import seaborn as sns
import pandas as pd

print(f"Matplotlib: {matplotlib.__version__}")
print(f"Seaborn: {sns.__version__}")
print(f"Pandas: {pd.__version__}")

Le tandem Matplotlib 3.10 / Seaborn 0.13 forme le socle technique de reference en 2026. Plusieurs fonctions statistiques de Seaborn ont vu leur API evoluer entre les versions 0.11 et 0.13, ce qui rend les installations obsoletes susceptibles de produire des resultats inattendus au moment le moins opportun.

Maitrise de l'API orientee objet Matplotlib

Deux philosophies coexistent dans Matplotlib pour tracer des graphiques. L'approche procedurale s'appuie sur des fonctions globales telles que plt.bar() ou plt.title(), qui agissent implicitement sur la figure active. L'approche orientee objet cree de maniere explicite les instances Figure et Axes via plt.subplots(), ce qui rend chaque operation sans equivoque quant a sa cible. Des qu'un graphique comporte plus d'un panneau, cette explicite devient indispensable.

Les evaluateurs techniques attendent quasi universellement l'API orientee objet. L'exemple suivant montre comment construire un diagramme en barres propre, avec un formatage soigne et une mise en page nettoyee.

# bar_chart_oo.py
import matplotlib.pyplot as plt
import numpy as np

# Sample quarterly revenue data
quarters = ["Q1", "Q2", "Q3", "Q4"]
revenue = [42_000, 58_000, 51_000, 67_000]

# Create figure and axes explicitly
fig, ax = plt.subplots(figsize=(8, 5))

# Draw bars with a specific color
ax.bar(quarters, revenue, color="#2563eb", width=0.5)

# Label axes clearly — interviewers check for this
ax.set_xlabel("Quarter")
ax.set_ylabel("Revenue (USD)")
ax.set_title("Quarterly Revenue — 2025")

# Format y-axis with dollar amounts
ax.yaxis.set_major_formatter(plt.FuncFormatter(lambda x, _: f"${x:,.0f}"))

# Remove top and right spines for a cleaner look
ax.spines[["top", "right"]].set_visible(False)

plt.tight_layout()
plt.savefig("quarterly_revenue.png", dpi=150)
plt.show()

Le destructuring fig, ax = plt.subplots() separe nettement le conteneur global (la figure, qui gere dimensions et resolution) de la zone de tracage (les axes, qui portent les donnees et les graduations). Le FuncFormatter convertit les valeurs brutes de l'axe Y en montants lisibles precedes du symbole dollar, un petit detail qui projette une image de rigueur professionnelle. La propriete spines permet de masquer les bordures superieure et droite, alignant le rendu sur les standards modernes de la data visualization. Enfin, tight_layout() recalcule les marges de la figure pour que les etiquettes ne soient jamais coupees, un probleme frequent lorsque la taille de la figure est fixee manuellement.

Aucun de ces ajustements n'est cosmetique : ils font partie integrante de la grille d'evaluation utilisee par les recruteurs en data analytics.

Panneaux multiples avec subplots

Presenter plusieurs metriques dans une visualisation unifiee est un exercice que les entretiens proposent regulierement. La fonction plt.subplots() genere une grille de panneaux independants, chacun dote de ses propres axes, de son propre type de graphique et de sa propre echelle. Cette modularite est la cle pour produire des dashboards analytiques clairs et coherents.

# subplots_comparison.py
import matplotlib.pyplot as plt
import numpy as np

months = ["Jan", "Feb", "Mar", "Apr", "May", "Jun"]
users = [1200, 1350, 1500, 1420, 1680, 1820]
revenue = [24_000, 27_000, 30_000, 28_400, 33_600, 36_400]

# Two side-by-side plots sharing the x-axis
fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(14, 5), sharey=False)

# Left panel: user growth as a line chart
ax1.plot(months, users, marker="o", color="#2563eb", linewidth=2)
ax1.set_title("Monthly Active Users")
ax1.set_ylabel("Users")
ax1.spines[["top", "right"]].set_visible(False)

# Right panel: revenue as a bar chart
ax2.bar(months, revenue, color="#16a34a", width=0.5)
ax2.set_title("Monthly Revenue")
ax2.set_ylabel("Revenue (USD)")
ax2.yaxis.set_major_formatter(plt.FuncFormatter(lambda x, _: f"${x:,.0f}"))
ax2.spines[["top", "right"]].set_visible(False)

fig.suptitle("Product Metrics — H1 2025", fontsize=14, fontweight="bold")
plt.tight_layout()
plt.savefig("product_metrics.png", dpi=150)
plt.show()

Le choix de sharey=False est delibere : imposer une echelle Y commune entre un nombre d'utilisateurs et un montant en dollars ecraserait l'une des deux courbes, la rendant visuellement ininterpretable. Le sur-titre defini par fig.suptitle() donne un cadre narratif a l'ensemble de la figure, tandis que chaque panneau porte un titre individuel qui precise son contenu. Sur le graphique lineaire, les marqueurs (marker="o") rendent chaque point de donnees identifiable, ce qui s'avere particulierement utile lorsque la serie ne contient que quelques observations.

Seaborn et la visualisation statistique

Seaborn etend les capacites de Matplotlib en fournissant une couche specialisee pour les graphiques statistiques. Son integration directe avec les DataFrames pandas supprime les conversions manuelles qui alourdissent le code, et ses fonctions de haut niveau produisent en quelques lignes des visualisations qui necessiteraient des dizaines de lignes en Matplotlib brut -- distributions, regressions, matrices de correlation.

Le graphique KDE (Kernel Density Estimation) est l'un des formats les plus frequemment demandes en entretien pour comparer des repartitions numeriques entre plusieurs groupes. A la difference d'un histogramme, dont l'aspect varie fortement selon le nombre de classes retenu, le KDE trace une estimation lissee de la densite de probabilite, offrant une vue synthetique et stable de la forme de chaque distribution.

# distribution_analysis.py
import seaborn as sns
import matplotlib.pyplot as plt
import pandas as pd
import numpy as np

# Simulate salary data for two departments
np.random.seed(42)
data = pd.DataFrame({
    "salary": np.concatenate([
        np.random.normal(75_000, 12_000, 200),  # Engineering
        np.random.normal(65_000, 10_000, 150),  # Marketing
    ]),
    "department": ["Engineering"] * 200 + ["Marketing"] * 150
})

# KDE plot comparing salary distributions
fig, ax = plt.subplots(figsize=(10, 5))
sns.kdeplot(
    data=data,
    x="salary",
    hue="department",        # Automatically splits by category
    fill=True,               # Shaded area under the curve
    alpha=0.4,
    palette=["#2563eb", "#dc2626"],
    ax=ax                    # Attach to our explicit axes
)

ax.set_title("Salary Distribution by Department")
ax.set_xlabel("Annual Salary (USD)")
ax.xaxis.set_major_formatter(plt.FuncFormatter(lambda x, _: f"${x:,.0f}"))
ax.spines[["top", "right"]].set_visible(False)

plt.tight_layout()
plt.savefig("salary_distribution.png", dpi=150)
plt.show()

Le parametre hue="department" ordonne a Seaborn de decouper les donnees par categorie et d'associer une couleur propre a chaque groupe. La combinaison fill=True et alpha=0.4 produit des zones colorees semi-transparentes sous chaque courbe, ce qui rend immediatement visible le degre de recouvrement entre les deux distributions -- une information analytique de premier ordre. En situation d'entretien, ce graphique permet de repondre a des interrogations telles que : le chevauchement salarial entre les deux departements est-il significatif ? Quelle distribution presente le plus de variabilite ?

Le parametre ax=ax est un detail technique important : il ancre le graphique Seaborn sur un objet Axes cree explicitement, preservant ainsi la possibilite d'appliquer ensuite des personnalisations Matplotlib supplementaires sur la meme figure.

Heatmaps de correlation : analyse multivariee en un coup d'oeil

La matrice de correlation visualisee sous forme de heatmap compte parmi les graphiques les plus regulierement exiges lors des entretiens data. En condensant les relations lineaires entre toutes les paires de variables numeriques dans une seule image, elle permet d'identifier instantanement les dependances fortes et les variables potentiellement redondantes. Les evaluateurs observent attentivement le choix de la palette chromatique, le parametrage de l'echelle et la qualite des interpretations formulees par le candidat.

# correlation_heatmap.py
import seaborn as sns
import matplotlib.pyplot as plt
import pandas as pd
import numpy as np

# Simulate e-commerce metrics
np.random.seed(42)
n = 500
page_views = np.random.poisson(15, n)
time_on_site = page_views * 2.5 + np.random.normal(0, 5, n)
cart_adds = np.random.binomial(page_views, 0.3)
purchases = np.random.binomial(cart_adds, 0.4)

df = pd.DataFrame({
    "page_views": page_views,
    "time_on_site": time_on_site,
    "cart_adds": cart_adds,
    "purchases": purchases
})

# Compute Pearson correlation
corr_matrix = df.corr()

fig, ax = plt.subplots(figsize=(8, 6))
sns.heatmap(
    corr_matrix,
    annot=True,              # Show correlation values in cells
    fmt=".2f",               # Two decimal places
    cmap="RdBu_r",           # Diverging colormap centered on 0
    vmin=-1, vmax=1,         # Fixed scale for consistency
    square=True,             # Square cells
    linewidths=0.5,
    ax=ax
)

ax.set_title("E-commerce Metrics Correlation")
plt.tight_layout()
plt.savefig("correlation_heatmap.png", dpi=150)
plt.show()

Chaque parametre de cette heatmap peut faire l'objet d'une question en entretien. La palette RdBu_r est de type divergent : les rouges intenses signalent les correlations positives fortes, les bleus intenses les correlations negatives fortes, et les tons neutres indiquent l'absence de relation lineaire. Fixer vmin=-1 et vmax=1 arrime l'echelle de couleurs a la plage theorique des coefficients de Pearson. Si ces bornes ne sont pas definies, Matplotlib ajuste dynamiquement la palette aux valeurs presentes dans la matrice, ce qui peut visuellement exagerer des correlations faibles et fausser l'analyse.

L'option annot=True imprime chaque coefficient directement dans sa cellule, garantissant une lecture precise qui ne repose pas uniquement sur l'interpretation des nuances chromatiques. Dans le jeu de donnees e-commerce utilise ici, un candidat averti devrait expliquer que la forte correlation entre page_views et time_on_site traduit une relation quasi mecanique, tandis que la correlation entre cart_adds et purchases quantifie l'efficacite du funnel de conversion.

Appliquer un style professionnel aux graphiques

Les parametres visuels par defaut de Matplotlib -- fond grisatre, polices modestes, couleurs ternes -- remplissent leur office pour une exploration rapide, mais envoient un signal d'approximation dans un cadre d'evaluation. Quelques lignes de configuration globale suffisent a elever significativement la qualite perceptive des graphiques, un effort marginal au regard de l'impact sur l'impression laissee au recruteur.

# professional_styling.py
import matplotlib.pyplot as plt
import seaborn as sns

# Apply Seaborn's built-in theme
sns.set_theme(
    style="whitegrid",       # Clean background with grid lines
    palette="muted",         # Professional color palette
    font_scale=1.1           # Slightly larger text
)

# Global Matplotlib overrides
plt.rcParams.update({
    "figure.facecolor": "white",
    "axes.facecolor": "white",
    "font.family": "sans-serif",
    "axes.titlesize": 14,
    "axes.labelsize": 12,
})

La fonction sns.set_theme() instaure un theme global applicable a toutes les figures creees ulterieurement dans la session. Le style whitegrid combine un arriere-plan blanc avec des lignes de grille discretes qui aident a la lecture des valeurs sans encombrer le graphique. La palette muted offre un jeu de couleurs adapte tant aux ecrans qu'aux impressions sur papier. Les surcharges appliquees via plt.rcParams permettent de controler precisement les tailles de polices et les teintes d'arriere-plan, assurant une lisibilite constante quel que soit le support de diffusion.

Cette configuration doit etre placee au tout debut du script ou du notebook, avant toute instruction de tracage, pour que le style s'applique de maniere uniforme a l'ensemble des figures de la session de travail.

Questions conceptuelles posees lors des entretiens de visualisation

Au-dela des exercices de code, les recruteurs en data analytics integrent systematiquement un volet de questions theoriques destine a sonder la comprehension profonde des principes de visualisation.

Diagramme en barres ou graphique lineaire : quel critere de choix ? Le diagramme en barres s'impose pour les comparaisons entre categories discretes depourvues de relation d'ordre naturelle ou ne comportant qu'un petit nombre de valeurs -- trimestres, departements, produits. Le graphique lineaire est reserve aux series temporelles ou l'evolution tendancielle prime sur chaque valeur individuelle. Tracer un graphique lineaire pour des categories nominales sans ordonnancement (des pays tries alphabetiquement, par exemple) cree une fausse impression de continuite qui induit le lecteur en erreur.

Interface pyplot ou API orientee objet : quelle distinction concrete ? L'interface pyplot maintient un etat global implicite : chaque appel a plt.plot() ou plt.title() s'applique a la figure et aux axes actifs au moment de l'execution. L'API orientee objet instancie explicitement Figure et Axes via plt.subplots(), eliminant toute ambiguite sur la cible de chaque operation. Pour le code de production et les graphiques multi-panneaux, la seconde approche est la norme attendue.

Comment choisir la bonne palette chromatique ? Les palettes se repartissent en trois grandes familles. Les palettes sequentielles (degradee monochrome du clair au fonce) representent des valeurs ordonnees sur un axe unique. Les palettes divergentes (deux teintes extremes separees par un point neutre) servent aux donnees centrees autour d'une reference, comme les coefficients de correlation autour de zero. Les palettes qualitatives (couleurs perceptuellement distinctes sans hierarchie) differencient des categories nominales.

Seaborn remplace-t-il Matplotlib ? Non. Seaborn constitue une surcouche statistique construite sur Matplotlib. La bibliotheque propose des fonctions de haut niveau pour les distributions, regressions et heatmaps, avec une integration native des DataFrames pandas. Toutefois, toute personnalisation fine -- annotation specifique, modification des ticks, ajout d'elements graphiques non standard -- necessite toujours un recours a l'API Matplotlib sous-jacente.

Pourquoi imposer vmin=-1 et vmax=1 sur une heatmap de correlation ? En l'absence de bornes explicites, Matplotlib calibre automatiquement l'echelle chromatique sur la plage de valeurs effectivement presentes dans la matrice. Si toutes les correlations observees se situent entre 0.3 et 0.7, cette plage etroite occupe l'integralite du spectre de couleurs, amplifiant artificiellement les ecarts et risquant de biaiser l'interpretation. Ancrer l'echelle a la plage theorique [-1, 1] garantit qu'une meme teinte correspond toujours a la meme intensite de correlation, independamment du jeu de donnees analyse.

Exercice de synthese : construire un dashboard produit en conditions d'entretien

Les evaluations finales en data analytics prennent souvent la forme d'un exercice de construction de dashboard sous contrainte de temps. Le candidat recoit un ensemble de donnees simulees et doit concevoir une visualisation multi-panneaux couvrant plusieurs indicateurs cles du produit. L'exercice mesure simultanement la fluence technique, la coherence des choix graphiques et la capacite a produire un resultat exploitable dans un delai restreint.

Le scenario ci-dessous simule une situation courante : elaborer un tableau de bord de pilotage produit a trois volets -- tendance du chiffre d'affaires, evolution de la base clients et suivi du taux de desabonnement mensuel, ce dernier integrant une ligne de seuil representant l'objectif de l'equipe.

# interview_exercise.py
import matplotlib.pyplot as plt
import seaborn as sns
import pandas as pd
import numpy as np

sns.set_theme(style="whitegrid", palette="muted", font_scale=1.05)

# Simulate 12 months of product data
np.random.seed(42)
months = pd.date_range("2025-01", periods=12, freq="MS")
df = pd.DataFrame({
    "month": months,
    "revenue": np.cumsum(np.random.normal(5000, 2000, 12)) + 50_000,
    "customers": np.cumsum(np.random.poisson(50, 12)) + 500,
    "churn_rate": np.clip(np.random.normal(0.05, 0.015, 12), 0.01, 0.12)
})

fig, axes = plt.subplots(1, 3, figsize=(18, 5))

# Panel 1: Revenue trend
axes[0].plot(df["month"], df["revenue"], marker="o", color="#2563eb")
axes[0].set_title("Revenue Trend")
axes[0].set_ylabel("Revenue (USD)")
axes[0].yaxis.set_major_formatter(plt.FuncFormatter(lambda x, _: f"${x:,.0f}"))
axes[0].tick_params(axis="x", rotation=45)
axes[0].spines[["top", "right"]].set_visible(False)

# Panel 2: Customer growth
axes[1].bar(df["month"], df["customers"], color="#16a34a", width=20)
axes[1].set_title("Customer Growth")
axes[1].set_ylabel("Total Customers")
axes[1].tick_params(axis="x", rotation=45)
axes[1].spines[["top", "right"]].set_visible(False)

# Panel 3: Churn rate with threshold line
axes[2].plot(df["month"], df["churn_rate"], marker="s", color="#dc2626")
axes[2].axhline(y=0.05, color="gray", linestyle="--", label="Target: 5%")
axes[2].set_title("Monthly Churn Rate")
axes[2].set_ylabel("Churn Rate")
axes[2].yaxis.set_major_formatter(plt.FuncFormatter(lambda x, _: f"{x:.1%}"))
axes[2].tick_params(axis="x", rotation=45)
axes[2].spines[["top", "right"]].set_visible(False)
axes[2].legend()

fig.suptitle("Product Dashboard — FY 2025", fontsize=14, fontweight="bold")
plt.tight_layout()
plt.savefig("interview_dashboard.png", dpi=150)
plt.show()

Ce dashboard concentre l'ensemble des competences detaillees dans cet article. Le premier volet trace la tendance du revenu avec un graphique lineaire a marqueurs, format naturel pour une serie temporelle ou la dynamique globale importe davantage que les valeurs isolees. Le deuxieme volet adopte le diagramme en barres pour la croissance cumulee du nombre de clients, chaque barre materialisant un mois discret. Le troisieme volet ajoute une ligne de reference horizontale (axhline()) qui permet de reperer en un instant les mois ou le churn depasse le seuil cible de 5 %. Le formatage en pourcentage de l'axe Y ({x:.1%}) et la rotation a 45 degres des etiquettes de dates assurent la lisibilite de chacun des trois panneaux.

Le veritable facteur de differenciation en entretien ne reside pas dans le code lui-meme, mais dans la capacite a verbaliser les decisions prises : expliquer pourquoi le revenu est represente par une ligne et les clients par des barres, pourquoi le seuil de churn est materialise visuellement plutot que mentionne dans une annotation, pourquoi les trois panneaux conservent des echelles verticales independantes. Cette aptitude a articuler la logique de conception distingue nettement les candidats confirmes des profils en debut de parcours.

Conclusion

La maitrise associee de Matplotlib et Seaborn confere un avantage tangible lors des entretiens techniques en data analytics. Les points essentiels a consolider avant toute evaluation sont les suivants :

• Privilegier systematiquement l'API orientee objet de Matplotlib (fig, ax = plt.subplots()) et abandonner les appels proceduraux pyplot, sources d'ambiguites des que la figure comporte plusieurs panneaux
• Accompagner chaque graphique d'un titre clair, d'axes etiquetes avec leurs unites et d'un formatage adapte des valeurs (symboles monetaires, pourcentages, separateurs de milliers)
• Configurer les subplots avec des echelles Y independantes lorsque les panneaux representent des grandeurs de natures ou d'ordres de magnitude differents
• Exploiter Seaborn pour les graphiques statistiques (KDE, heatmaps, distributions) et son integration native avec pandas, tout en conservant Matplotlib pour les ajustements fins
• Verrouiller les bornes de la heatmap de correlation a vmin=-1, vmax=1 avec une palette divergente pour garantir une interpretation rigoureuse et reproductible des coefficients de Pearson
• Appliquer sns.set_theme() et plt.rcParams en tete de script pour obtenir un rendu professionnel homogene sur l'ensemble des figures, avec un investissement en code minimal
• Developper la capacite a justifier oralement chaque decision de visualisation -- choix du type de graphique, de la palette, de l'echelle, des elements de reference -- car c'est cette competence qui separe les candidats experimentes des profils debutants