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

Otra opción común es un **gráfico de barras agrupadas**, donde las barras de cada categoría se colocan **una al lado de la otra** en lugar de apilarlas.

Esto es útil cuando se desea comparar categorías **entre grupos** (como sectores económicos en diferentes países), en lugar de dentro de un solo total.

## Pasos para crear un gráfico de barras agrupadas

1. **Definir un ancho de barra** y crear un arreglo para las posiciones del eje x usando `np.arange()`;
2. Combinar los datos de las categorías en un arreglo 2D;
3. Utilizar un bucle `for` para dibujar cada grupo de barras con la función `bar()`, desplazando sus posiciones horizontalmente;
4. Personalizar las posiciones y etiquetas de las marcas del eje 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()

### Cómo funciona `xticks()`

* El **primer argumento** desplaza las marcas de graduación al centro de cada grupo de barras;
* El **segundo argumento** establece las etiquetas utilizando la lista `countries`.

Este método funciona para cualquier número de categorías; solo ajusta el `width` para asegurarte de que las barras no se superpongan.

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

Los datos están en todas partes a nuestro alrededor, y comprenderlos es sumamente importante. La visualización ayuda a manejar los datos al identificar ciertos patrones y obtener información relevante. Desarrollará una base sólida en visualización de datos utilizando Python y sus bibliotecas, como matplotlib y seaborn, para extraer la mayor cantidad de información posible de los datos de manera clara y concisa.

Descubra los aspectos esenciales de la visualización de datos con Matplotlib. Conozca sus conceptos fundamentales, explore sus ventajas y cree su primer gráfico simple utilizando esta biblioteca básica de gráficos.

Domina la visualización de datos mediante los tipos de gráficos más populares. Aprende a construir gráficos de líneas, dispersión y barras para comunicar claramente los hallazgos de tus datos.

Aprenda a hacer que sus gráficos sean más informativos y visualmente atractivos. Añada títulos, leyendas, colores y cuadrículas, y descubra cómo organizar múltiples subgráficos de manera efectiva.

Explora visualizaciones estadísticas que ayudan a analizar distribuciones y patrones de datos. Crea histogramas, diagramas de caja y gráficos de pastel para descubrir conocimientos estadísticos más profundos.

Lleve sus habilidades de visualización al siguiente nivel con Seaborn. Cree gráficos avanzados como countplots, KDE, pair plots y mapas de calor, dominando el estilo elegante y las opciones de personalización de Seaborn.

Gráficos de Barras Agrupadas

Pasos para crear un gráfico de barras agrupadas

Cómo funciona `xticks()`

Solución

Gráficos de Barras Agrupadas

Pasos para crear un gráfico de barras agrupadas

Cómo funciona xticks()

Solución

Cómo funciona `xticks()`