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

Eine weitere gängige Option ist das **gruppierte Balkendiagramm**, bei dem die Balken für jede Kategorie **nebeneinander** statt übereinander angeordnet werden.

Dies ist nützlich, wenn Kategorien **über Gruppen hinweg** verglichen werden sollen (wie Wirtschaftssektoren in verschiedenen Ländern), anstatt innerhalb einer Gesamtsumme.

## Schritte zur Erstellung eines gruppierten Balkendiagramms

1. **Balkenbreite festlegen** und ein Array für die x-Achsen-Positionen mit `np.arange()` erstellen;
2. Kategoriedaten in einem 2D-Array zusammenfassen;
3. Mit einer `for`-Schleife jede Gruppe von Balken mit der Funktion `bar()` zeichnen und deren Positionen horizontal verschieben;
4. Die Positionen und Beschriftungen der x-Achsen-Ticks mit `plt.xticks()` anpassen.

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()

### Funktionsweise von `xticks()`

* Das **erste Argument** verschiebt die Achsenmarkierungen in die Mitte jeder Balkengruppe;
* Das **zweite Argument** setzt die Beschriftungen mithilfe der Liste `countries`.

Dieser Ansatz funktioniert für jede Anzahl von Kategorien — passe einfach die `width` an, um sicherzustellen, dass sich die Balken nicht überlappen.

Hinweis

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

Daten sind überall um uns herum, und ihre Interpretation ist von großer Bedeutung. Visualisierung unterstützt Sie dabei, Daten zu analysieren, indem sie bestimmte Muster und Erkenntnisse sichtbar macht. Sie erwerben ein fundiertes Verständnis der Datenvisualisierung mit Python und dessen Bibliotheken wie matplotlib und seaborn, um möglichst viele Informationen aus Daten auf übersichtliche und prägnante Weise zu gewinnen.

Entdecken Sie die Grundlagen der Datenvisualisierung mit Matplotlib. Lernen Sie die zentralen Konzepte kennen, erkunden Sie die Vorteile und erstellen Sie Ihr erstes einfaches Diagramm mit dieser grundlegenden Plot-Bibliothek.

Beherrschen Sie die Visualisierung von Daten mit den beliebtesten Diagrammtypen. Erlernen Sie die Erstellung von Linien-, Streu- und Balkendiagrammen zur klaren Vermittlung von Erkenntnissen aus Ihren Daten.

Erfahren Sie, wie Sie Ihre Diagramme informativer und ansprechender gestalten. Fügen Sie Titel, Legenden, Farben und Raster hinzu und entdecken Sie, wie Sie mehrere Teilplots effektiv anordnen.

Erkunden Sie statistische Visualisierungen, die bei der Analyse von Datenverteilungen und Mustern unterstützen. Erstellen Sie Histogramme, Boxplots und Kreisdiagramme, um tiefere statistische Einblicke zu gewinnen.

Verbessern Sie Ihre Visualisierungsfähigkeiten mit Seaborn. Erstellen Sie fortgeschrittene Diagramme wie Countplots, KDEs, Pair Plots und Heatmaps und beherrschen Sie Seaborns eleganten Stil sowie Anpassungsoptionen.

Gruppierte Balkendiagramme

Schritte zur Erstellung eines gruppierten Balkendiagramms

Funktionsweise von `xticks()`

Lösung

Gruppierte Balkendiagramme

Schritte zur Erstellung eines gruppierten Balkendiagramms

Funktionsweise von xticks()

Lösung

Funktionsweise von `xticks()`