Aller au contenu

Prise en main de Numpy - Le guide ultime

NumPy est la boîte à outils de base pour le calcul scientifique avec Python. NumPy fournit, entre autres, la prise en charge des tableaux multidimensionnels avec des opérations de base sur eux et des fonctions d'algèbre linéaire utiles. De nombreuses boîtes à outils utilisent les représentations du tableau NumPy comme une structure de données de base efficace.

Installer Numpy

Si vous travaillez avec Anaconda, Numpy est déjà installé sinon Numpy est disponible sur le répertoire PyPi

!pip install numpy

Importer Numpy

Numpy n'est pas une librairie native en Python, il faut l'installer au préalable. Si vous ne l'avez pas encore installée avez pas Pour importer Numpy if suffit de faire ceci import numpy mais il est plus courant de faire ceci import numpy as np

import numpy as np

Vous pouvez vérifier la version de Numpy

print(np.__version__)

x = [1, 5, -1, 0, 4]

x_array = np.array(x)

x + 1

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-3-eaf7b6991020> in <module>
----> 1 x + 1

TypeError: can only concatenate list (not "int") to list
x_array + 1

array([2, 6, 0, 1, 5])

Tous les éléments de x_array sont augmentés 1 alors que la même opération sur la liste x lève une exception.

def f(x):
    return x**2

f(x)

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-6-f2d123ee1505> in <module>
----> 1 f(x)

<ipython-input-5-4261cf13ee74> in f(x)
      1 def f(x):
----> 2     return x**2

TypeError: unsupported operand type(s) for ** or pow(): 'list' and 'int'

Cette opération n'est pas possible sur les listes natives de Python

f(x_array)

array([ 1, 25,  1,  0, 16])

Vecteurs

u = np.linspace(start=0, stop=10, num=10)
u

array([ 0.        ,  1.11111111,  2.22222222,  3.33333333,  4.44444444,
        5.55555556,  6.66666667,  7.77777778,  8.88888889, 10.        ])

v = np.linspace(start=0, stop=10, retstep=0.02)
v

(array([ 0.        ,  0.20408163,  0.40816327,  0.6122449 ,  0.81632653,
         1.02040816,  1.2244898 ,  1.42857143,  1.63265306,  1.83673469,
         2.04081633,  2.24489796,  2.44897959,  2.65306122,  2.85714286,
         3.06122449,  3.26530612,  3.46938776,  3.67346939,  3.87755102,
         4.08163265,  4.28571429,  4.48979592,  4.69387755,  4.89795918,
         5.10204082,  5.30612245,  5.51020408,  5.71428571,  5.91836735,
         6.12244898,  6.32653061,  6.53061224,  6.73469388,  6.93877551,
         7.14285714,  7.34693878,  7.55102041,  7.75510204,  7.95918367,
         8.16326531,  8.36734694,  8.57142857,  8.7755102 ,  8.97959184,
         9.18367347,  9.3877551 ,  9.59183673,  9.79591837, 10.        ]),
 0.20408163265306123)

Matrices

M = np.array([
    [1, 2, 3],
    [4, 5, 6],
    [7, 8, 9]
])
M

array([[1, 2, 3],
       [4, 5, 6],
       [7, 8, 9]])

N = np.array([1, 2, 3, 4, 5, 6, 7, 8, 9])
N = N.reshape((3, 3))
N

array([[1, 2, 3],
       [4, 5, 6],
       [7, 8, 9]])

Dimensions

M.shape

(3, 3)

Transposée

M.T

array([[1, 4, 7],
       [2, 5, 8],
       [3, 6, 9]])

Produit de deux matrices

Inverse

np.linalg.inv(M)

array([[-4.50359963e+15,  9.00719925e+15, -4.50359963e+15],
       [ 9.00719925e+15, -1.80143985e+16,  9.00719925e+15],
       [-4.50359963e+15,  9.00719925e+15, -4.50359963e+15]])

np.dot(M, np.linalg.inv(M))

array([[ 0.,  0.,  0.],
       [-4.,  0., -4.],
       [ 0.,  0.,  0.]])

Indicateurs statistiques

# Échantillon
X = np.array([12, 4, 9, 17, 8.5, 13, 14.5, 10, 11, 19.25,])

Moyenne

X.mean(), np.mean(X)

(11.825, 11.825)

Variance

X.var(), np.var(X)

(17.475625, 17.475625)

Écart-type

X.std(), np.std(X)

(4.180385747751037, 4.180385747751037)

Génération de nombres aléatoires

Lois de probabilité

Numpy permet de simuler les lois de probabilité

1. Loi normale

normal_sample = np.random.normal(loc=0, scale=1, size=30)
normal_sample

array([ 0.85244362, -0.54164536,  0.19854661,  1.65220835, -0.0395565 ,
       -1.68872945, -0.98958335, -0.25029709,  0.10325105, -0.89433271,
       -1.32362226, -1.32604555,  0.86669263, -0.17504581, -1.95959421,
       -0.8681262 , -1.2524416 , -0.02080667,  0.53948589, -1.94526224,
       -1.14650797, -0.47076931,  0.51783715,  1.45280426, -0.05573768,
        1.20075222, -1.3077279 ,  0.50787525,  1.14185561, -1.14986783])

loc: Moyenne
scale: Écart-type
size: Taille de l'échantillon

print("Moyenne:", np.mean(normal_sample))
print("Écart-type:", np.std(normal_sample, ddof=0))

Moyenne: -0.2790649016925496
Écart-type: 1.0106534455633465

2. Loi uniforme

uniform_sample = np.random.uniform(low=0, high=1, size=30)
uniform_sample

array([0.50553442, 0.61860428, 0.98909768, 0.31621984, 0.08856231,
       0.01236105, 0.68724347, 0.69467672, 0.22420085, 0.98429677,
       0.49966182, 0.70798057, 0.19188433, 0.66531416, 0.55552582,
       0.95336091, 0.99950493, 0.37356494, 0.58781905, 0.5273596 ,
       0.11068473, 0.10488008, 0.98196091, 0.60894809, 0.31632556,
       0.45742475, 0.39943295, 0.64229407, 0.25660412, 0.23873302])

print("Moyenne:", np.mean(uniform_sample))
print("Variance:", np.var(uniform_sample, ddof=0))

Moyenne: 0.5100020598382468
Variance: 0.08226912965726332

3. Loi exponentielle

exponential_sample = np.random.exponential(scale=1, size=30)
exponential_sample

array([3.9218249 , 0.3979421 , 1.70940746, 0.13462975, 4.31350004,
       0.41001018, 0.20232039, 0.84855559, 0.5572745 , 1.1525659 ,
       0.41453037, 2.20087499, 1.41130649, 1.4158009 , 0.32676615,
       1.53323471, 0.79079837, 0.4191092 , 0.70289818, 0.74215646,
       0.04903491, 1.04719581, 0.29177388, 1.7714993 , 0.68629523,
       0.3455022 , 0.30483589, 0.76464627, 4.12319142, 0.14694294])

print("Moyenne:", np.mean(exponential_sample))
print("Variance:", np.var(exponential_sample, ddof=0))

Moyenne: 1.1045474826993096
Variance: 1.2993639961702512

Importation et Exportation

data = np.genfromtxt("data.txt", délimiter=",")

Exporter un tableau

Numpy permet d'écrire les tableaux sur le disque, ce qui peut être utile pour faire des traitements ultérieurs.

with open("outputs/array.npy", 'wb') as f:
    np.save(f, array)

---------------------------------------------------------------------------
NameError                                 Traceback (most recent call last)
<ipython-input-26-3904551a21d7> in <module>
      1 with open("array.npy", 'wb') as f:
----> 2     np.save(f, array)

NameError: name 'array' is not defined

Importer des données

with open("array.npy", 'rb') as f:
    saved_array = np.load(f)

Références

Pour avoir plus de détails, merci de consulter la documentation officielle Numpy Docs