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

Een andere veelgebruikte optie is een **gegroepeerde staafdiagram**, waarbij de staven voor elke categorie **naast elkaar** worden geplaatst in plaats van gestapeld.

Dit is nuttig wanneer categorieën **tussen groepen** (zoals economische sectoren in verschillende landen) moeten worden vergeleken, in plaats van binnen één totaal.

## Stappen voor het maken van een gegroepeerde staafdiagram

1. **Stel een staafbreedte in** en maak een array voor de x-asposities met `np.arange()`;
2. Combineer de categoriedata in een 2D-array;
3. Gebruik een `for`-lus om elke groep staven te tekenen met de functie `bar()`, waarbij de posities horizontaal worden verschoven;
4. Pas de posities en labels van de x-as-ticks aan met `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()

### Hoe `xticks()` Werkt

* Het **eerste argument** verschuift de markeringen naar het midden van elke groep balken;
* Het **tweede argument** stelt de labels in met behulp van de lijst `countries`.

Deze methode werkt voor elk aantal categorieën — pas gewoon de `width` aan om te voorkomen dat de balken overlappen.

Opmerking

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

Data is overal om ons heen, en het begrijpen ervan is van groot belang. Visualisatie helpt bij het analyseren van data door patronen en inzichten te ontdekken. Je ontwikkelt een degelijke basis in datavisualisatie met Python en de bijbehorende bibliotheken, zoals matplotlib en seaborn, om zo veel mogelijk informatie uit data te halen op een overzichtelijke en beknopte manier.

Ontdek de basisprincipes van datavisualisatie met Matplotlib. Maak kennis met de kernconcepten, verken de voordelen en maak een eerste eenvoudige grafiek met deze fundamentele plotbibliotheek.

Beheers het visualiseren van data met de meest populaire grafiektypen. Leer lijn-, spreidings- en staafdiagrammen te bouwen om inzichten uit uw data duidelijk over te brengen.

Leer hoe u uw plots informatiever en visueel aantrekkelijker maakt. Voeg titels, legenda's, kleuren en rasters toe en ontdek hoe u meerdere subplotten effectief kunt rangschikken.

Verken statistische visualisaties die helpen bij het analyseren van gegevensverdelingen en patronen. Maak histogrammen, boxplots en cirkeldiagrammen om diepere statistische inzichten te verkrijgen.

Breng uw visualisatievaardigheden naar een hoger niveau met Seaborn. Maak geavanceerde grafieken zoals countplots, KDE's, pair plots en heatmaps, terwijl u de elegante stijl en aanpassingsmogelijkheden van Seaborn beheerst.

Gegroepeerde Staafdiagrammen

Stappen voor het maken van een gegroepeerde staafdiagram

Hoe `xticks()` Werkt

Oplossing

Gegroepeerde Staafdiagrammen

Stappen voor het maken van een gegroepeerde staafdiagram

Hoe xticks() Werkt

Oplossing

Hoe `xticks()` Werkt