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

Ett annat vanligt alternativ är ett **grupperat stapeldiagram**, där staplarna för varje kategori placeras **sida vid sida** istället för att staplas på varandra.

Detta är användbart när du vill jämföra kategorier **mellan grupper** (till exempel ekonomiska sektorer i olika länder), snarare än inom en total.

## Steg för att skapa ett grupperat stapeldiagram

1. **Ange en stapelbredd** och skapa en array för x-axelns positioner med `np.arange()`;
2. Kombinera din kategoridata i en 2D-array;
3. Använd en `for`-loop för att rita varje grupp av staplar med funktionen `bar()`, och förskjut deras positioner horisontellt;
4. Anpassa x-axelns tick-positioner och etiketter med `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()

### Hur `xticks()` fungerar

* **Första argumentet** flyttar fästpunkterna till mitten av varje grupp av staplar;
* **Andra argumentet** anger etiketterna med hjälp av listan `countries`.

Denna metod fungerar för valfritt antal kategorier — justera bara `width` för att säkerställa att staplarna inte överlappar varandra.

Observera

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 finns överallt omkring oss, och att förstå den är oerhört viktigt. Visualisering hjälper dig att hantera data genom att identifiera vissa mönster och insikter. Du kommer att bygga en gedigen grund inom datavisualisering med Python och dess bibliotek, såsom matplotlib och seaborn, för att få ut så mycket information som möjligt ur data på ett snyggt och koncist sätt.

Upptäck grunderna i datavisualisering med Matplotlib. Lär dig dess kärnkoncept, utforska dess fördelar och skapa ditt första enkla diagram med detta grundläggande visualiseringsbibliotek.

Bemästra hur du visualiserar data med de mest populära diagramtyperna. Lär dig att skapa linje-, punkt- och stapeldiagram för att tydligt kommunicera insikter från din data.

Lär dig göra dina diagram mer informativa och visuellt tilltalande. Lägg till titlar, förklaringar, färger och rutnät, samt upptäck hur du effektivt arrangerar flera delplottar.

Utforska statistiska visualiseringar som hjälper till att analysera datadistributioner och mönster. Skapa histogram, lådagram och cirkeldiagram för att avslöja djupare statistiska insikter.

Ta dina visualiseringskunskaper till nästa nivå med Seaborn. Skapa avancerade diagram såsom countplots, KDE, parplottar och värmekartor samtidigt som du behärskar Seaborns eleganta stil och anpassningsmöjligheter.

Grupperade Stapeldiagram

Steg för att skapa ett grupperat stapeldiagram

Hur `xticks()` fungerar

Lösning

Grupperade Stapeldiagram

Steg för att skapa ett grupperat stapeldiagram

Hur xticks() fungerar

Lösning

Hur `xticks()` fungerar