Manipulation des Tableaux en Python avec Numpy
Numpy est une bibliothèque puissante et efficace pour la manipulation de tableaux multidimensionnels (ou arrays) en Python. C’est un outil essentiel pour le calcul numérique, car il permet de gérer de grands ensembles de données et de réaliser des opérations mathématiques complexes de manière optimisée.
Voici un guide détaillé pour manipuler des tableaux avec Numpy.
1. Installation de Numpy
Si vous n’avez pas encore installé Numpy, vous pouvez l’installer via pip :
pip install numpy2. Création d’un Tableau Numpy (Array)
Un tableau Numpy est similaire à une liste Python, mais il est optimisé pour les opérations mathématiques et la manipulation de grands ensembles de données.
a) Créer un tableau à partir d’une liste
import numpy as np
# Créer un tableau à partir d'une liste Python
arr = np.array([1, 2, 3, 4, 5])
print(arr)b) Créer un tableau multidimensionnel (matrice)
# Créer un tableau 2D (matrice)
matrice = np.array([[1, 2], [3, 4], [5, 6]])
print(matrice)c) Créer des tableaux avec des valeurs spéciales
# Tableau de zéros
zeros = np.zeros((3, 3))
# Tableau de uns
uns = np.ones((2, 4))
# Tableau de valeurs aléatoires
random_values = np.random.rand(3, 3)
# Tableau d'une séquence de nombres
range_values = np.arange(0, 10, 2) # De 0 à 10, pas de 23. Manipulation de Base des Tableaux Numpy
a) Accéder aux éléments
arr = np.array([10, 20, 30, 40, 50])
# Accéder à un élément par index
print(arr[0]) # Premier élément (10)
print(arr[-1]) # Dernier élément (50)
# Accéder à un élément dans une matrice
mat = np.array([[1, 2], [3, 4], [5, 6]])
print(mat[1, 1]) # Accède à l'élément de la 2ème ligne, 2ème colonne (4)b) Slicing (découpage)
# Extraire une sous-partie du tableau
sous_partie = arr[1:4] # Du 2ème au 4ème élément
print(sous_partie) # [20 30 40]
# Slicing sur une matrice
print(mat[0:2, 0:2]) # Extraire un sous-tableau4. Opérations sur les Tableaux
Les opérations sur les arrays Numpy sont réalisées de manière élément par élément (vectorisation), ce qui est très rapide et optimisé.
a) Opérations arithmétiques
# Créer un tableau
arr = np.array([1, 2, 3, 4])
# Ajouter une valeur à tous les éléments
arr_plus_5 = arr + 5 # [6 7 8 9]
# Multiplier tous les éléments par 2
arr_times_2 = arr * 2 # [2 4 6 8]
# Calculer la racine carrée
arr_sqrt = np.sqrt(arr) # [1. 1.41 1.73 2.]b) Opérations mathématiques
# Somme de tous les éléments
somme = arr.sum()
# Produit de tous les éléments
produit = arr.prod()
# Moyenne des éléments
moyenne = arr.mean()
# Maximum et minimum
max_value = arr.max()
min_value = arr.min()c) Opérations entre tableaux
# Additionner deux tableaux élément par élément
arr1 = np.array([1, 2, 3])
arr2 = np.array([4, 5, 6])
resultat = arr1 + arr2 # [5 7 9]
# Produit élément par élément
produit_element = arr1 * arr2 # [4 10 18]5. Manipulation des Dimensions des Tableaux
a) Reshape : Changer la forme d’un tableau
# Reshape d'un tableau 1D en 2D
arr = np.array([1, 2, 3, 4, 5, 6])
arr_reshape = arr.reshape(2, 3) # Transforme en matrice 2x3b) Transposer un tableau
# Transposer une matrice (échanger lignes et colonnes)
matrice = np.array([[1, 2, 3], [4, 5, 6]])
transposee = matrice.T6. Opérations Avancées sur les Tableaux
a) Concaténer des tableaux
arr1 = np.array([1, 2, 3])
arr2 = np.array([4, 5, 6])
# Concatenation de deux tableaux en un seul
concatene = np.concatenate((arr1, arr2)) # [1 2 3 4 5 6]b) Empiler des matrices
# Empiler des matrices verticalement
arr1 = np.array([[1, 2], [3, 4]])
arr2 = np.array([[5, 6]])
stacked = np.vstack((arr1, arr2)) # Matrice 3x2c) Filtrer les éléments d’un tableau
arr = np.array([10, 20, 30, 40, 50])
# Filtrer les éléments supérieurs à 25
filtre = arr[arr > 25] # [30 40 50]7. Gestion des Valeurs Manquantes
Dans Numpy, les valeurs manquantes sont représentées par np.nan (Not a Number).
a) Créer un tableau avec des valeurs manquantes
arr_nan = np.array([1, 2, np.nan, 4])b) Vérifier la présence de valeurs manquantes
# Vérifier s'il y a des NaN
has_nan = np.isnan(arr_nan) # [False False True False]c) Remplacer les valeurs manquantes
# Remplacer les NaN par une valeur spécifique (exemple : 0)
arr_nan[np.isnan(arr_nan)] = 08. Tableaux Aléatoires
Numpy permet de générer facilement des nombres aléatoires.
a) Générer des nombres aléatoires
# Générer un tableau de valeurs aléatoires uniformes entre 0 et 1
valeurs_aleatoires = np.random.rand(3, 3)
# Générer des nombres aléatoires entiers entre 0 et 10
aleatoires_entiers = np.random.randint(0, 10, size=(3, 3))b) Mélanger un tableau
arr = np.array([1, 2, 3, 4, 5])
# Mélanger les éléments du tableau
np.random.shuffle(arr)9. Comparaisons et Masques Logiques
Vous pouvez réaliser des comparaisons élément par élément dans un tableau pour obtenir des résultats booléens (True/False).
a) Comparaisons élément par élément
arr = np.array([1, 2, 3, 4, 5])
# Vérifier si chaque élément est supérieur à 3
resultat = arr > 3 # [False False False True True]b) Appliquer un masque logique
# Extraire les éléments supérieurs à 3
elements_filtres = arr[arr > 3] # [4 5]10. Fonctions Utiles de Numpy
np.linspace(start, stop, num): Génère un tableau avecnumvaleurs uniformément espacées entrestartetstop.np.eye(n): Crée une matrice identité de taillen x n.np.dot(a, b): Produit matriciel entre deux matrices.np.argmax(arr): Renvoie l’indice du plus grand élément du tableau.
Numpy est une bibliothèque extrêmement puissante et polyvalente pour manipuler des tableaux multidimensionnels et effectuer des calculs numériques en Python. Ce guide couvre les bases de la manipulation des tableaux, les opérations mathématiques, la gestion des dimensions et des valeurs manquantes, ainsi que des opérations plus avancées comme le filtrage, la concaténation, et l’utilisation des tableaux aléatoires.
Cas Particuliers avec Numpy : Manipulation des Tableaux
Voici quelques cas particuliers d’utilisation des tableaux Numpy pour des manipulations avancées ou spécifiques qui peuvent être utiles dans différentes situations.
1. Remplir un Tableau avec une Diagonale
Remplir uniquement la diagonale principale d’une matrice avec une valeur spécifique est une opération courante.
Exemple : Créer une matrice avec des valeurs sur la diagonale
import numpy as np
# Créer une matrice 4x4 de zéros
matrice = np.zeros((4, 4))
# Remplir la diagonale avec 1
np.fill_diagonal(matrice, 1)
print(matrice)Résultat :
[[1. 0. 0. 0.]
[0. 1. 0. 0.]
[0. 0. 1. 0.]
[0. 0. 0. 1.]]2. Normaliser un Tableau
La normalisation consiste à mettre tous les éléments d’un tableau entre 0 et 1 en fonction de leurs valeurs maximales et minimales.
Exemple : Normaliser un tableau
arr = np.array([10, 20, 30, 40, 50])
# Normaliser les valeurs entre 0 et 1
arr_normalise = (arr - arr.min()) / (arr.max() - arr.min())
print(arr_normalise)Résultat :
[0. 0.25 0.5 0.75 1. ]3. Compter les Occurrences d’une Valeur
Si vous avez un tableau avec des répétitions de valeurs, vous pouvez compter le nombre d’occurrences d’une valeur spécifique.
Exemple : Compter les occurrences d’une valeur
arr = np.array([1, 2, 3, 2, 4, 2, 5])
# Compter le nombre d'occurrences de la valeur 2
nombre_de_2 = np.count_nonzero(arr == 2)
print(nombre_de_2)Résultat :
34. Appliquer une Fonction sur Chaque Élément du Tableau
Vous pouvez appliquer une fonction personnalisée sur chaque élément du tableau grâce à np.vectorize().
Exemple : Appliquer une fonction pour calculer la racine carrée
# Fonction pour calculer la racine carrée
def carre(x):
return x ** 2
# Créer un tableau
arr = np.array([1, 2, 3, 4, 5])
# Appliquer la fonction sur chaque élément
carres = np.vectorize(carre)(arr)
print(carres)Résultat :
[ 1 4 9 16 25]5. Obtenir les Indices des Valeurs Maximales/Minimales
Dans certains cas, vous aurez besoin de connaître l’indice (ou les indices) des valeurs maximales ou minimales dans un tableau.
Exemple : Trouver l’indice de la valeur maximale
arr = np.array([10, 25, 8, 50, 42])
# Trouver l'indice de la valeur maximale
indice_max = np.argmax(arr)
print(indice_max)Résultat :
3 # (indice de la valeur 50)6. Faire des Opérations avec des Tableaux de Dimensions Différentes (Broadcasting)
Le broadcasting est une fonctionnalité puissante de Numpy qui permet d’effectuer des opérations entre des tableaux de tailles différentes de manière efficace.
Exemple : Ajouter un tableau 1D à chaque ligne d’un tableau 2D
# Créer un tableau 2D
matrice = np.array([[1, 2, 3], [4, 5, 6]])
# Créer un tableau 1D
ligne = np.array([10, 20, 30])
# Ajouter le tableau 1D à chaque ligne du tableau 2D (broadcasting)
resultat = matrice + ligne
print(resultat)Résultat :
[[11 22 33]
[14 25 36]]7. Trouver des Valeurs Uniques dans un Tableau
Si vous avez un tableau avec des valeurs répétées et que vous voulez extraire les valeurs uniques, vous pouvez utiliser np.unique().
Exemple : Extraire les valeurs uniques d’un tableau
arr = np.array([1, 2, 3, 2, 4, 1, 5])
# Extraire les valeurs uniques
valeurs_uniques = np.unique(arr)
print(valeurs_uniques)Résultat :
[1 2 3 4 5]8. Empiler Horizontalement et Verticalement des Tableaux
Il peut être utile d’empiler plusieurs tableaux soit horizontalement (en ajoutant des colonnes), soit verticalement (en ajoutant des lignes).
Exemple : Empiler verticalement des tableaux
arr1 = np.array([[1, 2], [3, 4]])
arr2 = np.array([[5, 6]])
# Empiler verticalement
empile_vert = np.vstack((arr1, arr2))
print(empile_vert)Résultat :
[[1 2]
[3 4]
[5 6]]Exemple : Empiler horizontalement des tableaux
arr3 = np.array([[7], [8]])
# Empiler horizontalement
empile_horiz = np.hstack((arr1, arr3))
print(empile_horiz)Résultat :
[[1 2 7]
[3 4 8]]9. Transformer un Tableau en 1D (Flatten)
Parfois, vous avez un tableau multidimensionnel et vous avez besoin de le transformer en un tableau à une dimension.
Exemple : Aplatir une matrice 2D en tableau 1D
matrice = np.array([[1, 2, 3], [4, 5, 6]])
# Transformer en tableau 1D
flattened = matrice.flatten()
print(flattened)Résultat :
[1 2 3 4 5 6]10. Calcul de la Covariance et de la Corrélation
Numpy permet de calculer la covariance et la corrélation entre des ensembles de données stockés dans des tableaux.
Exemple : Calculer la covariance
# Créer deux ensembles de données
x = np.array([2, 4, 6, 8])
y = np.array([1, 3, 5, 7])
# Calculer la matrice de covariance
covariance = np.cov(x, y)
print(covariance)Résultat :
[[6.66666667 6.66666667]
[6.66666667 6.66666667]]Exemple : Calculer la corrélation
# Calculer la matrice de corrélation
correlation = np.corrcoef(x, y)
print(correlation)Résultat :
[[1. 1.]
[1. 1.]]Ces cas particuliers montrent la puissance et la flexibilité de Numpy dans la manipulation des tableaux. Que ce soit pour travailler avec des matrices, manipuler des valeurs spécifiques, gérer des dimensions différentes ou réaliser des calculs statistiques avancés, Numpy offre des outils adaptés et optimisés pour chaque besoin.
Autres articles
