NumPy¶

Le module Numpy apporte des fonctions de calculs numériques autour des tableaux multidimensionnels ainsi que des fonctions de calculs mathématiques de haut niveau (algèbre linéaire, statistique, ajustement polynomial d'une courbe ...).

Attention

Pour utiliser Numpy, il faut rajouter la ligne suivante en début de fichier :

import numpy as np

Tableau NumPy¶

NumPy introduit un nouveau type l'array qui est semblable à une liste, mais tous les éléments doivent être du même type (entier, flottant, booléen ou encore chaîne de caractères).

Le tableau peut être unidimensionnel ou multidimensionnel.

Création d'un tableau¶

# Tableau unidimensionnel
import numpy as np

# Construction du tableau de type float
tab = np.array([1, 2, 3, 4], float)

# Affichage du tableau
print(tab)
# Affichage de l'élément d'indice 1
print("Element d'incide 1 :", tab[1])

    [1. 2. 3. 4.]  
    Element d'incide 1 : 2.0

# Création du tableau de type int
tab = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]], int)  # Dimension = 2

print(tab)
print("Sélection de l'élément d'indice [2,1]:", tab[2, 1])

    [[1 2 3]
     [4 5 6]
     [7 8 9]]
    Sélection de l'élément d'indice [2,1]: 8

tab = np.array([[[1, 2], [3, 4]], [[5, 6], [7, 8]]])  # Dimension = 3

print(tab)
print("Sélection de l'élément d'indice [1,0,1] :", tab[1, 0, 1])

    [[[1 2]
      [3 4]]

     [[5 6]
      [7 8]]]
    Sélection de l'élément d'indice [1,0,1] : 6

Sélection de données dans un tableau ou slicing¶

Pour sélectionner une portion de données dans un tableau, le slicing fonctionne de la même manière que pour les listes.

L'usage est le suivant : array[début:fin:pas]

# Tableau unidimensionnel
a = np.array([1, 2, 3, 4, 5, 6, 7, 8, 9], int)

# Une valeur sur deux en commençant à l'indice 0 jusqu'à l'indice 6 exclu
print(a[0:6:2])
# Une valeur sur trois en commençant à l'indice 1 jusqu'à la fin
print(a[1::3])

    [1 3 5]
    [2 5 8]

print(a[0:5])  # Les valeurs comprises entre l'indice 0 et 5 exclue
print(a[:5])  # Les 5 premières valeurs

    [1 2 3 4 5]
    [1 2 3 4 5]

print(a[5:9])  # Les valeurs comprises entre l'indice 5 et 9 exclue
print(a[5:])  # Les dernières valeurs à partir de l'indice 5

    [6 7 8 9]
    [6 7 8 9]

print(a[-1])  # Affichage de la dernière valeur d'un tableau

Pour un tableau multidimensionnel, on sépare chaque dimension par une virgule :
array[dim1,dim2,dim3] $\rightarrow$ array[debut:fin:pas,début:fin:pas,début:fin:pas]

# Tableau bidimensionnel
a = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9], [
             10, 11, 12]], int)  # Dimension = 2

print(a)

    [[ 1  2  3]
     [ 4  5  6]
     [ 7  8  9]
     [10 11 12]]

print(a[1])  # Tableau d'indice 1
print(a[1, 2])  # Troisième élément du tableau d'indice 1

    [4 5 6]
    6

print(a[::2])  # Un tableau sur deux
print(a[0:3:2])  # Un tableau sur deux

    [[1 2 3]
     [7 8 9]]
    [[1 2 3]
     [7 8 9]]

print(a[:, 0])  # Le premier élément de chaque tableau
print(a[:, ::2])  # Un élément sur deux dans chaque tableau

    [ 1  4  7 10]
    [[ 1  3]
     [ 4  6]
     [ 7  9]
     [10 12]]

Copie d'un tableau¶

Attention

Si vous modifiez une donnée d'un tableau b issu de l'extraction d'un tableau a, le tableau a sera aussi modifié.

a = np.array([1, 2, 3, 4])
b = a[1:3]  # Sélection des données pour b par slice
b[1] = 0  # Modification de b

print(a)  # a est aussi modifié

    [1 2 0 4]

Pour éviter ce problème il faut réaliser une copie avec la fonction np.copy(a) ou la méthode a.copy().

a = np.array([1, 2, 3, 4])
b = a[1:3].copy()  # Sélection des données pour b par slice et copy
b[1] = 0  # Modification de b

print(a)  # a n'est plus modifié

    [1 2 3 4]

Construction des tableaux¶

Il existe plusieurs fonctions qui permettent de construire un tableau rapidement.

Fonction `np.arange`¶

Équivalent à la fonction range.

# Créé un tableau de 10 éléments par pas de 1 en commençant à 0
a = np.arange(10)
print(a)

# On peut forcer le type ici flottant
a = np.arange(10, dtype=np.float)
print(a)

a = np.arange(10.0)
print(a)

    [0 1 2 3 4 5 6 7 8 9]
    [0. 1. 2. 3. 4. 5. 6. 7. 8. 9.]
    [0. 1. 2. 3. 4. 5. 6. 7. 8. 9.]

# Création d'un tableau de valeur entre 1 et 3 exclu avec un pas de 0,2
a = np.arange(1, 3, 0.2)
print(a)

    [1.  1.2 1.4 1.6 1.8 2.  2.2 2.4 2.6 2.8]

Fonction `np.linspace`¶

La fonction np.arange exclue le dernier élément. Il est alors plus courant d'utiliser la fonction np.linspace pour éviter ce problème.
Utilisation : np.linspace(début, fin, nombre de points)

# Création d'un tableau de 0 à 10 inclue par pas de 1
a = np.linspace(0, 10, 11)
print(a)

# Création d'un tableau de 0 à 10 inclue par pas de 0.1
a = np.linspace(0, 10, 101)
print(a)

    [ 0.  1.  2.  3.  4.  5.  6.  7.  8.  9. 10.]
    [ 0.   0.1  0.2  0.3  0.4  0.5  0.6  0.7  0.8  0.9  1.   1.1  1.2  1.3
4  1.5  1.6  1.7  1.8  1.9  2.   2.1  2.2  2.3  2.4  2.5  2.6  2.7
8  2.9  3.   3.1  3.2  3.3  3.4  3.5  3.6  3.7  3.8  3.9  4.   4.1
2  4.3  4.4  4.5  4.6  4.7  4.8  4.9  5.   5.1  5.2  5.3  5.4  5.5
6  5.7  5.8  5.9  6.   6.1  6.2  6.3  6.4  6.5  6.6  6.7  6.8  6.9
  7.1  7.2  7.3  7.4  7.5  7.6  7.7  7.8  7.9  8.   8.1  8.2  8.3
4  8.5  8.6  8.7  8.8  8.9  9.   9.1  9.2  9.3  9.4  9.5  9.6  9.7
8  9.9 10. ]

Fonction `np.logspace`¶

Fonction similaire à np.linspace met avec un espacement logarithmique entre les points.
Utilisation : np.logspace(début, fin, nombre de points)

# Création d'un tableau de 0 à 10 avec 11 points
a = np.logspace(0, 10, 11)
print(a)

# Création d'un tableau de 0 à 10 avec 101 points
a = np.logspace(0, 10, 101)
print(a)

    [1.e+00 1.e+01 1.e+02 1.e+03 1.e+04 1.e+05 1.e+06 1.e+07 1.e+08 1.e+09
e+10]
    [1.00000000e+00 1.25892541e+00 1.58489319e+00 1.99526231e+00
51188643e+00 3.16227766e+00 3.98107171e+00 5.01187234e+00
30957344e+00 7.94328235e+00 1.00000000e+01 1.25892541e+01
58489319e+01 1.99526231e+01 2.51188643e+01 3.16227766e+01
98107171e+01 5.01187234e+01 6.30957344e+01 7.94328235e+01
00000000e+02 1.25892541e+02 1.58489319e+02 1.99526231e+02
51188643e+02 3.16227766e+02 3.98107171e+02 5.01187234e+02
30957344e+02 7.94328235e+02 1.00000000e+03 1.25892541e+03
58489319e+03 1.99526231e+03 2.51188643e+03 3.16227766e+03
98107171e+03 5.01187234e+03 6.30957344e+03 7.94328235e+03
00000000e+04 1.25892541e+04 1.58489319e+04 1.99526231e+04
51188643e+04 3.16227766e+04 3.98107171e+04 5.01187234e+04
30957344e+04 7.94328235e+04 1.00000000e+05 1.25892541e+05
58489319e+05 1.99526231e+05 2.51188643e+05 3.16227766e+05
98107171e+05 5.01187234e+05 6.30957344e+05 7.94328235e+05
00000000e+06 1.25892541e+06 1.58489319e+06 1.99526231e+06
51188643e+06 3.16227766e+06 3.98107171e+06 5.01187234e+06
30957344e+06 7.94328235e+06 1.00000000e+07 1.25892541e+07
58489319e+07 1.99526231e+07 2.51188643e+07 3.16227766e+07
98107171e+07 5.01187234e+07 6.30957344e+07 7.94328235e+07
00000000e+08 1.25892541e+08 1.58489319e+08 1.99526231e+08
51188643e+08 3.16227766e+08 3.98107171e+08 5.01187234e+08
30957344e+08 7.94328235e+08 1.00000000e+09 1.25892541e+09
58489319e+09 1.99526231e+09 2.51188643e+09 3.16227766e+09
98107171e+09 5.01187234e+09 6.30957344e+09 7.94328235e+09
00000000e+10]

Fonctions modifiant les dimensions d'un tableau¶

Il est possible de redimensionner un tableau pour en augmenter le nombre de dimensions ou au contraire les réduire.

Méthode `.reshape`¶

La fonction .reshape permet de modifier le format d'un tableau en gardant le même nombre d'éléments.

Attention

Le nombre d'éléments doit rester identique entre le tableau d'origine et la version avec le format modifier.

a = np.arange(8)
print(a)

# On le transforme en tableau de 2 lignes et 4 colonnes
b = a.reshape(2, 4)
print(b)

# On le transforme en tableau de 4 lignes et 2 colonnes
c = a.reshape(4, 2)
print(c)

    [0 1 2 3 4 5 6 7]
    [[0 1 2 3]
     [4 5 6 7]]
    [[0 1]
     [2 3]
     [4 5]
     [6 7]]

Fonction `np.resize`¶

Similaire à reshape mais modifier le nombre total d'éléments.

Attention

Cette fonction n'est pas une méthode d'un tableau. On doit l'appeler avec np.resize(tableau, (l, c)) avec l le nombre de lignes et c le nombre de colonnes.

a = np.arange(8)
print(a)

# On le transforme en tableau de 2 lignes et 3 colonnes
b = np.resize(a, (2, 3))
print(b)

# On le transforme en tableau de 1 lignes et 2 colonnes
c = np.resize(a, (1, 2))
print(c)

    [0 1 2 3 4 5 6 7]
    [[0 1 2]
     [3 4 5]]
    [[0 1]]

Méthodes `.ravel` ou `.flatten`¶

Les fonctions .ravel et .flatten permettent de retourner un tableau de dimension 1 en "aplatissant" un tableau de n dimensions.

a = np.arange(8).reshape(4, 2)
print(a)

# Aplatissement pour retourner sur une dimension 1
b = a.ravel()
print(b)

c = a.flatten()
print(c)

    [[0 1]
     [2 3]
     [4 5]
     [6 7]]
    [0 1 2 3 4 5 6 7]
    [0 1 2 3 4 5 6 7]

Méthode `.transpose`¶

Cette fonction permet de transposer deux axes, par défaut le dernier.
Par exemple un tableau de 2x4 deviendra un tableau de 4x2.

a = np.arange(8).reshape(4, 2)
print(a)

# On transpose le tableau
b = a.transpose()
print(b)

    [[0 1]
     [2 3]
     [4 5]
     [6 7]]
    [[0 2 4 6]
     [1 3 5 7]]

a = np.arange(12).reshape(4, 3)
print(a)

# On transpose le tableau
b = a.transpose()
print(b)

    [[ 0  1  2]
     [ 3  4  5]
     [ 6  7  8]
     [ 9 10 11]]
    [[ 0  3  6  9]
     [ 1  4  7 10]
     [ 2  5  8 11]]

Constantes fournies par NumPy¶

NumPy fourni un certain nombre de constantes tel que :

$\pi$ ;
$e$ ;
$+\infty$ et $-\infty$ ;
NaN pour "pas un nombre".

print(np.pi)  # Constante pi
print(np.e)  # Constante e
print(np.NAN)  # Pas un nombre

    3.141592653589793
    2.718281828459045
    nan

print(np.inf)  # Constante infini
print(np.PINF)  # Constante infini positive
print(np.NINF)  # Constante infini négative

    inf
    inf
    -inf

print(np.PZERO)  # Constante zéro positif
print(np.NZERO)  # Constante zéro négatif

    0.0
    -0.0

Opération sur les tableaux¶

Il est possible d'effectuer les opérations classiques $+$ , $-$ , $\times$ , $\div$ entre deux tableaux (l'opération s'effectue alors terme à terme) ou entre un tableau et une constante (l'opération est appliquée à tous les termes avec la constante).

a = np.arange(10)  # Tableau de 0 à 9
b = np.ones(10)  # Tableau de 10 éléments rempli de 1

print(a)
print(b)

    [0 1 2 3 4 5 6 7 8 9]
    [1. 1. 1. 1. 1. 1. 1. 1. 1. 1.]

# Addition des deux tableaux
print(a+b)

# Addition d'un tableau et d'une constante
print(1+b)

# Multiplication d'un tableau et d'une constante
print(3*a)

    [ 1.  2.  3.  4.  5.  6.  7.  8.  9. 10.]
    [2. 2. 2. 2. 2. 2. 2. 2. 2. 2.]
    [ 0  3  6  9 12 15 18 21 24 27]

# Matrice 3x3
m = np.arange(9).reshape(3, 3)
print(m)

# Matrice diagonale 3x3
v = np.ones(3)
diag = np.diag(v)
print(diag)

    [[0 1 2]
     [3 4 5]
     [6 7 8]]
    [[1. 0. 0.]
     [0. 1. 0.]
     [0. 0. 1.]]

print(m*diag)  # Multiplication de deux matrices
print(diag-1)  # Soustraction de la constante à tous les termes

    [[0. 0. 0.]
     [0. 4. 0.]
     [0. 0. 8.]]
    [[ 0. -1. -1.]
     [-1.  0. -1.]
     [-1. -1.  0.]]

print((diag-1)/(m+2))  # Combinaison des opérations

    [[ 0.         -0.33333333 -0.25      ]
     [-0.2         0.         -0.14285714]
     [-0.125      -0.11111111  0.        ]]

Produit et somme¶

Les fonctions np.prod(...) et np.sum(...) permettent respectivement de calculer le produit et la somme de l'ensemble d'un tableau.

# Création d'un tableau avec 20 valeurs entières prise aléatoirement entre 0 et 100
a = np.random.randint(0, 100, 20)

b = np.sum(a)  # Calcul de la somme
c = np.prod(a)  # Calcul du produit

print("Tableau :", a)
print("Somme :", b)
print("Produit :", c)

    Tableau : [45 60 39 23 57 94 45 60 12 58 17 86 14 72 71 16  5 49 22 81]
    Somme : 926
    Produit : 1525940224

Différence entre les termes successifs¶

La fonction np.diff(...) permet de faire la différence entre les termes de manière successive et retourne un tableau avec les différences calculées.

# Création d'un tableau avec 20 valeurs entières prise aléatoirement entre 0 et 100
a = np.random.randint(0, 100, 20)

b = np.diff(a)  # Calcul de la différence

print("Tableau :", a)
print("Différence :", b)

    Tableau : [ 4 35 41  4 87 19 37 75 83 23 30 67 26 56  3 78 88 29 34 65]
    Différence : [ 31   6 -37  83 -68  18  38   8 -60   7  37 -41  30 -53  75  10 -59   5
      31]

Somme cumulative¶

La fonction np.cumsum(...) permet de calculer la somme cumulée terme à terme du tableau et retourne un tableau avec le résultat de cette somme.

# Création d'un tableau avec 20 valeurs entières prise aléatoirement entre 0 et 100
a = np.random.randint(0, 100, 20)

b = np.cumsum(a)  # Calcul de la somme cumulée

print("Tableau :", a)
print("Somme cumulative :", b)

    Tableau : [85 45  8 83 35 54 76 96 97 26 84 84 50 61 36 26  8 54  9 59]
    Somme cumulative : [  85  130  138  221  256  310  386  482  579  605  689  773  823  884
      920  946  954 1008 1017 1076]

Moyenne¶

La fonction np.mean(...)retourne la moyenne d'un tableau.

# Création d'un tableau avec 20 valeurs entières prise aléatoirement entre 0 et 100
a = np.random.randint(0, 100, 20)

b = np.mean(a)  # Calcul de la moyenne

print("Tableau :", a)
print("Moyenne :", b)

    Tableau : [87 83 98  5 94 87 66 27 25 58 82 97 23 76 24 99 62 98 12 86]
    Moyenne : 64.45

Fonctions mathématiques¶

NumPy fournit un certain nombre de fonctions mathématiques dans le domaine de la trigonométrie, des exponentielles et des logarithmes.

Liste non exhaustive des fonctions :

np.cos(array)
np.sin(array)
np.tan(array)
np.arccos(array)
np.arcsin(array)
np.arctan(array)
np.degrees(array) ou np.rad2deg(array) conversion de radian en degré
np.radians(array) ou np.deg2rad(array) conversion de degrée en radian
np.exp(array)
np.log(array) logarithme naturel
np.log2(array) logarithme base 2
np.log10(array) logarithme base 10
np.sqrt(array) racine carré

import matplotlib.pyplot as plt
x = np.linspace(0, 2*np.pi, 100)  # Création d'un tableau allant de 0 à 2*pi
y = np.sin(x)  # Calcul du sinus du tableau x

# Affichage du calcul
plt.plot(x, y)
plt.show()

png

Fonctions de recherche¶

Valeurs min et max¶

Les fonctions np.min(...) et np.max(...) permettent de chercher la valeur min et max dans un tableau.

# Création d'un tableau avec 20 valeurs entières prise aléatoirement entre 0 et 100
a = np.random.randint(0, 100, 20)

a_min = np.min(a)  # Valeur min
a_max = np.max(a)  # Valeur max

print("Tableau :", a)
print("Min :", a_min, "Max :", a_max)

    Tableau : [65 32 71 80  5  8 21 57 89 25 71 76 64 47 85 28 32 70 41 16]
    Min : 5 Max : 89

Position des valeurs min et max¶

Les fonctions np.argmin(...) et np.argmax(...) permettent de connaitre la position (indice) de la valeur min et max dans un tableau.

# Création d'un tableau avec 20 valeurs entières prise aléatoirement entre 0 et 100
a = np.random.randint(0, 100, 20)

a_min = np.argmin(a)  # Indice min
a_max = np.argmax(a)  # Indice max

print("Tableau :", a)
print("Index min :", a_min, "Index max :", a_max)

    Tableau : [66 22 43 93 87 77  0 51 46 27 79 81 35 92 83 77 32 58 90 16]
    Index min : 6 Index max : 3

Recherche avec condition¶

La fonction np.where(condition) permet de retourner les index des valeurs répondant à la condition donnée. La condition contient le nom du tableau NumPy dans lequel on veut effectuer la recherche.

# Création d'un tableau avec 20 valeurs entières prise aléatoirement entre 0 et 100
a = np.random.randint(0, 100, 20)

b = np.where(a < 50)  # Chercher les index des valeurs en dessous de 50

print("Tableau :", a)
print("Index :", b)
print("Valeurs :", a[b])

    Tableau : [94 17 14 82 49 28  2 12 68 43 42 69 44  9 97 91 39 97 15 62]
    Index : (array([ 1,  2,  4,  5,  6,  7,  9, 10, 12, 13, 16, 18], dtype=int64),)
    Valeurs : [17 14 49 28  2 12 43 42 44  9 39 15]

Assemblage de plusieurs tableaux¶

Il est possible d'assembler plusieurs tableaux pour n'en former qu'un seul.

Fonction `np.concatenate(...)`¶

Assemble les tableaux selon un axe existant.

a = np.array([[1, 2], [3, 4]])
b = np.array([[5, 6]])

c = np.concatenate((a, b))

print(c)

    [[1 2]
     [3 4]
     [5 6]]

Empilement de tableaux¶

Il existe trois fonctions d'empilements des tableaux :

np.stack(...) : empilement selon un nouvel axe ;
np.hstack(...) : empilement horizontal (colonne par colonne) ;
np.vstack(...) : empilement vertical (ligne par ligne).

# Création de deux tableaux
a = np.array([[1, 2], [3, 4]])
b = np.array([[5, 6], [7, 8]])

# Créé un nouveau tableau contenant les tableaux sélectionnées
c = np.stack((a, b))

print(c)

    [[[1 2]
      [3 4]]

     [[5 6]
      [7 8]]]

# Création de deux tableaux
a = np.array([[1, 2], [3, 4]])
b = np.array([[5, 6], [7, 8]])

c = np.hstack((a, b))  # Empilement colonne par colonne

print(c)

    [[1 2 5 6]
     [3 4 7 8]]

# Création de deux tableaux
a = np.array([[1, 2], [3, 4]])
b = np.array([[5, 6], [7, 8]])

c = np.vstack((a, b))  # Empilement ligne par ligne

print(c)

    [[1 2]
     [3 4]
     [5 6]
     [7 8]]

NumPy¶

Tableau NumPy¶

Création d'un tableau¶

Sélection de données dans un tableau ou slicing¶

Copie d'un tableau¶

Construction des tableaux¶

Fonction np.arange¶

Fonction np.linspace¶

Fonction np.logspace¶

Fonctions modifiant les dimensions d'un tableau¶

Méthode .reshape¶

Fonction np.resize¶

Méthodes .ravel ou .flatten¶

Méthode .transpose¶

Constantes fournies par NumPy¶

Opération sur les tableaux¶

Produit et somme¶

Différence entre les termes successifs¶

Somme cumulative¶

Moyenne¶

Fonctions mathématiques¶

Fonctions de recherche¶

Valeurs min et max¶

Position des valeurs min et max¶

Recherche avec condition¶

Assemblage de plusieurs tableaux¶

Fonction np.concatenate(...)¶

Empilement de tableaux¶

Fonction `np.arange`¶

Fonction `np.linspace`¶

Fonction `np.logspace`¶

Méthode `.reshape`¶

Fonction `np.resize`¶

Méthodes `.ravel` ou `.flatten`¶

Méthode `.transpose`¶

Fonction `np.concatenate(...)`¶