Exercice Corrigé: NumPy – Partie 4

# Importer la bibliothèque NumPy avec l'alias 'np'.
import numpy as np

# Création d'un tableau NumPy 'tab' contenant les valeurs d'une matrice 3x3
tab = np.array([[5, 3, 7],
                [3, 8, 6],
                [1, 2, 9]])

print("Tableau original:")
print(tab)

n = 8
r = 5

print("\nRemplacer les éléments qui sont égaux à", n, "par", r)
print(np.where(tab == n, r, tab))

print("\nRemplacer les éléments qui sont inférieurs à", n, "par", r)
print(np.where(tab < n, r, tab))

print("\nRemplacer les éléments qui sont supérieurs à", n, "par", r)
print(np.where(tab > n, r, tab))

Sortie:

Tableau original:
[[5 3 7]
 [3 8 6]
 [1 2 9]]

Remplacer les éléments qui sont égaux à 8 par 5
[[5 3 7]
 [3 5 6]
 [1 2 9]]

Remplacer les éléments qui sont inférieurs à 8 par 5
[[5 5 5]
 [5 8 5]
 [5 5 9]]

Remplacer les éléments qui sont supérieurs à 8 par 5
[[5 3 7]
 [3 8 6]
 [1 2 5]]

Explication:

Dans le code ci-dessus : np.array(...) : crée un tableau NumPy 3×3 avec les valeurs données et le stocke dans une variable « tab ».

n = 8 et r = 5 : Fixe les variables n et r à 8 et 5, respectivement.

np.where(tab== n, r, tab) : Cette instruction utilise np.where() pour créer un nouveau tableau ayant la même forme que tab. Pour chaque élément de tab, si l’élément est égal à n (8), le nouveau tableau aura la valeur r (5) à la position correspondante; sinon, le nouveau tableau aura la même valeur que dans tab.

# Importer la bibliothèque NumPy avec l'alias 'np'.
import numpy as np

# Création d'un tableau NumPy 'tab' contenant les valeurs d'une matrice 3x3
tab = np.array([[5, 3, 7],
                [3, 8, 6],
                [1, 2, 9]])

print("Tableau original:")
print(tab)

n = 5
print("\nÉléments supérieurs à", n)
print(tab[tab > n])

n = 6
print("\nÉléments inférieurs à", n)
print(tab[tab < n])

Sortie:

Tableau original:
[[5 3 7]
 [3 8 6]
 [1 2 9]]

Éléments supérieurs à 5
[7 8 6 9]

Éléments inférieurs à 6
[5 3 3 1 2]

Explication:

Dans le code ci-dessus : tab = np.array(...) : Crée un tableau NumPy 3x3 avec les valeurs données.

n = 5 : Fixe la variable n à 5.

print(tab[tab > n]) : Cette ligne utilise l'indexation booléenne pour filtrer les éléments du tableau tab qui sont supérieurs à n (5). Le résultat est un tableau NumPy 1D contenant les éléments filtrés et les résultats sont affichés.

n = 6 : Fixe la variable n à 6.

print(tab[tab < n]) : Cette ligne utilise l'indexation booléenne pour filtrer les éléments du tableau tab qui sont inférieurs à n (6). Le résultat est un tableau NumPy 1D contenant les éléments filtrés et les résultats sont affichés.

# Importer la bibliothèque NumPy avec l'alias 'np'.
import numpy as np

# Création d'un tableau NumPy 'tab' contenant les valeurs d'une matrice 3x3
tab = np.array([[5, 3, 7],
                [3, 8, 6],
                [1, 2, 9]])

print("Tableau original:")
print(tab)


print("\nTrier le tableau par ligne dans l'ordre croissant:")
print(np.sort(tab))


print("\nTrier le tableau par colonne dans l'ordre croissant:")
print(np.sort(tab, axis=0)) 

Sortie:

Tableau original:
[[5 3 7]
 [3 8 6]
 [1 2 9]]

Trier le tableau par ligne dans l'ordre croissant:
[[3 5 7]
 [3 6 8]
 [1 2 9]]

Trier le tableau par colonne dans l'ordre croissant:
[[1 2 6]
 [3 3 7]
 [5 8 9]]

Explication:

np.array(...) : Crée un tableau NumPy 3x3 avec les valeurs données et le stocke dans la variable 'tab'

print(np.sort(tab)) : Cette ligne trie le tableau tab selon le dernier axe (axis=-1 ou axis=1) par défaut. Chaque ligne est triée individuellement. Les résultats sont affichés.

print(np.sort(tab, axis=0)) : Cette ligne trie le tableau selon le premier axe (axe=0). Chaque colonne est triée individuellement. Les résultats sont affichés.

# Importer la bibliothèque NumPy avec l'alias 'np'.
import numpy as np

# Création d'un tableau NumPy 'tab' de forme (5, 6) rempli de zéros de type entier
tab = np.zeros(shape=(5, 6), dtype='int')

print("Tableau rempli de zéros:")
print(tab)

Sortie:

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

Explication:

Dans le code ci-dessus: np.zeros(shape=(5, 6), dtype='int') crée un tableau 2D 5x6 rempli de zéros de type entier et le stocke dans la variable 'tab'

# Importer la bibliothèque NumPy avec l'alias 'np'.
import numpy as np

# Création d'un tableau NumPy 'tab' allant de 0 à 15 et transformation en un tableau 4x4
tab = np.arange(16, dtype='int').reshape(-1, 4)

print("Tableau original:")
print(tab)

# Échanger la première et la dernière ligne du tableau 'tab'.
# tab[[0,-1],:] accède à la première et à la dernière ligne, puis les intervertit en utilisant l'indexation avancée.
tab[[0,-1],:] = tab[[-1,0],:]

print("\nAprès permutation de la première et de la dernière ligne:")
print(tab)

Sortie:

Tableau original:
[[ 0  1  2  3]
 [ 4  5  6  7]
 [ 8  9 10 11]
 [12 13 14 15]]

Après permutation de la première et de la dernière ligne:
[[12 13 14 15]
 [ 4  5  6  7]
 [ 8  9 10 11]
 [ 0  1  2  3]]

Explication:

Dans le code ci-dessus: np.arange(16, dtype='int').reshape(-1, 4) crée un tableau 2D d'entiers de 0 à 15 avec une forme de 4 lignes et 4 colonnes, stocké dans la variable 'tab'. Le -1 dans la méthode reshape signifie que NumPy déduira automatiquement le nombre de lignes en fonction du nombre de colonnes spécifié (4 dans ce cas).

tab[[0,-1],:] = tab[[-1,0],:]: Cette ligne échange la première (0-ième) et la dernière (-1-ième) ligne du tableau tab. Elle utilise l'indexation avancée pour y parvenir :

• tab[[0,-1],:]: Sélectionne la première et la dernière ligne du tableau.
• tab[[-1,0],:]: sélectionne la dernière et la première ligne du tableau, dans cet ordre.

Ensuite, les lignes sélectionnées sont assignées l'une à l'autre, ce qui a pour effet d'intervertir leurs positions dans le tableau.

# Importer la bibliothèque NumPy avec l'alias 'np'.
import numpy as np

# Fixer à 10 la graine du générateur de nombres aléatoires de NumPy
np.random.seed(10)

# Générer un tableau de 20 nombres aléatoires à partir d'une distribution uniforme [0, 1].
print(np.random.rand(20))

Sortie:

[0.77132064 0.02075195 0.63364823 0.74880388 0.49850701 0.22479665
 0.19806286 0.76053071 0.16911084 0.08833981 0.68535982 0.95339335
 0.00394827 0.51219226 0.81262096 0.61252607 0.72175532 0.29187607
 0.91777412 0.71457578]

Explication:

Dans le code ci-dessus : np.random.seed(10) fixe la valeur de la graine aléatoire à 10. La définition de la graine garantit que le même ensemble de nombres aléatoires est généré chaque fois que le code est exécuté. Elle est utile pour la reproductibilité lorsque vous travaillez avec des nombres aléatoires dans votre code.

print(np.random.rand(20)) : Cette ligne génère un tableau de 20 nombres aléatoires compris entre 0 (inclus) et 1 (exclu), en utilisant une distribution uniforme. La fonction np.random.rand() est utilisée pour générer les nombres aléatoires, et le tableau résultant est affiché.

# Importer la bibliothèque NumPy avec l'alias 'np'.
import numpy as np

print("Créer un tableau de forme (5,4):") 

print(np.arange(1, 21).reshape(5, 4)) 

Sortie:

Créer un tableau de forme (5,4):
[[ 1  2  3  4]
 [ 5  6  7  8]
 [ 9 10 11 12]
 [13 14 15 16]
 [17 18 19 20]]

Explication:

Dans le code ci-dessus: print(np.arange(1, 21).reshape(5, 4)): Cette instruction crée un tableau NumPy avec des entiers de 1 (inclus) à 21 (exclus), c'est-à-dire des entiers de 1 à 20, et le remodèle en une matrice 5x4 (5 lignes et 4 colonnes). Une copie des résultats est affichée.

# Importer la bibliothèque NumPy avec l'alias 'np'.
import numpy as np

# Création d'un tableau unidimensionnel 'tab' contenant des nombres de 1 à 20
tab = np.arange(1, 21)
print("Tableau unidimensionnel de chiffres simples:") 
print(tab)

# Création d'un tableau unidimensionnel 'tab' contenant des nombres de 10 à 20
tab = np.arange(10, 21)
print("\nTableau unidimensionnel de nombres à deux chiffres:") 
print(tab)

# Création d'un tableau unidimensionnel 'tab' contenant des nombres de 100 à 200
tab = np.arange(100, 201)
print("\nTableau unidimensionnel de nombres à trois chiffres:") 
print(tab)

Sortie:

Tableau unidimensionnel de chiffres simples:
[ 1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20]

Tableau unidimensionnel de nombres à deux chiffres:
[10 11 12 13 14 15 16 17 18 19 20]

Tableau unidimensionnel de nombres à trois chiffres:
[100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117
 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135
 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153
 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171
 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189
 190 191 192 193 194 195 196 197 198 199 200]

Explication:

L'exercice ci-dessus montre la création de trois tableaux NumPy différents à l'aide de la fonction np.arange() avec différents points de départ et d'arrivée.

np.arange(1, 21) crée un tableau NumPy contenant des entiers de 1 (inclus) à 21 (exclus), c'est-à-dire des entiers de 1 à 20.

np.arange(10, 21) crée un tableau NumPy contenant des entiers de 10 (inclus) à 21 (exclusifs), c'est-à-dire des entiers de 10 à 20.

np.arange(100, 201) crée un nouveau tableau NumPy contenant des entiers de 100 (inclus) à 201 (exclusifs), c'est-à-dire des entiers de 100 à 200.

# Importer la bibliothèque NumPy avec l'alias 'np'.
import numpy as np

# Création des tableaux NumPy 'tab1' et 'tab2'.
tab1 = np.array([0, 1, 2])
tab2 = np.array([0, 1, 3])

print("Tableaux originaux:")
print(tab1)
print(tab2)

# Afficher un message demandant si les deux tableaux sont égaux en termes d'éléments ou non
print("\nTester si deux tableaux sont égaux (en termes d'éléments) ou non:")
print(tab1 == tab2)

Sortie:

Tableaux originaux:
[0 1 2]
[0 1 3]

Tester si deux tableaux sont égaux (en termes d'éléments) ou non:
[True True False]

Explication:

Le code ci-dessus montre comment comparer deux tableaux NumPy à l'aide de l'opérateur == et de la fonction np.equal().

tab1 = np.array(...) : Cette instruction crée un tableau NumPy nommé « tab1 » contenant trois valeurs.

tab2 = np.array(...) : Cette instruction crée un autre tableau NumPy nommé 'tab2' contenant trois valeurs.

print(tab1 == tab2) : Cette instruction compare les deux tableaux 'tab1' et 'tab2' en utilisant l'opérateur == et affiche le tableau booléen résultant.

# Importer la bibliothèque NumPy avec l'alias 'np'.
import numpy as np

# Création d'un tableau NumPy 'tab' avec des valeurs fournies, y compris NaN (Not a Number)
tab = np.array([[1, 5, np.nan, 3],
                 [9, 7, 6, 8],
                 [3, np.nan, 0, np.nan]])

print("Tableau original:")
print(tab)

# Afficher un message indiquant que les données manquantes (NaN) ont été trouvées dans le tableau à l'aide de np.isnan()
# Cette fonction renvoie un tableau booléen de la même forme que « tab », où True représente les valeurs NaN.
print("\nTrouver les données manquantes de ce tableau:")
print(np.isnan(tab))

Sortie:

Tableau original:
[[ 1.  5. nan  3.]
 [ 9.  7.  6.  8.]
 [ 3. nan  0. nan]]

Trouver les données manquantes de ce tableau:
[[False False True False]
 [False False False False]
 [False True False True]]

Explication:

L'exemple ci-dessus crée un tableau NumPy contenant des valeurs NaN et affiche un tableau booléen indiquant quels éléments du tableau original sont des valeurs NaN.

tab = np.array(...) : Ici, np.array(...) crée un tableau NumPy 2D nommé « tab » avec 3 lignes et 4 colonnes. Certains éléments du tableau sont des NaN (Not a Number).

print(np.isnan(tab)) : La fonction np.isnan() renvoie un tableau booléen de la même forme que « tab », où chaque élément indique si l'élément correspondant dans « tab » est NaN ou non. Enfin, elle affiche le tableau booléen résultant.