Summary  
This chapter explains how to combine multiple arrays into a single array by concatenating them along a specified axis using the NumPy concatenate function, covering both one-dimensional and multidimensional cases and the effect of the axis parameter.

General domain of usage  
Machine learning

**Array-concatenatie** is een fundamentele bewerking in **NumPy** waarmee arrays langs een opgegeven as worden samengevoegd om grotere, meer uitgebreide datasets te creëren. Dit is vooral nuttig in de **machine learning**, waar gegevens vaak over meerdere arrays zijn verdeeld of afzonderlijk worden opgeslagen, bijvoorbeeld wanneer ze afkomstig zijn van **verschillende bronnen**.

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.

Grotere, uniforme datasets verbeteren doorgaans de prestaties van ML-modellen en neurale netwerken.

Meer leren

In wezen houdt **concatenatie** in dat arrays aan elkaar worden gekoppeld om een nieuwe array te vormen.

**NumPy** heeft een `concatenate()`-functie waarmee je arrays langs een opgegeven as kunt samenvoegen:
* `axis=0` (de standaardwaarde) voegt de arrays samen per rij;
* `axis=1` voegt de arrays samen per kolom.

De eerste parameter van deze functie is de **reeks arrays** (een `tuple` of `list` van arrays) die moeten worden samengevoegd, terwijl `axis` de tweede parameter is.

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)

Concatenatie creëert een 1D-array met de elementen van de eerste array **gevolgd** door de elementen van de tweede array.

Het samenvoegen van 2D-arrays gebeurt op een vergelijkbare manier, maar je moet ook de parameter `axis` specificeren:

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

De paarse elementen komen overeen met `array1`, en de groene met `array2`.

We kunnen in feite een willekeurig aantal arrays samenvoegen, en dit werkt op dezelfde manier.

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

Ontgrendel het volledige potentieel van Python's meest essentiële bibliotheek voor numerieke berekeningen, NumPy. Deze uitgebreide cursus is ontworpen om je van een basiskennis naar een gevorderd niveau van vaardigheid in NumPy te brengen. Of je nu data scientist, ingenieur, onderzoeker of ontwikkelaar bent, het beheersen van NumPy is essentieel voor efficiënte datamanipulatie, wetenschappelijk rekenen en machine learning.

Ontdek de toepassingen van NumPy en begrijp waarom het een van de populairste bibliotheken is voor numerieke berekeningen. Leer de verschillende manieren om arrays te maken en te initialiseren om efficiënt aan diverse databehoeften te voldoen.

Ontdek hoe u specifieke elementen en deelverzamelingen in NumPy-arrays kunt benaderen met behulp van indexnotatie. Leer om conditionele indexering toe te passen om gegevens te filteren en ontbrekende waarden efficiënt te beheren.

NumPy biedt veel ingebouwde functies voor het uitvoeren van veelvoorkomende arraybewerkingen. Leer hoe u deze tools kunt toepassen om gegevens efficiënt te transformeren, aggregeren en analyseren zonder repetitieve code te schrijven.

Leer hoe u wiskundige bewerkingen efficiënt uitvoert op NumPy-arrays. Pas deze bewerkingen toe om realistische problemen op te lossen en krijg een dieper inzicht in hoe gevectoriseerde berekeningen numerieke analyses versnellen.

Array-concatenatie

Oplossing