Summary  
Array concatenation merges multiple arrays into a single array by stacking them along a specified axis using NumPy’s concatenate function.

General domain of usage  
Machine learning

La **concatenación de arrays** es una operación fundamental en **NumPy** que combina arrays a lo largo de un eje especificado para crear conjuntos de datos más grandes y completos. Esto es especialmente útil en **aprendizaje automático**, donde los datos suelen estar divididos en varios arrays o almacenados por separado, como cuando provienen de **diferentes fuentes**.

Watch this video for a step-by-step visual explanation of array concatenation in NumPy. You'll see how to join one-dimensional and two-dimensional arrays along different axes, understand the role of the 'axis' parameter, and observe practical examples that reinforce the concepts covered in this chapter. This demonstration will help you confidently use array concatenation for data analysis and machine learning tasks.

Los conjuntos de datos más grandes y unificados suelen mejorar el rendimiento de los modelos de ML y redes neuronales.

Estudiar más

En esencia, la **concatenación** consiste en unir arrays para formar un nuevo array.

**NumPy** dispone de la función `concatenate()` que permite concatenar arrays a lo largo de un eje especificado:
* `axis=0` (valor predeterminado) concatena los arrays por filas;
* `axis=1` concatena los arrays por columnas.

El primer parámetro de esta función es la **secuencia de arrays** (una `tuple` o `list` de arrays) a concatenar, mientras que `axis` es el segundo parámetro.

import numpy as np
array1 = np.array([1, 2, 3])
array2 = np.array([4, 5, 6])
# Concatenating 1D arrays along their only axis 0
concatenated_array = np.concatenate((array1, array2))
print(concatenated_array)

La concatenación crea un arreglo unidimensional con los elementos del primer arreglo **seguidos** por los elementos del segundo arreglo.

La concatenación de arreglos bidimensionales se realiza de manera similar, pero también es necesario especificar el parámetro `axis`:

import numpy as np
array1 = np.array([[1, 2], [3, 4]])
array2 = np.array([[5, 6], [7, 8]])
# Concatenating along the axis 0 (rows)
concatenated_array_rows = np.concatenate((array1, array2))
print(f'Axis = 0:\n{concatenated_array_rows}')
# Concatenating along the axis 1 (columns)
concatenated_array_columns = np.concatenate((array1, array2), axis=1)
print(f'Axis = 1:\n{concatenated_array_columns}')

Los elementos morados corresponden a `array1`, y los verdes a `array2`.

De hecho, se puede concatenar cualquier cantidad de arrays, y funcionará de la misma manera.

import unittest
import importlib.util
import numpy as np
import io
from contextlib import redirect_stdout


def _dynamic_test(test_case, condition, success_message, failure_message):
    """Codefinity-style test output"""
    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 TestUserCode(unittest.TestCase):
    @classmethod
    def setUpClass(cls):
        # Початкові дані
        cls.sales_data_2021 = np.array([[350, 420, 380, 410],
                                        [270, 320, 290, 310]])
        cls.sales_data_2022 = np.array([[370, 430, 400, 390],
                                        [280, 330, 300, 370]])
        # Очікуваний результат об’єднання по стовпцях
        cls.expected_combined = np.concatenate(
            (cls.sales_data_2021, cls.sales_data_2022), axis=1
        )

    def test_concatenation_by_columns(self):
        """1–2. Sales data concatenated by columns with 2022 data following 2021"""
        spec = importlib.util.spec_from_file_location("user_code", "user_code.py")
        module = importlib.util.module_from_spec(spec)
        spec.loader.exec_module(module)

        ok = hasattr(module, "combined_sales_by_product")
        arr = getattr(module, "combined_sales_by_product", None)
        type_ok = isinstance(arr, np.ndarray)
        shape_ok = type_ok and arr.shape == self.expected_combined.shape
        val_ok = type_ok and np.array_equal(arr, self.expected_combined)

        # Перевірка, що об’єднання відбулося саме по стовпцях (axis=1)
        correct_axis = type_ok and arr.shape[1] == (
            self.sales_data_2021.shape[1] + self.sales_data_2022.shape[1]
        )

        # Перевірка, що друга половина — це саме дані 2022 року
        follows_ok = type_ok and np.array_equal(
            arr[:, -self.sales_data_2022.shape[1]:], self.sales_data_2022
        )

        _dynamic_test(
            self,
            ok and type_ok and shape_ok and val_ok and correct_axis and follows_ok,
            "Sales data concatenated correctly by columns with 2022 data following 2021",
            "Sales data concatenation incorrect (axis or order wrong)",
        )

    def test_print_output(self):
        """Перевірка, що результат надруковано"""
        f = io.StringIO()
        spec = importlib.util.spec_from_file_location("user_code", "user_code.py")
        module = importlib.util.module_from_spec(spec)
        with redirect_stdout(f):
            spec.loader.exec_module(module)
        output = f.getvalue()

        printed_phrase = "Combined sales by product" in output
        printed_values = all(str(x) in output for x in [350, 430, 370])
        _dynamic_test(
            self,
            printed_phrase and printed_values,
            "Combined sales printed correctly",
            "Print statement missing or incorrect",
        )


if __name__ == "__main__":
    unittest.main()


test_code.py

Desbloquea todo el potencial de la biblioteca más esencial de Python para el cálculo numérico, NumPy. Este curso integral está diseñado para llevarte desde un nivel principiante hasta un nivel avanzado de competencia en NumPy. Ya seas científico de datos, ingeniero, investigador o desarrollador, dominar NumPy es fundamental para la manipulación eficiente de datos, el cálculo científico y el aprendizaje automático.

Explora las aplicaciones de NumPy y comprende por qué es una de las bibliotecas más populares para el cálculo numérico. Aprende las diferentes formas de crear e inicializar arreglos para manejar diversas necesidades de datos de manera eficiente.

Descubre cómo acceder a elementos específicos y subconjuntos en arreglos de NumPy utilizando la notación de índices. Aprende a aplicar indexación condicional para filtrar datos y gestionar valores faltantes de manera eficiente.

NumPy ofrece muchas funciones integradas para realizar operaciones comunes con arreglos. Aprenda cómo aplicar estas herramientas para transformar, agregar y analizar datos de manera eficiente sin escribir código repetitivo.

Aprende a realizar operaciones matemáticas de manera eficiente en arreglos de NumPy. Aplica estas operaciones para resolver problemas del mundo real y adquiere una comprensión más profunda de cómo los cálculos vectorizados aceleran el análisis numérico.

Concatenación de arrays

Solución