Summary  
This chapter explains how to merge multiple NumPy arrays into a larger array by concatenating them along a chosen axis using the `concatenate()` function.  

General domain of usage  
Machine learning

**Array concatenation** is a fundamental operation in **NumPy** that combines arrays along a specified axis to create larger, more comprehensive datasets. This is especially useful in **machine learning**, where data is often split across multiple arrays or stored separately, such as when it comes from **different sources**.

Larger, unified datasets typically improve the performance of ML models and neural networks.

Study More

Essentially, **concatenation** involves joining arrays together to form a new array.

**NumPy** has a `concatenate()` function that enables you to concatenate arrays along a specified axis:
* `axis=0` (the default value) concatenates the arrays by rows;
* `axis=1` concatenates the arrays by columns.

The first parameter of this function is the **sequence of arrays** (a `tuple` or `list` of arrays) to concatenate, while `axis` is the second parameter.

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)

Concatenation creates a 1D array with the elements of the first array **followed** by the elements of the second array.

Concatenating 2D arrays is performed in a similar way, but you also have to specify the `axis` parameter:

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}')

The purple elements correspond to `array1`, and the green ones to `array2`.

In fact, we can concatenate any number of arrays, and it will work the same way.

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

Develop essential skills for numerical computing using NumPy. Learn how to work with NumPy arrays, create and manipulate multidimensional data, apply indexing and slicing, perform vectorized operations, reshape arrays, use broadcasting, and apply basic linear algebra techniques. The course focuses on practical operations commonly used in data analysis tasks.

Array Concatenation

Løsning