Summary  
This chapter explains how to create independent copies of arrays—avoiding shared references—by using the ndarray.copy() method or the numpy.copy() function (including their memory‐layout options) and shows the impact when printing original versus copied arrays.

General domain of usage  
Data analysis

Often, you need to create a **copy** of an array to make changes without affecting the original array.

## Simple Assignment

First, we'll discuss why we can't simply create another variable using `array_2 = array_1`, where `array_1` is our original 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)

We changed the value of the first element of `array_2` to `10`, but this assignment also changed the value of the first element of `array_1` to `10`.

With `array_2 = array_1`, you are not creating a **new** array; instead, you are creating a **reference** to the same array in memory. As a result, any changes made to `array_2` will also affect `array_1`.

Note

To solve this problem, we could write `array_2 = np.array([1, 2, 3])`, but that would mean writing the same code **twice**. Remember the key principle in coding: **Don't repeat yourself**.

## ndarray.copy() Method

Luckily, **NumPy** has an `ndarray.copy()` method as a solution to this 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}')

Now, we have created a new array for `array_2` with the same elements as `array_1`.

For **2D** arrays, the copying procedure is exactly the same.


## numpy.copy() Function

Instead of the `.copy()` **method**, we can also use the `copy()` **function**, which takes the array as its parameter: `array_2 = np.copy(array_1)`.

Both the function and the method work the same; however, there is one nuance. They both have the `order` parameter, which specifies the **memory layout** of the array, but their default values are different. 

The picture below shows the structure of the `sales_data_2021` array used in the task:

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

Develop essential skills for numerical computing using NumPy. Learn how to work with NumPy arrays, create and manipulate multidimensional data, apply indexing and slicing, perform vectorized operations, reshape arrays, use broadcasting, and apply basic linear algebra techniques. The course focuses on practical operations commonly used in data analysis tasks.

Copying Arrays

Simple Assignment

ndarray.copy() Method

numpy.copy() Function

Lösung