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

En anden almindelig mulighed er et **grupperet søjlediagram**, hvor søjlerne for hver kategori placeres **side om side** i stedet for at blive stablet.

Dette er nyttigt, når du ønsker at sammenligne kategorier **på tværs af grupper** (som økonomiske sektorer i forskellige lande), snarere end inden for én samlet mængde.

## Trin til at oprette et grupperet søjlediagram

1. **Angiv en søjlebredde** og opret et array til x-akse positioner ved hjælp af `np.arange()`;
2. Kombiner dine kategoridata i et 2D-array;
3. Brug en `for`-løkke til at tegne hver gruppe af søjler med funktionen `bar()`, og forskyd deres positioner vandret;
4. Tilpas x-aksens tick-positioner og etiketter ved hjælp af `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()

### Sådan fungerer `xticks()`

* **Første argument** flytter mærkerne til midten af hver gruppe af søjler;
* **Andet argument** angiver etiketterne ved hjælp af listen `countries`.

Denne metode fungerer for et vilkårligt antal kategorier — juster blot `width` for at sikre, at søjlerne ikke overlapper.

Bemærk

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 er overalt omkring os, og det er yderst vigtigt at kunne forstå det. Visualisering hjælper dig med at håndtere data ved at finde bestemte mønstre og indsigter. Du opbygger et solidt fundament inden for datavisualisering ved hjælp af Python og dets biblioteker, såsom matplotlib og seaborn, for at udtrække så meget information som muligt fra data på en overskuelig og præcis måde.

Opdag det grundlæggende inden for datavisualisering med Matplotlib. Lær dets kernekoncepter, udforsk dets fordele, og opret dit første enkle plot ved hjælp af dette fundamentale plotbibliotek.

Opnå færdigheder i at visualisere data gennem de mest populære diagramtyper. Lær at opbygge linje-, punkt- og søjlediagrammer for tydelig formidling af indsigter fra dine data.

Lær at gøre dine plots mere informative og visuelt tiltalende. Tilføj titler, signaturforklaringer, farver og gitterlinjer, og opdag hvordan du effektivt arrangerer flere underplots.

Udforsk statistiske visualiseringer, der hjælper med at analysere datadistributioner og mønstre. Opret histogrammer, boksplot og cirkeldiagrammer for at afdække dybere statistiske indsigter.

Forbedr dine visualiseringsevner med Seaborn. Opret avancerede diagrammer såsom countplots, KDE'er, parplots og heatmaps, mens du mestrer Seaborns elegante stil og tilpasningsmuligheder.

Grupperede Søjlediagrammer

Trin til at oprette et grupperet søjlediagram

Sådan fungerer `xticks()`

Løsning

Grupperede Søjlediagrammer

Trin til at oprette et grupperet søjlediagram

Sådan fungerer xticks()

Løsning

Sådan fungerer `xticks()`