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

**Taulukoiden yhdistäminen** on keskeinen operaatio **NumPyssa**, jossa taulukot yhdistetään tietylle akselille suurempien ja kattavampien tietoaineistojen luomiseksi. Tämä on erityisen hyödyllistä **koneoppimisessa**, jossa data on usein jaettu useisiin taulukoihin tai tallennettu erikseen, esimerkiksi kun se on peräisin **eri lähteistä**.

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.

Suuremmat, yhtenäiset tietoaineistot parantavat tyypillisesti ML-mallien ja neuroverkkojen suorituskykyä.

Opiskele lisää

Yhdistäminen tarkoittaa käytännössä taulukoiden liittämistä yhteen uuden taulukon muodostamiseksi.

**NumPyssa** on `concatenate()`-funktio, jonka avulla voit yhdistää taulukoita tietylle akselille:
* `axis=0` (oletusarvo) yhdistää taulukot riveittäin;
* `axis=1` yhdistää taulukot sarakkeittain.

Tämän funktion ensimmäinen parametri on **taulukoiden jono** (`tuple` tai `list` taulukoita), jotka yhdistetään, ja `axis` on toinen parametri.

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)

Yhdistäminen luo yksidimensionaalisen taulukon, jossa ensimmäisen taulukon alkiot **seuraavat** toisen taulukon alkioita.

Kaksidimensionaalisten taulukoiden yhdistäminen tehdään samalla tavalla, mutta sinun täytyy lisäksi määrittää `axis`-parametri:

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

Violetit alkiot vastaavat `array1`:tä ja vihreät `array2`:ta.

Voimme itse asiassa yhdistää minkä tahansa määrän taulukoita, ja se toimii samalla tavalla.

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

Avaa Pythonin tärkeimmän numeerisen laskennan kirjaston, NumPyn, koko potentiaali. Tämä kattava kurssi on suunniteltu viemään sinut aloittelijan tasolta edistyneeksi NumPy-osaajaksi. Olitpa sitten data-analyytikko, insinööri, tutkija tai kehittäjä, NumPyn hallinta on olennaista tehokkaaseen datan käsittelyyn, tieteelliseen laskentaan ja koneoppimiseen.

Tutustu NumPyn käyttökohteisiin ja ymmärrä, miksi se on yksi suosituimmista kirjastoista numeeriseen laskentaan. Opiskele erilaisia tapoja luoda ja alustaa taulukoita erilaisten tietotarpeiden tehokkaaseen käsittelyyn.

Opi, kuinka NumPy-taulukoiden yksittäisiin alkioihin ja osajoukkoihin päästään käsiksi indeksimerkinnän avulla. Tutustu ehdollisen indeksoinnin käyttöön tietojen suodattamisessa ja puuttuvien arvojen hallinnassa tehokkaasti.

NumPy tarjoaa monia sisäänrakennettuja funktioita yleisten taulukko-operaatioiden suorittamiseen. Opi käyttämään näitä työkaluja datan muuntamiseen, aggregointiin ja analysointiin tehokkaasti ilman toistuvaa koodia.

Opi suorittamaan matemaattisia operaatioita tehokkaasti NumPy-taulukoilla. Sovella näitä operaatioita todellisten ongelmien ratkaisemiseen ja syvennä ymmärrystäsi siitä, miten vektorisoidut laskutoimitukset nopeuttavat numeerista analyysiä.

Taulukoiden Yhdistäminen

Ratkaisu