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

Et annet vanlig alternativ er et **gruppert stolpediagram**, der stolpene for hver kategori plasseres **side om side** i stedet for å stables.

Dette er nyttig når du ønsker å sammenligne kategorier **på tvers av grupper** (for eksempel økonomiske sektorer i ulike land), i stedet for innenfor én total.

## Fremgangsmåte for å lage et gruppert stolpediagram

1. **Angi en stolpebredde** og opprett et array for x-akseposisjoner med `np.arange()`;
2. Kombiner kategoridataene dine i et 2D-array;
3. Bruk en `for`-løkke for å tegne hver gruppe av stolper med funksjonen `bar()`, og forskyv posisjonene horisontalt;
4. Tilpass x-aksens posisjoner og 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()

### Hvordan `xticks()` fungerer

* **Første argument** flytter avmerkingslinjene til midten av hver gruppe med stolper;
* **Andre argument** setter etikettene ved å bruke listen `countries`.

Denne metoden fungerer for et hvilket som helst antall kategorier — juster bare `width` for å sikre at stolpene ikke overlapper.

Merk

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 finnes overalt rundt oss, og det er svært viktig å kunne tolke det. Visualisering hjelper deg å håndtere data ved å finne bestemte mønstre og innsikter. Du vil utvikle et solid grunnlag i datavisualisering ved bruk av Python og dets biblioteker, som matplotlib og seaborn, for å hente ut mest mulig informasjon fra data på en ryddig og presis måte.

Oppdag det grunnleggende innen datavisualisering med Matplotlib. Lær om kjernebegrepene, utforsk fordelene, og lag din første enkle graf med dette grunnleggende biblioteket for plotting.

Behersk visualisering av data gjennom de mest populære diagramtypene. Lær å bygge linje-, punkt- og stolpediagrammer for å formidle innsikt fra dataene dine på en tydelig måte.

Lær å gjøre diagrammene dine mer informative og visuelt tiltalende. Legg til titler, forklaringer, farger og rutenett, og oppdag hvordan du effektivt kan arrangere flere delplott.

Utforsk statistiske visualiseringer som hjelper med å analysere datadistribusjoner og mønstre. Lag histogrammer, boksdiagrammer og sektordiagrammer for å avdekke dypere statistiske innsikter.

Ta visualiseringsevner til neste nivå med Seaborn. Lag avanserte diagrammer som countplot, KDE, pair plot og heatmap, samtidig som du mestrer Seaborns elegante stil og tilpasningsmuligheter.

Grupperte Stolpediagrammer

Fremgangsmåte for å lage et gruppert stolpediagram

Hvordan `xticks()` fungerer

Løsning

Grupperte Stolpediagrammer

Fremgangsmåte for å lage et gruppert stolpediagram

Hvordan xticks() fungerer

Løsning

Hvordan `xticks()` fungerer