Tutoriel Numpy - Opérations mathématiques NumPy et diffusion

1. Opération arithmétique NumPy
2. Diffusion de NumPy

Dans ce chapitre, nous aborderons les opérations en NumPy, comme les opérations arithmétiques de base et les opérations matricielles.

Commençons par les opérations arithmétiques de base.

Opération arithmétique NumPy

L’addition, la soustraction, la multiplication et la division sont les opérations arithmétiques les plus élémentaires dans NumPy. Elles sont similaires aux opérations arithmétiques normales entre les nombres.

import numpy as np

arrayA = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
arrayB = arrayA.T
# array([[1, 2, 3],
#       [4, 5, 6],
#       [7, 8, 9]])

arrayB = arrayA.T
# array([[1, 4, 7],
#       [2, 5, 8],
#       [3, 6, 9]])

arrayA + arrayB
# array([[ 2,  6, 10],
#       [ 6, 10, 14],
#       [10, 14, 18]])

arrayA - arrayB
# array([[ 0, -2, -4],
#       [ 2,  0, -2],
#       [ 4,  2,  0]])

arrayA * arrayB
# array([[ 1,  8, 21],
#       [ 8, 25, 48],
#       [21, 48, 81]])

arrayA / arrayB
# array([[1.        , 0.5       , 0.42857143],
#       [2.        , 1.        , 0.75      ],
#       [2.33333333, 1.33333333, 1.        ]])

Il faut noter que l’opération de multiplication de matrice - *, multiplie les éléments à la même position sur les deux tableaux pour obtenir l’élément à la même position du tableau de résultat. Ce n’est pas le produit des points de deux tableaux donnés qui doit être calculé avec la méthode np.dot.

np.dot(arrayA, arrayB)
# array([[ 14,  32,  50],
#       [ 32,  77, 122],
#       [ 50, 122, 194]])

Diffusion de NumPy

Deux tableaux doivent avoir la même forme dans l’opération mathématique de tableau. Mais NumPy introduit le concept de diffusion pour remplir automatiquement le tableau si possible lorsque deux tableaux n’ont pas la même forme.

Laissez-moi expliquer ce concept avec des exemples,

import numpy as np

arrayA = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
arrayA + 1
# array([[ 2,  3,  4],
#       [ 5,  6,  7],
#       [ 8,  9, 10]])

Ici, 1 est ajouté à tous les éléments de arrayA, ou en d’autres termes, 1 est diffusé de la forme (1, 1) à la même forme de arrayA - (3, 3) pour rendre possible l’opération d’ajout de tableau.

L’opération réelle est la suivante,

arrayA + np.array([[1, 1, 1], [1, 1, 1], [1, 1, 1]])

La diffusion en NumPy pourrait également être utilisée dans les scénarios ci-dessous,

Deux tableaux ont la même longueur dans une dimension, et un tableau a la même longueur que 1 dans l’autre dimension

Commençons par un exemple,

arrayC = np.array([10, 11, 12])
arrayA + arrayC
# array([[11, 13, 15],
#       [14, 16, 18],
#       [17, 19, 21]])

La forme de arryA est (3, 3) et la forme de arrayC est (3, 1). Il répond aux critères de dimensions des tableaux, et les données sur une seule ligne dans arrayC seront diffusées sur trois lignes pour correspondre à la forme de arrayA.

Il est également applicable si deux tableaux ont la même longueur de ligne.

arrayD = np.array([[10], [11], [12]])
# array([[10],
#       [11],
#       [12]])
arrayA + arrayD
# array([[11, 12, 13],
#       [15, 16, 17],
#       [19, 20, 21]])