Skip to content

Diagramme en secteurs Matplotlib : guide complet pour créer des camemberts en Python

Soren Atelier
Name
Soren Atelier

Updated on

Créer des visualisations de données efficaces est essentiel pour communiquer clairement des insights. Lorsque vous devez montrer des proportions ou des pourcentages d’un tout, les diagrammes en secteurs (camemberts) deviennent un outil incontournable dans votre arsenal de visualisation. Pourtant, de nombreux analystes de données ont du mal à produire des camemberts au rendu professionnel : mettre correctement en évidence des segments importants, choisir des couleurs adaptées et afficher les pourcentages avec précision. Le diagramme en secteurs matplotlib par défaut paraît souvent trop simple, manque de contexte et n’accentue pas les points clés.

Ces difficultés de visualisation deviennent encore plus marquées lors de présentations à des parties prenantes qui doivent comprendre rapidement des répartitions de parts de marché, des allocations budgétaires ou des résultats d’enquête. Un camembert mal conçu peut davantage embrouiller qu’éclairer, et conduire à une mauvaise interprétation d’indicateurs métier critiques.

Matplotlib fournit une fonction plt.pie() complète, avec de nombreuses options de personnalisation qui transforment des graphiques circulaires basiques en visualisations professionnelles. Ce guide montre comment créer des camemberts allant de simples proportions à des diagrammes imbriqués complexes, avec des exemples pratiques sur les labels, les couleurs, les parts “explosées”, les graphiques en anneau, et l’intégration avec des DataFrames pandas pour des workflows d’analyse de données réalistes.

📚

    Syntaxe de base d’un diagramme en secteurs Matplotlib

    La création de camemberts dans matplotlib repose sur plt.pie(), qui ne nécessite qu’une liste ou un tableau de valeurs représentant la taille de chaque secteur.

    import matplotlib.pyplot as plt
 
# Basic pie chart data
sizes = [35, 25, 20, 20]
labels = ['Product A', 'Product B', 'Product C', 'Product D']
 
# Create pie chart
plt.pie(sizes, labels=labels)
plt.title('Market Share Distribution')
plt.show()

    Cela crée un graphique circulaire basique où la taille des secteurs est proportionnelle aux valeurs de la liste sizes. Matplotlib calcule automatiquement les pourcentages et les angles de chaque segment. Le graphique attribue des couleurs via le cycle de couleurs par défaut, ce qui ne correspond pas toujours à vos besoins de présentation.

    Pour obtenir un cercle parfait plutôt qu’une ellipse, ajoutez plt.axis('equal') :

    import matplotlib.pyplot as plt
 
sizes = [35, 25, 20, 20]
labels = ['Product A', 'Product B', 'Product C', 'Product D']
 
plt.pie(sizes, labels=labels)
plt.axis('equal')  # Equal aspect ratio ensures circular shape
plt.title('Market Share Distribution')
plt.show()

    Afficher les pourcentages avec autopct

    Le paramètre autopct formate et affiche automatiquement les pourcentages sur chaque secteur, rendant le graphique plus informatif sans calcul manuel.

    import matplotlib.pyplot as plt
 
sizes = [35, 25, 20, 20]
labels = ['Product A', 'Product B', 'Product C', 'Product D']
 
plt.pie(sizes, labels=labels, autopct='%1.1f%%')
plt.axis('equal')
plt.title('Market Share with Percentages')
plt.show()

    La chaîne de format '%1.1f%%' affiche les pourcentages avec une décimale. Le premier % démarre le spécificateur de format, 1.1f signifie un chiffre avant la virgule et un après, et %% produit un symbole pourcentage littéral dans la sortie.

    Pour des pourcentages entiers sans décimales, utilisez '%1.0f%%' :

    plt.pie(sizes, labels=labels, autopct='%1.0f%%')

    Vous pouvez aussi fournir une fonction personnalisée à autopct pour contrôler plus finement l’affichage :

    import matplotlib.pyplot as plt
 
sizes = [350, 250, 200, 200]
labels = ['Product A', 'Product B', 'Product C', 'Product D']
 
def make_autopct(values):
    def my_autopct(pct):
        total = sum(values)
        val = int(round(pct * total / 100.0))
        return f'{pct:.1f}%\n({val:d})'
    return my_autopct
 
plt.pie(sizes, labels=labels, autopct=make_autopct(sizes))
plt.axis('equal')
plt.title('Market Share with Counts and Percentages')
plt.show()

    Cela affiche à la fois le pourcentage et le décompte réel sur chaque secteur.

    Couleurs personnalisées et colormaps

    Le paramètre colors accepte une liste de couleurs pour remplacer le cycle par défaut de matplotlib. Vous pouvez utiliser des noms de couleurs, des codes hexadécimaux ou des tuples RGB.

    import matplotlib.pyplot as plt
 
sizes = [35, 25, 20, 20]
labels = ['Product A', 'Product B', 'Product C', 'Product D']
colors = ['#ff9999', '#66b3ff', '#99ff99', '#ffcc99']
 
plt.pie(sizes, labels=labels, colors=colors, autopct='%1.1f%%')
plt.axis('equal')
plt.title('Market Share with Custom Colors')
plt.show()

    Pour une sélection de couleurs pilotée par les données, utilisez les colormaps matplotlib :

    import matplotlib.pyplot as plt
import numpy as np
 
sizes = [35, 25, 20, 20]
labels = ['Product A', 'Product B', 'Product C', 'Product D']
 
# Generate colors from a colormap
cmap = plt.cm.Set3
colors = cmap(np.linspace(0, 1, len(sizes)))
 
plt.pie(sizes, labels=labels, colors=colors, autopct='%1.1f%%')
plt.axis('equal')
plt.title('Market Share with Colormap')
plt.show()

    Parmi les colormaps populaires pour les camemberts : Set1, Set2, Set3, Pastel1, Pastel2, et tab10.

    Exploser des secteurs pour mettre en évidence

    Le paramètre explode écarte certains secteurs du centre afin de mettre en valeur des points importants. Chaque valeur du tuple correspond au décalage radial du secteur.

    import matplotlib.pyplot as plt
 
sizes = [35, 25, 20, 20]
labels = ['Product A', 'Product B', 'Product C', 'Product D']
colors = ['#ff9999', '#66b3ff', '#99ff99', '#ffcc99']
explode = (0.1, 0, 0, 0)  # Explode the first slice
 
plt.pie(sizes, labels=labels, colors=colors, autopct='%1.1f%%',
        explode=explode)
plt.axis('equal')
plt.title('Market Share with Exploded Slice')
plt.show()

    La valeur 0.1 déplace le premier secteur vers l’extérieur de 10% du rayon. Vous pouvez “exploser” plusieurs secteurs :

    explode = (0.1, 0.05, 0, 0)  # Explode first two slices
plt.pie(sizes, labels=labels, colors=colors, autopct='%1.1f%%',
        explode=explode)

    Ajouter une ombre et un angle de départ

    Le paramètre shadow ajoute une ombre portée pour un effet 3D, tandis que startangle fait pivoter l’ensemble du graphique pour positionner les secteurs à des angles spécifiques.

    import matplotlib.pyplot as plt
 
sizes = [35, 25, 20, 20]
labels = ['Product A', 'Product B', 'Product C', 'Product D']
colors = ['#ff9999', '#66b3ff', '#99ff99', '#ffcc99']
explode = (0.1, 0, 0, 0)
 
plt.pie(sizes, labels=labels, colors=colors, autopct='%1.1f%%',
        explode=explode, shadow=True, startangle=90)
plt.axis('equal')
plt.title('Market Share with Shadow and Rotation')
plt.show()

    Le startangle=90 fait pivoter le graphique pour que le premier secteur commence à 90 degrés (en haut du cercle) au lieu de 0 degré (à droite) par défaut. C’est utile pour placer les secteurs importants en haut, donc plus visibles.

    Créer des graphiques en anneau (donut charts)

    Les graphiques en anneau sont des camemberts avec un centre creux, créés via le paramètre wedgeprops pour définir la largeur de chaque “part”.

    import matplotlib.pyplot as plt
 
sizes = [35, 25, 20, 20]
labels = ['Product A', 'Product B', 'Product C', 'Product D']
colors = ['#ff9999', '#66b3ff', '#99ff99', '#ffcc99']
 
# Create donut chart
wedgeprops = {'width': 0.4}
 
plt.pie(sizes, labels=labels, colors=colors, autopct='%1.1f%%',
        wedgeprops=wedgeprops)
plt.axis('equal')
plt.title('Market Share Donut Chart')
plt.show()

    La valeur width de 0.4 crée un anneau représentant 40% du rayon total. Une valeur plus petite crée un anneau plus fin, tandis que des valeurs proches de 1.0 se rapprochent d’un camembert plein.

    Vous pouvez ajouter du texte au centre :

    import matplotlib.pyplot as plt
 
sizes = [35, 25, 20, 20]
labels = ['Product A', 'Product B', 'Product C', 'Product D']
colors = ['#ff9999', '#66b3ff', '#99ff99', '#ffcc99']
 
wedgeprops = {'width': 0.4, 'edgecolor': 'white', 'linewidth': 2}
 
plt.pie(sizes, labels=labels, colors=colors, autopct='%1.1f%%',
        wedgeprops=wedgeprops)
plt.axis('equal')
 
# Add center text
plt.text(0, 0, 'Total\nSales', ha='center', va='center',
         fontsize=14, fontweight='bold')
plt.title('Market Share Donut Chart')
plt.show()

    Diagrammes en secteurs imbriqués et concentriques

    Créez des visualisations plus complexes en traçant plusieurs camemberts avec des rayons différents pour afficher des relations hiérarchiques.

    import matplotlib.pyplot as plt
import numpy as np
 
# Outer ring data
outer_sizes = [35, 25, 20, 20]
outer_labels = ['Product A', 'Product B', 'Product C', 'Product D']
outer_colors = ['#ff9999', '#66b3ff', '#99ff99', '#ffcc99']
 
# Inner ring data (subcategories)
inner_sizes = [15, 20, 12, 13, 10, 10, 8, 12]
inner_labels = ['A1', 'A2', 'B1', 'B2', 'C1', 'C2', 'D1', 'D2']
inner_colors = ['#ffcccc', '#ff6666', '#99ccff', '#3399ff',
                '#ccffcc', '#66ff66', '#ffe6cc', '#ffb366']
 
fig, ax = plt.subplots()
 
# Outer pie
ax.pie(outer_sizes, labels=outer_labels, colors=outer_colors,
       autopct='%1.1f%%', radius=1.2, wedgeprops={'width': 0.4})
 
# Inner pie
ax.pie(inner_sizes, labels=inner_labels, colors=inner_colors,
       autopct='%1.0f%%', radius=0.8, wedgeprops={'width': 0.4})
 
ax.axis('equal')
plt.title('Nested Pie Chart: Products and Subcategories')
plt.show()

    Cela crée deux graphiques en anneau concentriques, où l’anneau intérieur montre les sous-catégories des segments de l’anneau extérieur.

    Ajouter des légendes

    Pour les graphiques avec beaucoup de secteurs, ou lorsque les labels encombrent la visualisation, déplacez les labels vers une légende avec legend().

    import matplotlib.pyplot as plt
 
sizes = [35, 25, 20, 15, 5]
labels = ['Product A', 'Product B', 'Product C', 'Product D', 'Others']
colors = ['#ff9999', '#66b3ff', '#99ff99', '#ffcc99', '#ff99cc']
 
plt.pie(sizes, colors=colors, autopct='%1.1f%%', startangle=90)
plt.axis('equal')
plt.legend(labels, loc='upper left', bbox_to_anchor=(1, 0, 0.5, 1))
plt.title('Market Share Distribution')
plt.tight_layout()
plt.show()

    Le paramètre bbox_to_anchor positionne la légende en dehors de la zone du graphique. La fonction tight_layout() ajuste la zone du tracé pour éviter de rogner la légende.

    Pour des entrées de légende personnalisées avec pourcentages :

    import matplotlib.pyplot as plt
 
sizes = [35, 25, 20, 15, 5]
labels = ['Product A', 'Product B', 'Product C', 'Product D', 'Others']
colors = ['#ff9999', '#66b3ff', '#99ff99', '#ffcc99', '#ff99cc']
 
wedges, texts, autotexts = plt.pie(sizes, colors=colors, autopct='%1.1f%%',
                                     startangle=90)
plt.axis('equal')
 
# Create legend with labels and percentages
legend_labels = [f'{label} ({size}%)' for label, size in zip(labels, sizes)]
plt.legend(wedges, legend_labels, loc='upper left',
           bbox_to_anchor=(1, 0, 0.5, 1))
plt.title('Market Share Distribution')
plt.tight_layout()
plt.show()

    Référence des paramètres d’un diagramme en secteurs

    ParamètreTypeDescriptionExemple
    xarray-likeTailles des secteurs (requis)[30, 25, 20, 25]
    labelslist of strLabels texte pour chaque secteur['A', 'B', 'C', 'D']
    colorslistCouleurs pour chaque secteur['red', 'blue', 'green']
    autopctstr or functionChaîne de format ou fonction pour les pourcentages'%1.1f%%'
    explodetupleDécalage radial pour chaque secteur(0.1, 0, 0, 0)
    shadowboolAjouter une ombre portéeTrue ou False
    startanglefloatAngle de rotation en degrés90
    radiusfloatRayon du camembert1.0 (par défaut)
    wedgepropsdictPropriétés des “wedges”{'width': 0.4}
    textpropsdictPropriétés des textes (labels){'fontsize': 12}
    labeldistancefloatDistance des labels depuis le centre1.1 (par défaut)
    pctdistancefloatDistance du texte de pourcentage depuis le centre0.6 (par défaut)
    counterclockboolSens de tracé des secteursTrue (par défaut)
    frameboolDessiner le cadre des axesFalse (par défaut)

    Personnaliser les propriétés du texte

    Le paramètre textprops contrôle l’apparence de tous les éléments textuels du camembert, y compris les labels et les pourcentages.

    import matplotlib.pyplot as plt
 
sizes = [35, 25, 20, 20]
labels = ['Product A', 'Product B', 'Product C', 'Product D']
colors = ['#ff9999', '#66b3ff', '#99ff99', '#ffcc99']
 
textprops = {'fontsize': 14, 'fontweight': 'bold', 'color': 'darkblue'}
 
plt.pie(sizes, labels=labels, colors=colors, autopct='%1.1f%%',
        textprops=textprops)
plt.axis('equal')
plt.title('Market Share with Custom Text', fontsize=16, fontweight='bold')
plt.show()

    Pour contrôler séparément les labels et le texte des pourcentages, accédez aux objets texte renvoyés :

    import matplotlib.pyplot as plt
 
sizes = [35, 25, 20, 20]
labels = ['Product A', 'Product B', 'Product C', 'Product D']
colors = ['#ff9999', '#66b3ff', '#99ff99', '#ffcc99']
 
wedges, texts, autotexts = plt.pie(sizes, labels=labels, colors=colors,
                                     autopct='%1.1f%%')
 
# Customize label text
for text in texts:
    text.set_fontsize(12)
    text.set_fontweight('bold')
 
# Customize percentage text
for autotext in autotexts:
    autotext.set_color('white')
    autotext.set_fontsize(10)
    autotext.set_fontweight('bold')
 
plt.axis('equal')
plt.title('Market Share with Styled Text')
plt.show()

    Travailler avec des DataFrames Pandas

    Dans des cas réels, l’analyse de données implique souvent des DataFrames pandas. Vous pouvez créer des camemberts directement à partir de colonnes du DataFrame.

    import matplotlib.pyplot as plt
import pandas as pd
 
# Sample DataFrame
data = {
    'Product': ['Product A', 'Product B', 'Product C', 'Product D'],
    'Sales': [350000, 250000, 200000, 200000]
}
df = pd.DataFrame(data)
 
# Create pie chart from DataFrame
plt.pie(df['Sales'], labels=df['Product'], autopct='%1.1f%%',
        startangle=90)
plt.axis('equal')
plt.title('Sales Distribution by Product')
plt.show()

    Pour des données regroupées, utilisez une agrégation pandas avant de tracer :

    import matplotlib.pyplot as plt
import pandas as pd
 
# Sample DataFrame with categories
data = {
    'Region': ['North', 'South', 'East', 'West', 'North', 'South', 'East', 'West'],
    'Product': ['A', 'A', 'A', 'A', 'B', 'B', 'B', 'B'],
    'Sales': [120000, 80000, 95000, 105000, 90000, 110000, 85000, 95000]
}
df = pd.DataFrame(data)
 
# Group by region and sum sales
region_sales = df.groupby('Region')['Sales'].sum()
 
plt.pie(region_sales.values, labels=region_sales.index, autopct='%1.1f%%',
        startangle=90)
plt.axis('equal')
plt.title('Total Sales by Region')
plt.show()

    Enregistrer les camemberts dans des fichiers

    Enregistrez les camemberts dans divers formats d’image avec plt.savefig() avant d’appeler plt.show().

    import matplotlib.pyplot as plt
 
sizes = [35, 25, 20, 20]
labels = ['Product A', 'Product B', 'Product C', 'Product D']
colors = ['#ff9999', '#66b3ff', '#99ff99', '#ffcc99']
 
plt.pie(sizes, labels=labels, colors=colors, autopct='%1.1f%%')
plt.axis('equal')
plt.title('Market Share Distribution')
 
# Save as PNG with high DPI
plt.savefig('market_share.png', dpi=300, bbox_inches='tight')
 
# Save as PDF for vector graphics
plt.savefig('market_share.pdf', bbox_inches='tight')
 
# Save as SVG for web use
plt.savefig('market_share.svg', bbox_inches='tight')
 
plt.show()

    Le paramètre bbox_inches='tight' supprime l’espace blanc superflu autour du graphique. Le paramètre dpi contrôle la résolution pour les formats raster comme PNG.

    Exemple réel : répartition d’un budget

    import matplotlib.pyplot as plt
import pandas as pd
 
# Annual budget data
budget_data = {
    'Category': ['Salaries', 'Marketing', 'Operations', 'R&D', 'Infrastructure'],
    'Amount': [450000, 180000, 120000, 150000, 100000]
}
df = pd.DataFrame(budget_data)
 
# Calculate total budget
total_budget = df['Amount'].sum()
 
# Define colors
colors = ['#ff6b6b', '#4ecdc4', '#45b7d1', '#f9ca24', '#6c5ce7']
 
# Create pie chart
fig, ax = plt.subplots(figsize=(10, 7))
 
wedges, texts, autotexts = ax.pie(df['Amount'], labels=df['Category'],
                                    colors=colors, autopct='%1.1f%%',
                                    startangle=90, explode=(0.05, 0, 0, 0, 0))
 
# Customize text
for text in texts:
    text.set_fontsize(12)
    text.set_fontweight('bold')
 
for autotext in autotexts:
    autotext.set_color('white')
    autotext.set_fontsize(10)
    autotext.set_fontweight('bold')
 
ax.axis('equal')
plt.title(f'Annual Budget Breakdown\nTotal: ${total_budget:,}',
          fontsize=16, fontweight='bold', pad=20)
 
plt.tight_layout()
plt.savefig('budget_breakdown.png', dpi=300, bbox_inches='tight')
plt.show()

    Exemple réel : résultats d’enquête

    import matplotlib.pyplot as plt
import numpy as np
 
# Survey response data
responses = {
    'Very Satisfied': 145,
    'Satisfied': 230,
    'Neutral': 85,
    'Dissatisfied': 30,
    'Very Dissatisfied': 10
}
 
labels = list(responses.keys())
sizes = list(responses.values())
total_responses = sum(sizes)
 
# Color scheme from red to green
colors = ['#2ecc71', '#3498db', '#95a5a6', '#e67e22', '#e74c3c']
 
fig, ax = plt.subplots(figsize=(10, 7))
 
wedges, texts, autotexts = ax.pie(sizes, labels=labels, colors=colors,
                                    autopct=lambda pct: f'{pct:.1f}%\n({int(pct * total_responses / 100)})',
                                    startangle=90, wedgeprops={'edgecolor': 'white', 'linewidth': 2})
 
for text in texts:
    text.set_fontsize(11)
 
for autotext in autotexts:
    autotext.set_color('white')
    autotext.set_fontsize(9)
    autotext.set_fontweight('bold')
 
ax.axis('equal')
plt.title(f'Customer Satisfaction Survey Results\nTotal Responses: {total_responses}',
          fontsize=16, fontweight='bold', pad=20)
 
plt.tight_layout()
plt.show()

    Exemple réel : analyse de parts de marché

    import matplotlib.pyplot as plt
import pandas as pd
 
# Market share data for multiple quarters
data = {
    'Company': ['Company A', 'Company B', 'Company C', 'Company D', 'Others'],
    'Q1_Share': [28, 24, 18, 15, 15],
    'Q2_Share': [30, 22, 19, 14, 15],
    'Q3_Share': [32, 21, 18, 15, 14],
    'Q4_Share': [35, 20, 17, 16, 12]
}
df = pd.DataFrame(data)
 
# Create subplots for each quarter
fig, axes = plt.subplots(2, 2, figsize=(14, 12))
quarters = ['Q1_Share', 'Q2_Share', 'Q3_Share', 'Q4_Share']
colors = ['#ff9999', '#66b3ff', '#99ff99', '#ffcc99', '#ff99cc']
 
for idx, (ax, quarter) in enumerate(zip(axes.flat, quarters)):
    wedges, texts, autotexts = ax.pie(df[quarter], labels=df['Company'],
                                        colors=colors, autopct='%1.1f%%',
                                        startangle=90)
 
    for text in texts:
        text.set_fontsize(10)
 
    for autotext in autotexts:
        autotext.set_color('white')
        autotext.set_fontsize(9)
        autotext.set_fontweight('bold')
 
    ax.set_title(f'Market Share {quarter.replace("_Share", "")}',
                 fontsize=12, fontweight='bold')
 
plt.suptitle('Quarterly Market Share Analysis', fontsize=16, fontweight='bold', y=0.995)
plt.tight_layout()
plt.savefig('market_share_analysis.png', dpi=300, bbox_inches='tight')
plt.show()

    Combiner les camemberts avec d’autres visualisations

    Créez des tableaux de bord complets en combinant camemberts, diagrammes en barres, courbes ou tableaux.

    import matplotlib.pyplot as plt
import pandas as pd
import numpy as np
 
# Sample data
categories = ['Product A', 'Product B', 'Product C', 'Product D']
current_sales = [350000, 250000, 200000, 200000]
previous_sales = [320000, 280000, 180000, 220000]
 
# Create figure with subplots
fig = plt.figure(figsize=(14, 6))
 
# Pie chart showing current market share
ax1 = plt.subplot(1, 2, 1)
colors = ['#ff9999', '#66b3ff', '#99ff99', '#ffcc99']
ax1.pie(current_sales, labels=categories, colors=colors, autopct='%1.1f%%',
        startangle=90)
ax1.set_title('Current Market Share', fontsize=14, fontweight='bold')
 
# Bar chart showing comparison
ax2 = plt.subplot(1, 2, 2)
x = np.arange(len(categories))
width = 0.35
 
bars1 = ax2.bar(x - width/2, previous_sales, width, label='Previous Period',
                color='#95a5a6', alpha=0.8)
bars2 = ax2.bar(x + width/2, current_sales, width, label='Current Period',
                color='#3498db', alpha=0.8)
 
ax2.set_xlabel('Products', fontsize=12, fontweight='bold')
ax2.set_ylabel('Sales ($)', fontsize=12, fontweight='bold')
ax2.set_title('Sales Comparison', fontsize=14, fontweight='bold')
ax2.set_xticks(x)
ax2.set_xticklabels(categories)
ax2.legend()
ax2.grid(axis='y', alpha=0.3)
 
plt.tight_layout()
plt.savefig('combined_visualization.png', dpi=300, bbox_inches='tight')
plt.show()

    Quand utiliser un camembert plutôt qu’un diagramme en barres

    Les camemberts fonctionnent mieux dans des scénarios spécifiques, mais les diagrammes en barres offrent souvent des comparaisons plus lisibles.

    Utilisez un camembert lorsque :

    • Vous montrez des parts d’un tout (les pourcentages doivent totaliser 100%)
    • Vous affichez 5 catégories ou moins
    • Vous souhaitez mettre en avant un ou deux segments dominants
    • Les proportions exactes importent moins que la composition générale
    • Vous produisez des synthèses de haut niveau pour des dirigeants

    Utilisez un diagramme en barres lorsque :

    • Vous comparez des valeurs entre catégories
    • Vous affichez plus de 5 catégories
    • Vous avez besoin de comparaisons précises
    • Les valeurs ne s’additionnent pas en un tout pertinent
    • Vous affichez des tendances dans le temps
    • Les parties prenantes doivent comparer des segments de taille similaire

    Exemple de comparaison :

    import matplotlib.pyplot as plt
 
data = {'Category A': 23, 'Category B': 19, 'Category C': 18,
        'Category D': 17, 'Category E': 13, 'Category F': 10}
 
fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(14, 5))
 
# Pie chart
ax1.pie(data.values(), labels=data.keys(), autopct='%1.1f%%', startangle=90)
ax1.set_title('Pie Chart: Harder to Compare Similar Values', fontweight='bold')
 
# Bar chart
ax2.bar(data.keys(), data.values(), color='#3498db')
ax2.set_ylabel('Value', fontweight='bold')
ax2.set_title('Bar Chart: Easier to Compare Similar Values', fontweight='bold')
ax2.grid(axis='y', alpha=0.3)
 
plt.tight_layout()
plt.show()

    Le diagramme en barres rend les petites différences entre catégories beaucoup plus visibles que le camembert.

    Camemberts interactifs avec PyGWalker

    Pour une analyse exploratoire nécessitant des visualisations interactives, PyGWalker (opens in a new tab) transforme des DataFrames pandas en interfaces interactives de type Tableau, permettant de créer des camemberts en glisser-déposer.

    import pandas as pd
import pygwalker as pyg
 
# Sample DataFrame
data = {
    'Product': ['Product A', 'Product B', 'Product C', 'Product D', 'Product E'],
    'Sales': [350000, 250000, 200000, 200000, 150000],
    'Region': ['North', 'South', 'East', 'West', 'North']
}
df = pd.DataFrame(data)
 
# Launch interactive visualization interface
walker = pyg.walk(df)

    PyGWalker permet à des analystes métier sans compétences de programmation de créer des camemberts et d’autres visualisations de manière interactive, de filtrer les données dynamiquement et d’exporter les résultats pour des présentations. L’outil gère des agrégations complexes et fournit des résumés statistiques intégrés, ce qui le rend utile pour prototyper rapidement avant de finaliser des visualisations de production avec matplotlib.

    Personnalisation avancée : couleurs des bords et styles de ligne

    Ajoutez une séparation visuelle entre les secteurs en définissant la couleur des bordures et l’épaisseur des lignes via wedgeprops.

    import matplotlib.pyplot as plt
 
sizes = [35, 25, 20, 20]
labels = ['Product A', 'Product B', 'Product C', 'Product D']
colors = ['#ff9999', '#66b3ff', '#99ff99', '#ffcc99']
 
wedgeprops = {
    'edgecolor': 'black',
    'linewidth': 2,
    'linestyle': '-',
    'antialiased': True
}
 
plt.pie(sizes, labels=labels, colors=colors, autopct='%1.1f%%',
        startangle=90, wedgeprops=wedgeprops)
plt.axis('equal')
plt.title('Market Share with Edge Styling')
plt.show()

    Pour un rendu plus subtil, utilisez des bordures blanches :

    wedgeprops = {'edgecolor': 'white', 'linewidth': 3}

    Gérer les petits secteurs et le chevauchement des labels

    Avec de nombreux petits secteurs, les labels peuvent se chevaucher. Les solutions incluent l’usage d’une légende, l’augmentation de la taille de la figure ou l’ajustement du positionnement des labels.

    import matplotlib.pyplot as plt
 
# Data with several small slices
sizes = [30, 25, 15, 10, 8, 5, 4, 3]
labels = ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H']
colors = plt.cm.Set3(range(len(sizes)))
 
fig, ax = plt.subplots(figsize=(10, 8))
 
wedges, texts, autotexts = ax.pie(sizes, colors=colors, autopct='%1.1f%%',
                                    startangle=90, pctdistance=0.85)
 
# Remove labels from pie and use legend
for text in texts:
    text.set_text('')
 
ax.legend(wedges, labels, title="Categories", loc="center left",
          bbox_to_anchor=(1, 0, 0.5, 1))
ax.axis('equal')
ax.set_title('Distribution with Many Categories', fontsize=14, fontweight='bold')
 
plt.tight_layout()
plt.show()

    Sinon, affichez uniquement les pourcentages sur le graphique et placez les noms de catégories dans une légende, ce qui réduit l’encombrement visuel.

    Créer des graphiques en anneau proportionnels à plusieurs niveaux

    Construisez des visualisations hiérarchiques avancées montrant des répartitions par catégorie sur plusieurs niveaux.

    import matplotlib.pyplot as plt
import numpy as np
 
# Department budget data
departments = ['Engineering', 'Sales', 'Marketing', 'Operations']
dept_budgets = [400000, 300000, 200000, 100000]
 
# Team breakdown within departments
teams = ['Backend', 'Frontend', 'Mobile',
         'Field Sales', 'Inside Sales',
         'Digital', 'Content',
         'Logistics', 'Support']
team_budgets = [200000, 150000, 50000,
                180000, 120000,
                120000, 80000,
                60000, 40000]
 
fig, ax = plt.subplots(figsize=(12, 8))
 
# Outer ring (departments)
dept_colors = ['#e74c3c', '#3498db', '#2ecc71', '#f39c12']
outer_pie = ax.pie(dept_budgets, labels=departments, colors=dept_colors,
                    autopct='%1.1f%%', radius=1.3, wedgeprops={'width': 0.35})
 
# Inner ring (teams)
team_colors = ['#c0392b', '#e74c3c', '#ec7063',
               '#2980b9', '#3498db',
               '#27ae60', '#2ecc71',
               '#d68910', '#f39c12']
inner_pie = ax.pie(team_budgets, labels=teams, colors=team_colors,
                    autopct='%1.0f%%', radius=0.95,
                    wedgeprops={'width': 0.35}, labeldistance=0.7,
                    textprops={'fontsize': 9})
 
ax.axis('equal')
plt.title('Organizational Budget Breakdown\nDepartments and Teams',
          fontsize=16, fontweight='bold', pad=20)
plt.tight_layout()
plt.show()

    Cela crée un diagramme en anneau à deux niveaux, où l’anneau intérieur affiche les budgets des équipes correspondant aux segments “départements” de l’anneau extérieur.

    FAQ

    Comment créer un camembert de base dans matplotlib ?

    Utilisez plt.pie() avec une liste de valeurs et des labels optionnels. Ajoutez plt.axis('equal') pour garantir une forme circulaire plutôt qu’une ellipse. La syntaxe de base est plt.pie(sizes, labels=labels) puis plt.show() pour afficher le graphique.

    À quoi sert le paramètre autopct dans les camemberts matplotlib ?

    Le paramètre autopct affiche automatiquement les pourcentages sur chaque secteur. Utilisez des chaînes de format comme '%1.1f%%' pour une décimale, ou '%1.0f%%' pour des entiers. Vous pouvez aussi passer une fonction personnalisée pour afficher à la fois les pourcentages et les valeurs réelles.

    Comment créer un graphique en anneau (donut) dans matplotlib ?

    Créez un donut en définissant wedgeprops avec une valeur width inférieure à 1. Par exemple, wedgeprops={'width': 0.4} crée un anneau avec une largeur représentant 40% du rayon. Combinez cela avec plt.text() pour ajouter un libellé au centre.

    Comment “exploser” certains secteurs dans un camembert ?

    Utilisez explode avec un tuple de valeurs de décalage pour chaque secteur. Par exemple, explode=(0.1, 0, 0, 0) déplace le premier secteur vers l’extérieur de 10% du rayon et laisse les autres en place. Des valeurs plus grandes créent une séparation plus importante.

    Quand utiliser un camembert plutôt qu’un diagramme en barres ?

    Utilisez un camembert pour montrer des parts d’un tout avec 5 catégories ou moins, lorsque les pourcentages doivent totaliser 100%. Utilisez un diagramme en barres pour comparer des valeurs entre catégories, afficher plus de 5 éléments, ou lorsque la précision des comparaisons importe davantage que la composition. Les barres facilitent la comparaison de segments de taille proche.

    Comment personnaliser les couleurs dans les camemberts matplotlib ?

    Passez une liste de couleurs à colors avec des noms, des codes hexadécimaux ou des tuples RGB. Pour des couleurs pilotées par les données, utilisez des colormaps comme plt.cm.Set3 avec np.linspace() pour générer des tableaux de couleurs. Les colormaps populaires incluent Set1, Set2, Set3 et Pastel1.

    Comment ajouter une légende à un camembert au lieu d’afficher les labels sur les secteurs ?

    Appelez plt.legend() avec la liste des labels et positionnez-la avec loc et bbox_to_anchor. Par exemple, plt.legend(labels, loc='upper left', bbox_to_anchor=(1, 0, 0.5, 1)) place la légende à droite, hors du graphique. Utilisez plt.tight_layout() pour éviter qu’elle soit rognée.

    Conclusion

    Les diagrammes en secteurs matplotlib offrent un moyen puissant de visualiser des données proportionnelles lorsqu’ils sont utilisés à bon escient. Ce guide a couvert tout le spectre, des graphiques circulaires de base aux visualisations avancées en anneaux imbriqués, avec des exemples pratiques montrant les labels, les couleurs, les secteurs “explosés”, l’affichage des pourcentages et l’intégration avec des DataFrames. Le tableau de référence des paramètres sert d’aide-mémoire pour les options de personnalisation, et les exemples concrets montrent comment appliquer ces techniques à l’analyse budgétaire, aux résultats d’enquête et au reporting de parts de marché.

    Gardez à l’esprit que les camemberts fonctionnent mieux avec un nombre réduit de catégories présentant des proportions nettes, tandis que les diagrammes en barres conviennent mieux aux comparaisons détaillées. Pour une exploration interactive pendant l’analyse, PyGWalker propose une alternative sans code pour prototyper rapidement avant de finaliser des visualisations de production. En combinant ces techniques matplotlib avec des choix de conception réfléchis (quand utiliser un camembert plutôt qu’un diagramme en barres), vous pourrez créer des visualisations claires et informatives, capables de communiquer efficacement des insights à tout type de public.

    📚