NumPy: Le Calcul Scientifique sous Python

1 Introduction

Ce tutoriel vous guidera à travers les fonctionnalités essentielles de NumPy, la bibliothèque fondamentale pour le calcul scientifique en Python.

Public Cible : Développeurs Python ou analystes de données débutants. Une connaissance de base de Python (listes, boucles) est recommandée.

Objectifs :

• Comprendre l’utilité de NumPy et de son objet principal, le ndarray.
• Créer et manipuler des tableaux NumPy.
• Effectuer des calculs rapides grâce à la vectorisation.
• Utiliser l’indexation booléenne et le broadcasting.

2 Partie 1 : Les Fondations - L’Array NumPy

2.1 Pourquoi NumPy ?

Les listes Python sont flexibles, mais lentes pour les opérations mathématiques sur de grands volumes de données. NumPy fournit un objet ndarray (N-dimensional array) qui est beaucoup plus rapide et efficace en mémoire. C’est le socle de l’écosystème Data Science (Pandas, Matplotlib, etc.).

On l’importe traditionnellement avec l’alias np.

import numpy as np

2.2 Création d’un ndarray

Il existe de nombreuses façons de créer des tableaux NumPy.

# À partir d'une liste Python
liste = [1, 2, 3, 4]
arr_from_list = np.array(liste)
print(f"Array depuis une liste: {arr_from_list}")

# Un tableau de zéros
zeros_arr = np.zeros((2, 3)) # (2 lignes, 3 colonnes)
print(f"\nTableau de zéros:\n{zeros_arr}")

# Une séquence de nombres (similaire à range)
range_arr = np.arange(0, 10, 2) # de 0 à 9, par pas de 2
print(f"\nSéquence avec arange: {range_arr}")

# Un tableau de nombres aléatoires entre 0 et 1
random_arr = np.random.rand(3, 3)
print(f"\nTableau aléatoire:\n{random_arr}")

Array depuis une liste: [1 2 3 4]

Tableau de zéros:
[[0. 0. 0.]
 [0. 0. 0.]]

Séquence avec arange: [0 2 4 6 8]

Tableau aléatoire:
[[0.19773354 0.23685396 0.04278431]
 [0.98847635 0.20935586 0.82048987]
 [0.39161004 0.29576604 0.79146633]]

2.3 Les Attributs d’un Array

Chaque array NumPy possède des attributs qui décrivent ses caractéristiques.

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

# Nombre de dimensions
print(f"Nombre de dimensions (ndim): {data.ndim}")

# Forme de l'array (lignes, colonnes)
print(f"Forme (shape): {data.shape}")

# Nombre total d'éléments
print(f"Taille (size): {data.size}")

# Type de données
print(f"Type de données (dtype): {data.dtype}")

Nombre de dimensions (ndim): 2
Forme (shape): (2, 3)
Taille (size): 6
Type de données (dtype): int64

Exercice 1  

• Créez une matrice 3x4 remplie de nombres entiers aléatoires entre 10 et 50.
• Affichez ensuite ses dimensions, sa forme et sa taille.

Indice: np.random.randint(low, high, size)

---

3 Partie 2 : Sélection de Données - Indexing & Slicing

3.1 Indexing & Slicing

L’accès aux données dans NumPy est puissant et intuitif.

arr = np.arange(10, 20)
print(f"Array original: {arr}")

# Accéder à un élément (comme une liste)
print(f"Élément à l'index 3: {arr[3]}")

# Slicing (extraire une partie)
print(f"Éléments de l'index 2 à 5: {arr[2:6]}")

# Pour les arrays 2D
matrix = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
print(f"\nMatrice:\n{matrix}")

# Accéder à un élément : matrix[ligne, colonne]
print(f"Élément à la ligne 1, colonne 2: {matrix[1, 2]}")

# Extraire une colonne entière (toutes les lignes, colonne 1)
print(f"Deuxième colonne: {matrix[:, 1]}")

# Extraire une ligne entière (ligne 0, toutes les colonnes)
print(f"Première ligne: {matrix[0, :]}")

Array original: [10 11 12 13 14 15 16 17 18 19]
Élément à l'index 3: 13
Éléments de l'index 2 à 5: [12 13 14 15]

Matrice:
[[1 2 3]
 [4 5 6]
 [7 8 9]]
Élément à la ligne 1, colonne 2: 6
Deuxième colonne: [2 5 8]
Première ligne: [1 2 3]

3.2 L’Indexation Booléenne (Masquage)

C’est une technique extrêmement utile pour filtrer des données selon une condition.

data = np.array([10, 25, 3, 48, 17, 99])

# 1. Créer une condition
condition = data > 20
print(f"Condition (masque booléen): {condition}")

# 2. Utiliser le masque pour filtrer l'array
print(f"Éléments supérieurs à 20: {data[condition]}")

# On peut le faire en une seule ligne
print(f"Éléments pairs: {data[data % 2 == 0]}")

Condition (masque booléen): [False  True False  True False  True]
Éléments supérieurs à 20: [25 48 99]
Éléments pairs: [10 48]

Exercice 2 Créez une matrice 5x5 de nombres entiers aléatoires entre 0 et 100.

1. Extraire le bloc 2x2 en bas à droite de la matrice.
2. Remplacer tous les nombres inférieurs à 50 par la valeur -1.

4 Partie 3 : La Puissance de la Vectorisation

La vectorisation est l’idée d’appliquer des opérations sur des tableaux entiers sans utiliser de boucles for explicites en Python. C’est ce qui rend NumPy si rapide.

4.1 Opérations Mathématiques

arr1 = np.array([1, 2, 3])
arr2 = np.array([4, 5, 6])

# Opérations élément par élément
print(f"Addition: {arr1 + arr2}")
print(f"Multiplication: {arr1 * arr2}")

# Opération avec un scalaire (Broadcasting simple)
print(f"Array + 10: {arr1 + 10}")

# Fonctions universelles (UFuncs)
print(f"Racine carrée: {np.sqrt(arr1)}")

Addition: [5 7 9]
Multiplication: [ 4 10 18]
Array + 10: [11 12 13]
Racine carrée: [1.         1.41421356 1.73205081]

4.2 Opérations

NumPy permet de calculer facilement des statistiques sur les données, et plus globalement de faire des calculs d’algèbre linéaire.

Opérations de base

matrix = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
print(f"Matrice:\n{matrix}")

print(f"Somme de tous les éléments: {matrix.sum()}")
print(f"Moyenne de tous les éléments: {matrix.mean()}")

# Agrégation le long d'un axe
# axis=0 -> opère sur les colonnes
# axis=1 -> opère sur les lignes
print(f"Somme de chaque colonne: {matrix.sum(axis=0)}")
print(f"Moyenne de chaque ligne: {matrix.mean(axis=1)}")

# Opérations matricielles
arr1 = np.array([[1, 2], [3, 4]])
arr2 = np.array([[5, 6], [7, 8]])

print(f"\nMatrice 1:\n{arr1}")
print(f"Matrice 2:\n{arr2}")

## Multiplication élément par élément
print(f"Multiplication élément par élément:\n{arr1 * arr2}")

## Addition élément par élément
print(f"Addition élément par élément:\n{arr1 + arr2}")

## Multiplication matricielle
print(f"Multiplication matricielle:\n{np.dot(arr1, arr2)}")
print(f"Multiplication matricielle avec @:\n{arr1 @ arr2}")

Matrice:
[[1 2 3]
 [4 5 6]
 [7 8 9]]
Somme de tous les éléments: 45
Moyenne de tous les éléments: 5.0
Somme de chaque colonne: [12 15 18]
Moyenne de chaque ligne: [2. 5. 8.]

Matrice 1:
[[1 2]
 [3 4]]
Matrice 2:
[[5 6]
 [7 8]]
Multiplication élément par élément:
[[ 5 12]
 [21 32]]
Addition élément par élément:
[[ 6  8]
 [10 12]]
Multiplication matricielle:
[[19 22]
 [43 50]]
Multiplication matricielle avec @:
[[19 22]
 [43 50]]

Exercice 3 Créez un array représentant les notes (sur 20) de 4 étudiants dans 3 matières.

1. Calculez la moyenne de chaque étudiant.
2. Calculez la note moyenne, la note la plus basse et la note la plus haute pour chaque matière.

Opérations d’Algèbre Linéaire

La librairie NumPy contient un module nommé linalg contenant des fonctions d’algèbre linéaire. Nous en présentons les plus usuelles.

# Charger le module
from numpy import linalg

A = np.array([[1, 2], [3, 4]])
print(f"Matrice A:\n{A}")

# Déterminant
det_A = linalg.det(A)
print(f"\nDéterminant de A: {det_A}")

# Inverse
inv_A = linalg.inv(A)
print(f"\nInverse de A:\n{inv_A}")

# Vérification (A @ inv_A doit être la matrice identité)
print(f"\nA @ inv_A:\n{A @ inv_A}")

# Valeurs propres et vecteurs propres
eigenvalues, eigenvectors = linalg.eig(A)
print(f"\nValeurs propres de A: {eigenvalues}")
print(f"Vecteurs propres de A:\n{eigenvectors}")

# Résolution de système linéaire Ax = b
b = np.array([5, 11])
print(f"\nVecteur b: {b}")

x = linalg.solve(A, b)
print(f"Solution de Ax = b: {x}")

# Décomposition SVD
U, S, Vt = linalg.svd(A)
print(f"\nDécomposition SVD de A:")
print(f"U:\n{U}")
print(f"S:\n{S}")
print(f"Vt:\n{Vt}")

# Décomposition QR
Q, R = linalg.qr(A)
print(f"\nDécomposition QR de A:")
print(f"Q:\n{Q}")
print(f"R:\n{R}")

# Norme matricielle
norm_A = linalg.norm(A)
print(f"\nNorme matricielle de A: {norm_A}")

# Diagonale d'une matrice
diag_A = np.diag(A)
print(f"Diagonale de A: {diag_A}")

# Créer une matrice diagonale
diag_matrix = np.diag(diag_A)
print(f"Matrice diagonale:\n{diag_matrix}")

# Une matrice de 1
ones_matrix = np.ones((3, 3))
print(f"Matrice de 1:\n{ones_matrix}")

# Matrice de 0
zeros_matrix = np.zeros((3, 3))

# Matrice de variances covariances
data = np.array([[1, 2, 3], [4, 5, 6]])
print(f"Matrice de données:\n{data}")

var_cov_matrix = np.cov(data)
print(f"Matrice de variances covariances:\n{var_cov_matrix}")

# Moyenne des colonnes
mean_cols = np.mean(data, axis=0)
print(f"Moyennes des colonnes: {mean_cols}")

Matrice A:
[[1 2]
 [3 4]]

Déterminant de A: -2.0000000000000004

Inverse de A:
[[-2.   1. ]
 [ 1.5 -0.5]]

A @ inv_A:
[[1.00000000e+00 1.11022302e-16]
 [0.00000000e+00 1.00000000e+00]]

Valeurs propres de A: [-0.37228132  5.37228132]
Vecteurs propres de A:
[[-0.82456484 -0.41597356]
 [ 0.56576746 -0.90937671]]

Vecteur b: [ 5 11]
Solution de Ax = b: [1. 2.]

Décomposition SVD de A:
U:
[[-0.40455358 -0.9145143 ]
 [-0.9145143   0.40455358]]
S:
[5.4649857  0.36596619]
Vt:
[[-0.57604844 -0.81741556]
 [ 0.81741556 -0.57604844]]

Décomposition QR de A:
Q:
[[-0.31622777 -0.9486833 ]
 [-0.9486833   0.31622777]]
R:
[[-3.16227766 -4.42718872]
 [ 0.         -0.63245553]]

Norme matricielle de A: 5.477225575051661
Diagonale de A: [1 4]
Matrice diagonale:
[[1 0]
 [0 4]]
Matrice de 1:
[[1. 1. 1.]
 [1. 1. 1.]
 [1. 1. 1.]]
Matrice de données:
[[1 2 3]
 [4 5 6]]
Matrice de variances covariances:
[[1. 1.]
 [1. 1.]]
Moyennes des colonnes: [2.5 3.5 4.5]

Exercice 4  

5 Partie 4 : Manipulation et Fichiers

5.1 Remodeler un Array

On peut changer la forme d’un array tant que le nombre total d’éléments reste le même.

arr = np.arange(1, 13) # 12 éléments
print(f"Array original: {arr}")

# Le remodeler en matrice 3x4
reshaped_arr = arr.reshape(3, 4)
print(f"Array remodelé:\n{reshaped_arr}")

# Transposer une matrice (lignes deviennent colonnes et vice-versa)
print(f"Matrice transposée:\n{reshaped_arr.T}")

Array original: [ 1  2  3  4  5  6  7  8  9 10 11 12]
Array remodelé:
[[ 1  2  3  4]
 [ 5  6  7  8]
 [ 9 10 11 12]]
Matrice transposée:
[[ 1  5  9]
 [ 2  6 10]
 [ 3  7 11]
 [ 4  8 12]]

5.2 Entrées/Sorties

NumPy peut facilement sauvegarder et charger des arrays.

# np.save('mon_array.npy', reshaped_arr)
# loaded_arr = np.load('mon_array.npy')

# Charger depuis un fichier texte (ex: CSV) est aussi possible
# data = np.genfromtxt('mon_fichier.csv', delimiter=',')

6 Conclusion

Vous avez maintenant les bases pour utiliser NumPy efficacement. Vous pouvez créer des tableaux, les manipuler, effectuer des calculs rapides et filtrer des données. Ces compétences sont le point de départ pour presque toute analyse de données en Python. La prochaine étape naturelle est de découvrir la bibliothèque Pandas, qui est construite sur NumPy pour offrir des structures de données encore plus puissantes et flexibles.

7 Exercices

Exercice 5 (QCM NumPy)  

Question 1

Que va produire l’instruction np.arange(2, 11, 4) ?

1. [2, 6, 10, 14]
2. [2, 6, 10]
3. [2, 11, 4]
4. Une erreur

Question 2

import numpy as np
a = np.array([[1, 2, 3], [4, 5, 6]])
print(a.shape)

Que va afficher ce code ?

1. (3, 2)
2. (2, 3)
3. 6
4. 2

Question 3

import numpy as np
matrix = np.arange(1, 10).reshape(3, 3)
print(matrix[:2, 1:])

Que va afficher ce code ?

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

Question 4

import numpy as np
arr = np.array([5, 15, 25, 35, 45])
result = arr[arr < 30]
print(result)

Que va afficher ce code ?

1. [True, True, True, False, False]
2. [5, 15, 25]
3. [35, 45]
4. Une erreur

Question 5

Quelle est la différence principale entre l’opérateur * et la fonction np.dot() (ou l’opérateur @) pour deux matrices NumPy 2D ?

1. Il n’y a aucune différence, ils font la même chose.
2. * fait une multiplication matricielle, tandis que @ fait une multiplication élément par élément.
3. * fait une multiplication élément par élément, tandis que @ fait une multiplication matricielle.
4. * ne fonctionne que pour les vecteurs, @ pour les matrices.

Question 6

import numpy as np
data = np.array([[10, 20], [30, 40]])
print(data.sum(axis=0))

Que va afficher ce code ?

1. [30, 70] (somme des lignes)
2. 100 (somme totale)
3. [40, 60] (somme des colonnes)
4. Une erreur

Question 7

Quel concept NumPy permet d’effectuer l’opération np.array([1, 2, 3]) + 5 sans erreur ?

1. Vectorisation
2. Indexation
3. Broadcasting
4. Slicing

Question 8

À quoi sert la fonction np.linalg.solve(A, b) ?

1. Elle calcule le produit matriciel de A et b.
2. Elle résout le système d’équations linéaires Ax = b en trouvant x.
3. Elle calcule l’inverse de la matrice A.
4. Elle vérifie si la matrice A est singulière.

Question 9

Lequel de ces codes va générer une ValueError ?

1. np.arange(10).reshape(2, 5)
2. np.zeros((3, 3)).T
3. np.arange(9).reshape(3, 4)
4. np.array([1, 2, 3]) * np.array([4, 5, 6])

Question 10

Comment sélectionner tous les nombres pairs d’un array NumPy arr ?

1. arr[arr % 2]
2. arr[arr % 2 == 0]
3. arr.filter(lambda x: x % 2 == 0)
4. np.select(arr, arr % 2 == 0)

Question 11

import numpy as np
a = np.arange(5)
b = a[2:4]
b[0] = 99
print(a)

Que va afficher ce code ?

1. [0 1 2 3 4]
2. [99 1 2 3 4]
3. [0 1 99 3 4]
4. Une erreur, car on ne peut pas modifier une tranche (slice).

Question 12

Quelle instruction crée un array de 5 nombres espacés uniformément entre 0 et 10 (inclus) ?

1. np.arange(0, 10, 5)
2. np.linspace(0, 10, 5)
3. np.random.rand(0, 10, 5)
4. np.array([0, 10, 5])

Question 13

import numpy as np
a = np.array([1, 2])
b = np.array([3, 4])
c = np.vstack((a, b))
print(c.shape)

Que va afficher ce code ?

1. (4,)
2. (2, 2)
3. (1, 4)
4. (4, 1)

Question 14

import numpy as np
a = np.arange(6).reshape(2, 3)
b = a.T
print(b[1, 0])

Que va afficher ce code ?

1. 1
2. 3
3. 4
4. Une erreur

Question 15

import numpy as np
arr = np.array([10, 20, 20, 30, 10, 10])
unique_elements, counts = np.unique(arr, return_counts=True)
print(counts)

Que va afficher ce code ?

1. [10 20 30]
2. [1 2 3]
3. [3 2 1]
4. [1 2 3 1 1 1]

Question 16

import numpy as np
a = np.array([[1, 2, 3], [4, 5, 6]])
b = a.view()
b[0, 0] = 99
print(a[0, 0])

Que va afficher ce code ?

1. 1
2. 99
3. Une erreur

Question 17

Quelle fonction NumPy utiliseriez-vous pour créer un tableau (array) rempli de valeurs booléennes True ?

1. np.ones(shape, dtype=bool)
2. np.full(shape, True)
3. Les deux ci-dessus
4. Aucune des réponses précédentes

Question 18

import numpy as np
a = np.array([1, 2, 3])
b = np.array([4, 5, 6])
c = np.hstack((a, b))
print(c.shape)

Que va afficher ce code ?

1. (2, 3)
2. (3, 2)
3. (6,)
4. (2, 1)

Question 19

import numpy as np
a = np.arange(12).reshape(3, 4)
b = a.transpose((1, 0))
print(b[0, 1])

Que va afficher ce code ?

1. 1
2. 4
3. 3
4. Une erreur

Question 20

import numpy as np
arr = np.array([1, 2, 3, 4, 5, 1, 2, 1, 6, 7])

counts = np.bincount(arr)
print(np.argmax(counts))

Que va afficher ce code ?

1. 1
2. 0
3. 99
4. Une erreur

Exercice 6 Mini-Analyse de Ventes

Vous êtes chargé d’analyser les ventes hebdomadaires de 3 produits.

1. Création des données : Créez une matrice NumPy nommée ventes de forme (7, 3) (7 jours, 3 produits) contenant des nombres entiers aléatoires entre 20 et 100, représentant les unités vendues.

2. Calculs par produit : Calculez le total des ventes pour chaque produit sur toute la semaine. Affichez le résultat.

3. Calculs par jour : Calculez la moyenne des ventes quotidiennes pour tous les produits confondus.

4. Analyse de performance : Identifiez les jours (numéros de ligne) où les ventes du produit 2 (colonne d’index 1) ont dépassé 80 unités.

5. Calcul du chiffre d’affaires : Supposons que les prix des 3 produits soient [10.5, 25.0, 7.8]. Créez un array de prix et utilisez le broadcasting pour calculer le chiffre d’affaires total pour chaque jour.