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-Konkatenation** ist eine grundlegende Operation in **NumPy**, die Arrays entlang einer angegebenen Achse kombiniert, um größere, umfassendere Datensätze zu erstellen. Dies ist besonders nützlich im **maschinellen Lernen**, wo Daten häufig auf mehrere Arrays verteilt oder separat gespeichert sind, beispielsweise wenn sie aus **verschiedenen Quellen** stammen.

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.

Größere, einheitliche Datensätze verbessern in der Regel die Leistung von ML-Modellen und neuronalen Netzwerken.

Mehr erfahren

Im Wesentlichen bedeutet **Konkatenation**, dass Arrays zusammengefügt werden, um ein neues Array zu bilden.

**NumPy** bietet die Funktion `concatenate()`, mit der Sie Arrays entlang einer angegebenen Achse zusammenfügen können:
* `axis=0` (Standardwert) verbindet die Arrays zeilenweise;
* `axis=1` verbindet die Arrays spaltenweise.

Der erste Parameter dieser Funktion ist die **Sequenz von Arrays** (ein `tuple` oder `list` von Arrays), die zusammengefügt werden sollen, während `axis` der zweite Parameter ist.

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)

Die Verkettung erzeugt ein 1D-Array, bei dem die Elemente des ersten Arrays **gefolgt** von den Elementen des zweiten Arrays stehen.

Das Verketten von 2D-Arrays erfolgt auf ähnliche Weise, allerdings muss zusätzlich der Parameter `axis` angegeben werden:

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

Die violetten Elemente entsprechen `array1`, und die grünen gehören zu `array2`.

Tatsächlich können beliebig viele Arrays zusammengefügt werden, und es funktioniert auf die gleiche Weise.

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

Entfesseln Sie das volle Potenzial von Pythons wichtigster Bibliothek für numerisches Rechnen, NumPy. Dieser umfassende Kurs ist darauf ausgelegt, Sie von grundlegenden Kenntnissen bis hin zu fortgeschrittener NumPy-Kompetenz zu führen. Ob Datenwissenschaftler, Ingenieur, Forscher oder Entwickler – die Beherrschung von NumPy ist unerlässlich für effiziente Datenmanipulation, wissenschaftliches Rechnen und maschinelles Lernen.

Erkunden Sie die Anwendungen von NumPy und verstehen Sie, warum es eine der beliebtesten Bibliotheken für numerische Berechnungen ist. Lernen Sie die verschiedenen Methoden zur Erstellung und Initialisierung von Arrays kennen, um unterschiedliche Datenanforderungen effizient zu bewältigen.

Erfahren Sie, wie Sie mit Indexnotation auf bestimmte Elemente und Teilmengen in NumPy-Arrays zugreifen. Lernen Sie, bedingte Indizierung anzuwenden, um Daten zu filtern und fehlende Werte effizient zu verwalten.

NumPy bietet viele integrierte Funktionen zur Durchführung gängiger Array-Operationen. Lernen Sie, wie Sie diese Werkzeuge anwenden, um Daten effizient zu transformieren, zu aggregieren und zu analysieren, ohne wiederholten Code schreiben zu müssen.

Erfahren Sie, wie mathematische Operationen effizient auf NumPy-Arrays durchgeführt werden. Wenden Sie diese Operationen an, um reale Probleme zu lösen, und gewinnen Sie ein tieferes Verständnis dafür, wie vektorisierte Berechnungen die numerische Analyse beschleunigen.

Array-Konkatenation

Lösung