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 numpy

2. 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 2

---

3. 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-tableau

---

4. 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 2x3

b) Transposer un tableau

# Transposer une matrice (échanger lignes et colonnes)
matrice = np.array([[1, 2, 3], [4, 5, 6]])
transposee = matrice.T

---

6. 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 3x2

c) 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)] = 0

---

8. 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 avec num valeurs uniformément espacées entre start et stop.
• np.eye(n) : Crée une matrice identité de taille n 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 :

3

---

4. 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.