Summary  
Shows how to implement code that calculates and applies horizontal offsets for grouped bar charts by iterating through series arrays and setting x-axis tick labels accordingly.

General domain of usage  
Data visualization

Une autre option courante est un **diagramme à barres groupées**, où les barres de chaque catégorie sont placées **côte à côte** au lieu d'être empilées.

Cela est utile lorsque l'objectif est de comparer des catégories **entre différents groupes** (comme les secteurs économiques dans différents pays), plutôt qu'au sein d'un total unique.

## Étapes pour créer un diagramme à barres groupées

1. **Définir une largeur de barre** et créer un tableau pour les positions de l’axe des x à l’aide de `np.arange()` ;
2. Combiner les données des catégories dans un tableau 2D ;
3. Utiliser une boucle `for` pour tracer chaque groupe de barres avec la fonction `bar()`, en décalant leurs positions horizontalement ;
4. Personnaliser les positions et les étiquettes des graduations de l’axe des x à l’aide de `plt.xticks()`.

import matplotlib.pyplot as plt
import numpy as np

# Labels and data
countries = ['USA', 'China', 'Japan']
positions = np.arange(len(countries))

primary = np.array([1.4, 4.8, 0.4])
secondary = np.array([11.3, 6.2, 0.8])
tertiary = np.array([14.2, 8.4, 3.2])

# Group the data
sectors = np.array([primary, secondary, tertiary])

# Width of each bar
width = 0.25

# Plot each group of bars
for i in range(len(sectors)):
    plt.bar(positions + width * i, sectors[i], width)

# Center the group of bars and label the ticks
plt.xticks(positions + width, countries)

plt.show()

### Fonctionnement de `xticks()`

* Le **premier argument** déplace les repères de graduation vers le centre de chaque groupe de barres ;
* Le **deuxième argument** définit les étiquettes à l'aide de la liste `countries`.

Cette méthode fonctionne pour n'importe quel nombre de catégories — il suffit d'ajuster la valeur de `width` pour éviter que les barres ne se chevauchent.

Remarque

import unittest
import ast
import inspect
import user_code


def _dynamic_test(test_case, condition, success_message, failure_message):
    if condition:
        test_case._testMethodName = success_message
        test_case.assertTrue(True, success_message)
    else:
        test_case._testMethodName = failure_message
        test_case.fail(failure_message)


class TestGroupedBarChart(unittest.TestCase):

    @classmethod
    def setUpClass(cls):
        source = inspect.getsource(user_code)
        cls.tree = ast.parse(source)

        cls.for_loops = [
            node for node in ast.walk(cls.tree)
            if isinstance(node, ast.For)
        ]

        cls.bar_calls = [
            node for node in ast.walk(cls.tree)
            if isinstance(node, ast.Call)
            and isinstance(node.func, ast.Attribute)
            and node.func.attr == 'bar'
        ]

    def test_correct_array_in_len(self):
        try:
            loop = self.for_loops[0]
            arg_to_len = None

            # Check if the loop uses range(len(answers))
            if (isinstance(loop.iter, ast.Call)
                and isinstance(loop.iter.func, ast.Name)
                and loop.iter.func.id == 'range'):

                inner_call = loop.iter.args[0]
                if (isinstance(inner_call, ast.Call)
                    and isinstance(inner_call.func, ast.Name)
                    and inner_call.func.id == 'len'):

                    arg_to_len = inner_call.args[0].id if isinstance(inner_call.args[0], ast.Name) else None

            _dynamic_test(
                self,
                arg_to_len == 'answers',
                "Correct array used inside len() for loop: `len(answers)`",
                f"Expected `len(answers)`, but got `len({arg_to_len})`"
            )
        except Exception:
            self.fail("Missing or incorrect `for` loop structure.")

    def test_bar_function_used(self):
        _dynamic_test(
            self,
            len(self.bar_calls) > 0,
            "plt.bar() is used to create bars",
            "Missing plt.bar() call"
        )

    def test_correct_expression_for_x_positions(self):
        try:
            call = self.bar_calls[0]
            expr = call.args[0]
            left = expr.left.id
            right = expr.right

            _dynamic_test(
                self,
                isinstance(expr, ast.BinOp) and isinstance(expr.op, ast.Add)
                and left == 'positions'
                and isinstance(right, ast.BinOp)
                and isinstance(right.op, ast.Mult)
                and right.left.id == 'width'
                and right.right.id == 'i',
                "Correct expression for x-axis positions: positions + width * i",
                "Incorrect expression used for calculating bar positions"
            )
        except Exception:
            self.fail("Missing or invalid argument structure for x-axis positioning in plt.bar().")

    def test_correct_indexing_into_answers(self):
        try:
            call = self.bar_calls[0]
            arg = call.args[1]

            _dynamic_test(
                self,
                isinstance(arg, ast.Subscript)
                and arg.value.id == 'answers'
                and arg.slice.id == 'i',
                "Correctly indexing `answers[i]` for bar heights",
                "Incorrect indexing into answers array in plt.bar()"
            )
        except Exception:
            self.fail("Invalid or missing answers[i] indexing for bar height.")

    def test_correct_width_argument(self):
        try:
            call = self.bar_calls[0]
            width_arg = call.args[2]

            _dynamic_test(
                self,
                isinstance(width_arg, ast.Name) and width_arg.id == 'width',
                "Correct use of `width` as third argument in plt.bar()",
                f"Expected third argument to be `width`, found `{getattr(width_arg, 'id', str(width_arg))}`"
            )
        except Exception:
            self.fail("Missing or incorrect third argument in plt.bar().")


if __name__ == '__main__':
    unittest.main()

test_grouped_bar_charts.py

Les données sont omniprésentes autour de nous, et leur interprétation est essentielle. La visualisation permet d’analyser les données en identifiant certains motifs et informations clés. Vous acquerrez des bases solides en visualisation de données avec Python et ses bibliothèques, telles que matplotlib et seaborn, afin d’extraire un maximum d’informations de manière claire et concise.

Découvrez les principes fondamentaux de la visualisation de données avec Matplotlib. Comprenez ses concepts clés, explorez ses avantages et réalisez un premier graphique simple à l'aide de cette bibliothèque de visualisation essentielle.

Maîtriser la visualisation des données à travers les types de graphiques les plus populaires. Apprendre à construire des graphiques linéaires, de dispersion et à barres pour communiquer clairement les informations issues des données.

Apprenez à rendre vos graphiques plus informatifs et attrayants visuellement. Ajoutez des titres, des légendes, des couleurs et des grilles, et découvrez comment organiser efficacement plusieurs sous-graphiques.

Explorer des visualisations statistiques permettant d’analyser les distributions et les tendances des données. Créer des histogrammes, des boîtes à moustaches et des diagrammes circulaires pour révéler des informations statistiques approfondies.

Améliorez vos compétences en visualisation avec Seaborn. Créez des graphiques avancés tels que les countplots, KDE, pair plots et heatmaps tout en maîtrisant le style élégant et les options de personnalisation de Seaborn.

Diagrammes à Barres Groupées

Étapes pour créer un diagramme à barres groupées

Fonctionnement de `xticks()`

Solution

Diagrammes à Barres Groupées

Étapes pour créer un diagramme à barres groupées

Fonctionnement de xticks()

Solution

Fonctionnement de `xticks()`