1.1. Pourquoi avons-nous besoin de Numpy ?
Pour un débutant, une question légitime est : "Pourquoi ne pas simplement utiliser les listes Python ?". Voici la réponse :
- Performance : Les listes Python sont flexibles, mais cette flexibilité les rend lentes. Les tableaux Numpy ne contiennent qu'un seul type de données, ce qui leur permet d'effectuer des calculs jusqu'à 50 fois plus vite.
- Fonctionnalités : Numpy offre une quantité impressionnante de fonctions mathématiques optimisées, indisponibles avec les listes de base.
- Consommation Mémoire : Les tableaux Numpy sont plus compacts en mémoire que les listes Python.
En résumé, pour tout ce qui touche au calcul numérique ou à la science des données, Numpy n'est pas une option, c'est le standard.
1.2. Le cœur de Numpy : Le ndarray
L'objet central de Numpy est le ndarray (tableau N-dimensionnel). Imaginez-le comme une grille puissante qui peut avoir une, deux, trois dimensions ou plus.
- Un tableau 1D est un vecteur (une simple ligne de données).
- Un tableau 2D est une matrice (une grille avec des lignes et des colonnes).
- Un tableau 3D peut représenter une image (hauteur, largeur, canaux de couleur).
1.3. Créer des tableaux Numpy
Voici les manières les plus courantes de créer des tableaux.
import numpy as np # 'np' est l'alias standard
# 1. À partir d'une liste Python
ma_liste = [1, 2, 3, 4]
arr_1d = np.array(ma_liste)
print("Tableau 1D:", arr_1d)
ma_liste_2d = [[1, 2, 3], [4, 5, 6]]
arr_2d = np.array(ma_liste_2d)
print("Tableau 2D:\n", arr_2d)
# 2. Créer des tableaux à partir de rien
zeros = np.zeros(5)
print("Tableau de zéros:", zeros)
ones = np.ones((3, 4))
print("Matrice de uns:\n", ones)
# 3. Créer des séquences
range_arr = np.arange(10)
print("Séquence de 0 à 9:", range_arr)
linspace_arr = np.linspace(0, 100, 5)
print("Tableau espacé uniformément:", linspace_arr)
# 4. Créer des tableaux aléatoires
rand_arr = np.random.rand(2, 3)
print("Matrice aléatoire:\n", rand_arr)
1.4. Les attributs d'un tableau
Pour comprendre avec quel type de tableau vous travaillez, vous pouvez inspecter ses attributs :
arr_2d = np.array([[1, 2, 3], [4, 5, 6]])
print("Dimensions (shape):", arr_2d.shape) # (2, 3) -> 2 lignes, 3 colonnes
print("Nombre de dimensions (ndim):", arr_2d.ndim) # 2
print("Nombre total d'éléments (size):", arr_2d.size) # 6
print("Type de données (dtype):", arr_2d.dtype) # int64
2. Opérations et Manipulations avec Numpy
2.1. La magie de la Vectorisation
C'est le concept le plus important. Au lieu d'écrire une boucle for pour additionner chaque élément de deux tableaux, vous faites simplement tableau1 + tableau2. C'est plus lisible et infiniment plus rapide.
# Sans vectorisation (lent et verbeux)
list1 = [1, 2, 3]
list2 = [4, 5, 6]
resultat_liste = [list1[i] + list2[i] for i in range(len(list1))]
print("Résultat avec une boucle for:", resultat_liste)
# Avec la vectorisation Numpy (rapide et concis)
arr1 = np.array(list1)
arr2 = np.array(list2)
resultat_arr = arr1 + arr2
print("Résultat avec Numpy:", resultat_arr)
Cela s'applique à toutes les opérations : *, /, **, et aussi aux fonctions Numpy comme np.sqrt() (racine carrée).
2.2. Indexing et Slicing
Comme avec les listes, on peut extraire des parties d'un tableau.
arr = np.arange(10) # [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
# Indexing simple
print("Le 3ème élément:", arr[2]) # 2
# Slicing (extraire une tranche)
print("Éléments de l'index 2 à 5:", arr[2:6]) # [2, 3, 4, 5]
# Pour les tableaux 2D, on utilise [ligne, colonne]
arr_2d = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
print("Élément à la ligne 1, colonne 2:", arr_2d[1, 2]) # 6
# Extraire la première colonne entière
print("Première colonne:", arr_2d[:, 0]) # [1, 4, 7]
2.3. Calculs Statistiques
Numpy excelle dans le calcul de statistiques sur de grands volumes de données.
data = np.array([15, 20, 22, 28, 35, 40])
print("Moyenne:", data.mean())
print("Somme:", data.sum())
print("Écart-type:", data.std())
print("Valeur maximale:", data.max())
Exercices Pratiques
Exercice 1 : Création et Inspection
Créez un tableau Numpy 2D à partir de la liste Python suivante : [[10, 20], [30, 40], [50, 60]]. Ensuite, affichez sa forme (shape), son nombre de dimensions (ndim) et son type de données (dtype).
Voir la solution
import numpy as np
ma_liste = [[10, 20], [30, 40], [50, 60]]
mon_array = np.array(ma_liste)
print("Tableau créé :\n", mon_array)
print("Shape :", mon_array.shape)
print("Nombre de dimensions :", mon_array.ndim)
print("Type de données :", mon_array.dtype)
Exercice 2 : Vectorisation Simple
Créez un tableau Numpy contenant les nombres de 0 à 9. En une seule ligne de code (sans utiliser de boucle), multipliez chaque élément de ce tableau par 5, puis ajoutez 10 à chaque élément. Affichez le résultat final.
Voir la solution
import numpy as np
arr = np.arange(10)
resultat = arr * 5 + 10
print("Tableau original :", arr)
print("Résultat final :", resultat)
Exercice 3 : Slicing et Statistiques
Créez la matrice 3x3 suivante : [[1, 2, 3], [4, 5, 6], [7, 8, 9]]. À partir de cette matrice, extrayez la deuxième colonne ([2, 5, 8]). Ensuite, calculez la moyenne et la somme des éléments de cette colonne extraite.
Voir la solution
import numpy as np
matrice = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
# On extrait toutes les lignes (:) de la colonne à l'index 1
colonne_2 = matrice[:, 1]
print("Matrice originale :\n", matrice)
print("Deuxième colonne :", colonne_2)
print("Moyenne de la colonne :", colonne_2.mean())
print("Somme de la colonne :", colonne_2.sum())