Summary  
This chapter covers how simple assignment in NumPy creates views that share data with the original array and how to create independent copies using the ndarray.copy() method or numpy.copy() function to avoid unintended modifications.

General domain of usage  
Numerical computing

Ofte er det nødvendigt at oprette en **kopi** af et array for at foretage ændringer uden at påvirke det oprindelige array.

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.

## Simpel tildeling

Først diskuteres, hvorfor du ikke blot kan oprette en anden variabel ved hjælp af `array_2 = array_1`, hvor `array_1` er dit oprindelige array.

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)

Du ændrede værdien af det første element i `array_2` til `10`, men denne tildeling ændrede også værdien af det første element i `array_1` til `10`.

Med `array_2 = array_1` opretter du ikke et **nyt** array; i stedet opretter du en **reference** til det samme array i hukommelsen. Derfor vil alle ændringer foretaget på `array_2` også påvirke `array_1`.

Bemærk

For at løse dette problem kunne du skrive `array_2 = np.array([1, 2, 3])`, men det ville betyde, at du skulle skrive den samme kode **to gange**. Husk det centrale princip i programmering: **Gentag ikke dig selv**.

## ndarray.copy() Metode

Heldigvis har **NumPy** en `ndarray.copy()` metode som løsning på dette problem.

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 har du oprettet et nyt array for `array_2` med de samme elementer som `array_1`.

For **2D** arrays er kopieringsproceduren præcis den samme.


## numpy.copy() Funktion

I stedet for `.copy()` **metoden** kan du også bruge `copy()` **funktionen**, som tager arrayet som sin parameter: `array_2 = np.copy(array_1)`.

Både funktionen og metoden fungerer på samme måde; dog er der én nuance. Begge har parameteren `order`, som angiver **hukommelseslayoutet** for arrayet, men deres standardværdier er forskellige.


Billedet nedenfor viser strukturen af `sales_data_2021` arrayet, der bruges i opgaven:

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

Lås op for det fulde potentiale af Pythons mest essentielle bibliotek til numerisk beregning, NumPy. Dette omfattende kursus er designet til at tage dig fra et begynderforståelse til et avanceret niveau af færdigheder i NumPy. Uanset om du er data scientist, ingeniør, forsker eller udvikler, er det afgørende at mestre NumPy for effektiv datamanipulation, videnskabelig beregning og maskinlæring.

Udforsk anvendelserne af NumPy og forstå, hvorfor det er et af de mest populære biblioteker til numerisk databehandling. Lær de forskellige måder at oprette og initialisere arrays på for effektivt at håndtere forskellige databehov.

Opdag, hvordan man får adgang til specifikke elementer og delmængder i NumPy-arrays ved hjælp af indeksnotation. Lær at anvende betinget indeksering til at filtrere data og håndtere manglende værdier effektivt.

NumPy tilbyder mange indbyggede funktioner til at udføre almindelige array-operationer. Lær, hvordan disse værktøjer kan anvendes til effektivt at transformere, aggregere og analysere data uden at skrive gentagen kode.

Lær at udføre matematiske operationer effektivt på NumPy-arrays. Anvend disse operationer til at løse virkelige problemer og opnå en dybere forståelse af, hvordan vektoriserede beregninger accelererer numerisk analyse.

Kopiering af Arrays

Simpel tildeling

ndarray.copy() Metode

numpy.copy() Funktion

Løsning