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

Outra opção comum é o **gráfico de barras agrupadas**, onde as barras de cada categoria são colocadas **lado a lado** em vez de empilhadas.

Isso é útil quando se deseja comparar categorias **entre grupos** (como setores econômicos em diferentes países), em vez de dentro de um único total.

## Etapas para Criar um Gráfico de Barras Agrupadas

1. **Definir uma largura de barra** e criar um array para as posições do eixo x usando `np.arange()`;
2. Combinar os dados das categorias em um array 2D;
3. Utilizar um `for` para desenhar cada grupo de barras com a função `bar()`, deslocando suas posições horizontalmente;
4. Personalizar as posições e rótulos dos ticks do eixo x usando `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()

### Como funciona o `xticks()`

* O **primeiro argumento** desloca as marcas dos eixos para o centro de cada grupo de barras;
* O **segundo argumento** define os rótulos usando a lista `countries`.

Essa abordagem funciona para qualquer número de categorias — basta ajustar o `width` para garantir que as barras não se sobreponham.

Nota

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

Os dados estão em toda parte ao nosso redor, e compreendê-los é extremamente importante. A visualização auxilia na análise de dados ao identificar certos padrões e insights. Você desenvolverá uma base sólida em visualização de dados utilizando Python e suas bibliotecas, como matplotlib e seaborn, para extrair o máximo de informações dos dados de forma clara e concisa.

Descubra os conceitos essenciais da visualização de dados com Matplotlib. Conheça seus conceitos centrais, explore suas vantagens e crie seu primeiro gráfico simples utilizando esta biblioteca fundamental de plotagem.

Domine a visualização de dados por meio dos tipos de gráficos mais populares. Aprenda a construir gráficos de linha, dispersão e barras para comunicar claramente insights extraídos dos seus dados.

Aprenda a tornar seus gráficos mais informativos e visualmente atraentes. Adicione títulos, legendas, cores e grades, e descubra como organizar múltiplos subgráficos de forma eficaz.

Explore visualizações estatísticas que auxiliam na análise de distribuições e padrões de dados. Crie histogramas, boxplots e gráficos de pizza para revelar insights estatísticos mais profundos.

Aprimore suas habilidades de visualização com Seaborn. Crie gráficos avançados como countplots, KDEs, pair plots e heatmaps, dominando o estilo elegante e as opções de personalização do Seaborn.

Gráficos de Barras Agrupadas

Etapas para Criar um Gráfico de Barras Agrupadas

Como funciona o `xticks()`

Solução

Gráficos de Barras Agrupadas

Etapas para Criar um Gráfico de Barras Agrupadas

Como funciona o xticks()

Solução

Como funciona o `xticks()`