Summary  
This chapter explains that simple assignment of arrays creates views sharing the same data, and demonstrates how to implement code using the ndarray.copy() method or numpy.copy() function to produce independent array copies without affecting the original.  

General domain of usage  
Data analysis

Vaak is het nodig om een **kopie** van een array te maken om wijzigingen aan te brengen zonder de originele array te beïnvloeden.

Watch this video to see how copying arrays works in NumPy. You'll learn the difference between simple assignment and true copying, how changes affect original arrays, and how to use the `copy()` method and function. Visual examples will help you understand why and when to use each approach, making your array manipulations safer and more effective.

## Eenvoudige toewijzing

Eerst bespreken we waarom we niet eenvoudigweg een andere variabele kunnen maken met `array_2 = array_1`, waarbij `array_1` onze originele array is.

import numpy as np
array_1 = np.array([1, 2, 3])
array_2 = array_1
# Setting the first element of array_2 to 10
array_2[0] = 10
print(array_1)

We hebben de waarde van het eerste element van `array_2` gewijzigd naar `10`, maar deze toewijzing heeft ook de waarde van het eerste element van `array_1` gewijzigd naar `10`.

Met `array_2 = array_1` maak je geen **nieuwe** array; in plaats daarvan maak je een **referentie** naar dezelfde array in het geheugen. Hierdoor zullen alle wijzigingen die aan `array_2` worden aangebracht, ook `array_1` beïnvloeden.

Opmerking

Om dit probleem op te lossen, zouden we `array_2 = np.array([1, 2, 3])` kunnen schrijven, maar dat betekent dat we dezelfde code **twee keer** moeten schrijven. Onthoud het belangrijkste principe bij programmeren: **Herhaal jezelf niet**.

## ndarray.copy() Methode

Gelukkig heeft **NumPy** een `ndarray.copy()` methode als oplossing voor dit probleem.

import numpy as np
array_1 = np.array([1, 2, 3])
# Copying the contents of array_1
array_2 = array_1.copy()
# Setting the first element of array_2 to 10
array_2[0] = 10
print(f'Initial array: {array_1}')
print(f'Modified copy: {array_2}')

Nu hebben we een nieuwe array aangemaakt voor `array_2` met dezelfde elementen als `array_1`.

Voor **2D** arrays is de kopieerprocedure exact hetzelfde.


## numpy.copy() Functie

In plaats van de `.copy()` **methode** kunnen we ook de `copy()` **functie** gebruiken, die de array als parameter neemt: `array_2 = np.copy(array_1)`.

Zowel de functie als de methode werken hetzelfde; er is echter één nuance. Beide hebben de parameter `order`, die de **geheugenindeling** van de array specificeert, maar hun standaardwaarden verschillen. 

De onderstaande afbeelding toont de structuur van de `sales_data_2021` array die in de opdracht wordt gebruikt:

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 feedback 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.expected_2022 = cls.sales_data_2021.copy()
        cls.expected_2022[0, -2:] = np.array([390, 370])

    def test_sales_data_copy(self):
        """1. sales_data_2022 created as an independent copy"""
        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, "sales_data_2022")
        arr_21 = getattr(module, "sales_data_2021", None)
        arr_22 = getattr(module, "sales_data_2022", None)

        type_ok = isinstance(arr_22, np.ndarray)
        # Перевіряємо, що це інший об’єкт у пам’яті
        independent_obj = arr_21 is not arr_22
        # Перевіряємо, що зміни в arr_22 не вплинули на arr_21
        independent_data = not np.array_equal(arr_21, arr_22)

        _dynamic_test(
            self,
            ok and type_ok and independent_obj and independent_data,
            "sales_data_2022 correctly created as an independent copy",
            "sales_data_2022 not created properly as a copy",
        )

    def test_sales_data_update(self):
        """2. Last two elements of first row updated using correct slice"""
        spec = importlib.util.spec_from_file_location("user_code", "user_code.py")
        module = importlib.util.module_from_spec(spec)
        spec.loader.exec_module(module)

        arr_22 = getattr(module, "sales_data_2022", None)
        type_ok = isinstance(arr_22, np.ndarray)
        val_ok = type_ok and np.array_equal(arr_22, self.expected_2022)
        first_row_ok = type_ok and np.array_equal(arr_22[0, -2:], np.array([390, 370]))
        second_row_ok = type_ok and np.array_equal(arr_22[1], self.sales_data_2021[1])

        _dynamic_test(
            self,
            type_ok and val_ok and first_row_ok and second_row_ok,
            "sales_data_2022 updated correctly with negative slice",
            "sales_data_2022 update incorrect or affects wrong elements",
        )

    def test_print_output(self):
        """3. Both arrays printed"""
        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_21 = "2021" in output and "350" in output
        printed_22 = "2022" in output and "390" in output and "370" in output

        _dynamic_test(
            self,
            printed_21 and printed_22,
            "Both sales_data_2021 and sales_data_2022 printed correctly",
            "Missing or incorrect print statements",
        )


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.

Arrays Kopiëren

Eenvoudige toewijzing

ndarray.copy() Methode

numpy.copy() Functie

Oplossing