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

Il est souvent nécessaire de créer une **copie** d'un tableau afin d'effectuer des modifications sans affecter le tableau d'origine.

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.

## Affectation simple

Tout d'abord, nous allons expliquer pourquoi il n'est pas possible de simplement créer une autre variable avec `array_2 = array_1`, où `array_1` est notre tableau d'origine.

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)

Nous avons modifié la valeur du premier élément de `array_2` à `10`, mais cette affectation a également modifié la valeur du premier élément de `array_1` à `10`.

Avec `array_2 = array_1`, vous ne créez pas un **nouveau** tableau ; vous créez plutôt une **référence** vers le même tableau en mémoire. Par conséquent, toute modification apportée à `array_2` affectera également `array_1`.

Remarque

Pour résoudre ce problème, nous pourrions écrire `array_2 = np.array([1, 2, 3])`, mais cela impliquerait d'écrire le même code **deux fois**. Rappelez-vous du principe clé en programmation : **Ne vous répétez pas**.

## Méthode ndarray.copy()

Heureusement, **NumPy** propose une méthode `ndarray.copy()` comme solution à ce problème.

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

Nous avons maintenant créé un nouveau tableau pour `array_2` avec les mêmes éléments que `array_1`.

Pour les tableaux **2D**, la procédure de copie est exactement la même.


## Fonction numpy.copy()

Au lieu de la **méthode** `.copy()`, on peut également utiliser la **fonction** `copy()`, qui prend le tableau en paramètre : `array_2 = np.copy(array_1)`.

La fonction et la méthode fonctionnent de la même manière ; cependant, il existe une nuance. Elles possèdent toutes deux le paramètre `order`, qui spécifie la **disposition en mémoire** du tableau, mais leurs valeurs par défaut sont différentes.

L'image ci-dessous montre la structure du tableau `sales_data_2021` utilisé dans l'exercice :

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

Libérez tout le potentiel de la bibliothèque la plus essentielle de Python pour le calcul numérique, NumPy. Ce cours complet est conçu pour vous faire passer d'une compréhension débutante à un niveau avancé de maîtrise de NumPy. Que vous soyez data scientist, ingénieur, chercheur ou développeur, la maîtrise de NumPy est essentielle pour une manipulation efficace des données, le calcul scientifique et l'apprentissage automatique.

Explorez les applications de NumPy et comprenez pourquoi il s'agit de l'une des bibliothèques les plus populaires pour le calcul numérique. Découvrez les différentes méthodes de création et d'initialisation des tableaux afin de répondre efficacement à divers besoins en données.

Découvrez comment accéder à des éléments spécifiques et à des sous-ensembles dans les tableaux NumPy en utilisant la notation d'index. Apprenez à appliquer l'indexation conditionnelle pour filtrer les données et gérer efficacement les valeurs manquantes.

NumPy propose de nombreuses fonctions intégrées pour effectuer des opérations courantes sur les tableaux. Découvrez comment utiliser ces outils pour transformer, agréger et analyser les données efficacement sans écrire de code répétitif.

Apprenez à effectuer des opérations mathématiques efficacement sur des tableaux NumPy. Appliquez ces opérations pour résoudre des problèmes concrets et acquérez une compréhension approfondie de la manière dont les calculs vectorisés accélèrent l'analyse numérique.

Copie de Tableaux

Affectation simple

Méthode ndarray.copy()

Fonction numpy.copy()

Solution