Comment gérer des tableaux de différentes formes lors de l'addition en NumPy

Introduction

Dans ce tutoriel, nous allons explorer comment gérer des tableaux (arrays) de différentes formes lors de l'addition dans la puissante bibliothèque Python, NumPy. Que vous travailliez avec des tableaux 1D, 2D ou de dimensions supérieures, vous apprendrez les techniques pour garantir des opérations sur les tableaux précises et efficaces.

Introduction aux tableaux (arrays) NumPy

NumPy est une puissante bibliothèque open-source pour le calcul scientifique en Python. Elle prend en charge les grands tableaux (arrays) et matrices multi-dimensionnels, ainsi qu'un grand ensemble de fonctions mathématiques de haut niveau pour opérer sur ces tableaux. Les tableaux NumPy sont la structure de données fondamentale utilisée dans de nombreuses tâches de calcul scientifique et d'apprentissage automatique.

Qu'est-ce qu'un tableau (array) NumPy?

Un tableau (array) NumPy est une grille de valeurs, toutes de même type, et est indexé par un tuple d'entiers positifs. Le nombre de dimensions est le rang du tableau, et la forme (shape) du tableau est un tuple d'entiers donnant la taille du tableau le long de chaque dimension.

import numpy as np

## Create a 1D array
arr1d = np.array([1, 2, 3, 4, 5])
print(arr1d)
## Output: [1 2 3 4 5]

## Create a 2D array
arr2d = np.array([[1, 2, 3], [4, 5, 6]])
print(arr2d)
## Output: [[1 2 3]
##          [4 5 6]]

Avantages de l'utilisation des tableaux (arrays) NumPy

Stockage de données efficace : Les tableaux NumPy stockent les données dans un bloc contigu de mémoire, ce qui les rend plus économes en mémoire par rapport aux listes Python.
Calculs rapides : NumPy fournit des fonctions et des opérations hautement optimisées pour travailler avec les tableaux, qui sont implémentées en langages de bas niveau comme le C et le Fortran, les rendant beaucoup plus rapides que le code Python pur.
Polyvalence : Les tableaux NumPy peuvent avoir un nombre quelconque de dimensions et prennent en charge une large gamme d'opérations mathématiques, ce qui les rend adaptés à diverses tâches scientifiques et d'analyse de données.
Intégration avec d'autres bibliothèques : NumPy est largement utilisé comme bibliothèque fondamentale dans l'écosystème du calcul scientifique Python et s'intègre bien avec d'autres bibliothèques populaires telles que Pandas, SciPy et Matplotlib.

Comprendre les formes (shapes) des tableaux (arrays)

La forme (shape) d'un tableau (array) NumPy fait référence au nombre d'éléments le long de chaque dimension. Elle est représentée sous la forme d'un tuple d'entiers positifs qui spécifient la taille du tableau le long de chaque axe.

Accéder aux formes (shapes) des tableaux

Vous pouvez accéder à la forme (shape) d'un tableau (array) NumPy en utilisant l'attribut shape :

import numpy as np

## 1D array
arr1d = np.array([1, 2, 3, 4, 5])
print(arr1d.shape)  ## Output: (5,)

## 2D array
arr2d = np.array([[1, 2, 3], [4, 5, 6]])
print(arr2d.shape)  ## Output: (2, 3)

## 3D array
arr3d = np.array([[[1, 2], [3, 4]], [[5, 6], [7, 8]]])
print(arr3d.shape)  ## Output: (2, 2, 2)

Redimensionner les tableaux

Vous pouvez redimensionner un tableau (array) NumPy en utilisant la méthode reshape(). La nouvelle forme (shape) doit être compatible avec la taille originale du tableau.

import numpy as np

## Reshape a 1D array to a 2D array
arr1d = np.array([1, 2, 3, 4, 5, 6])
arr2d = arr1d.reshape(2, 3)
print(arr2d)
## Output: [[1 2 3]
##          [4 5 6]]

## Reshape a 2D array to a 3D array
arr2d = np.array([[1, 2], [3, 4], [5, 6]])
arr3d = arr2d.reshape(3, 1, 2)
print(arr3d)
## Output: [[[1 2]]
##          [[3 4]]
##          [[5 6]]]

Diffusion (Broadcasting)

NumPy prend également en charge la diffusion (broadcasting), qui vous permet d'effectuer des opérations sur des tableaux (arrays) de différentes formes (shapes). Lorsque les formes ne sont pas compatibles, NumPy redimensionnera automatiquement les tableaux plus petits pour correspondre à la forme du tableau plus grand.

import numpy as np

## Broadcasting a 1D array with a 2D array
arr1d = np.array([1, 2, 3])
arr2d = np.array([[4, 5, 6], [7, 8, 9]])
result = arr1d + arr2d
print(result)
## Output: [[ 5  7  9]
##          [ 8 10 12]]

Effectuer une addition sur des tableaux (arrays) de différentes formes (shapes)

Lorsque vous additionnez deux tableaux (arrays) NumPy, les formes (shapes) des tableaux doivent être compatibles. Cela signifie que les tableaux doivent avoir la même forme, ou qu'au moins l'une des dimensions doit être de taille 1 (une dimension singulière) afin qu'elle puisse être diffusée (broadcast) à la forme de l'autre tableau.

Additionner des tableaux ayant la même forme

Si les tableaux ont la même forme, vous pouvez simplement utiliser l'opérateur + pour effectuer une addition élément par élément :

import numpy as np

arr1 = np.array([[1, 2], [3, 4]])
arr2 = np.array([[5, 6], [7, 8]])
result = arr1 + arr2
print(result)
## Output: [[ 6  8]
##          [10 12]]

Additionner des tableaux de différentes formes (diffusion - broadcasting)

Si les tableaux ont des formes différentes, NumPy tentera de diffuser (broadcast) les tableaux à une forme commune avant d'effectuer l'addition. La diffusion (broadcasting) est une fonctionnalité puissante qui vous permet d'effectuer des opérations sur des tableaux de différentes formes.

import numpy as np

## Broadcasting a 1D array with a 2D array
arr1d = np.array([1, 2, 3])
arr2d = np.array([[4, 5, 6], [7, 8, 9]])
result = arr1d + arr2d
print(result)
## Output: [[ 5  7  9]
##          [ 8 10 12]]

## Broadcasting a scalar with a 2D array
scalar = 10
arr2d = np.array([[1, 2, 3], [4, 5, 6]])
result = scalar + arr2d
print(result)
## Output: [[11 12 13]
##          [14 15 16]]

Dans les exemples ci-dessus, NumPy diffuse automatiquement le tableau 1D et le scalaire pour correspondre à la forme du tableau 2D, permettant ainsi d'effectuer l'addition.

Gérer les formes incompatibles

Si les tableaux ont des formes qui ne peuvent pas être diffusées à une forme commune, NumPy lèvera une exception ValueError :

import numpy as np

arr1 = np.array([[1, 2], [3, 4]])
arr2 = np.array([[5, 6, 7], [8, 9, 10]])
result = arr1 + arr2
## ValueError: operands could not be broadcast together with shapes (2,2) (2,3)

Dans de tels cas, vous devrez peut-être redimensionner ou transposer l'un ou les deux tableaux pour rendre leurs formes compatibles avant d'effectuer l'addition.

Résumé

À la fin de ce tutoriel, vous aurez une bonne compréhension de la manière de gérer des tableaux (arrays) de différentes formes (shapes) lors de l'addition dans NumPy. Vous disposerez des connaissances nécessaires pour écrire un code Python robuste et flexible capable de gérer de manière transparente diverses configurations de tableaux, vous permettant ainsi d'aborder des tâches d'analyse de données et de calcul scientifique plus complexes.