Exercice Corrigé: NumPy – Partie 2

Ce programme NumPy crée un vecteur dont les valeurs sont comprises entre 15 et 34. Il affiche ensuite tous les éléments du vecteur à l’exception du premier et du dernier. En utilisant les capacités de découpage de tableau de NumPy, le programme extrait et affiche efficacement le sous-ensemble spécifié des éléments du vecteur.

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

# Création d'un tableau NumPy 'v' contenant des entiers de 15 à 34 en utilisant np.arange()
v = np.arange(15, 35)

print("Vecteur original:")
print(v)

print("Toutes les valeurs à l'exception de la première et de la dernière de ce vecteur:")
print(v[1:-1]) 

Sortie:

Vecteur original:
[15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34]
Toutes les valeurs à l'exception de la première et de la dernière de ce vecteur:
[16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33]

Ce programme NumPy crée un tableau 3×4 et itère ensuite sur ses éléments. En utilisant les fonctions de création de tableau de NumPy, il construit le tableau et, à l’aide des techniques d’itération, il accède à chaque élément et le traite individuellement.

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

# Création d'un tableau NumPy 'tab' contenant des entiers de 10 à 21 et transformation en une matrice 3x4 à l'aide de np.arange() et .reshape()
tab = np.arange(10, 22).reshape((3, 4))

# Affichage d'un message indiquant le tableau original 'tab'
print("Tableau original:")
print(tab)

# Affichage d'un message indiquant chaque élément du tableau en utilisant np.nditer() pour parcourir les éléments.
print("Chaque élément du tableau est:")
for x in np.nditer(tab):
    print(x, end=" ")

Sortie:

Tableau original:
[[10 11 12 13]
 [14 15 16 17]
 [18 19 20 21]]
Chaque élément du tableau est:
10 11 12 13 14 15 16 17 18 19 20 21 

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

# Génération d'un tableau NumPy 'tab' contenant 5 entiers aléatoires entre 0 et 10 en utilisant np.random.randint()
tab = np.random.randint(0, 11, 5)

# Afficher le vecteur de longueur 5 rempli d'entiers aléatoires de 0 à 10
print(tab)

Sortie:

[7 9 5 1 6]

Explication:

Dans le code ci-dessus, la fonction np.random.randint() génère un tableau d’entiers aléatoires. La fonction prend trois arguments : la borne inférieure (inclusive), la borne supérieure (exclusive) et le nombre d’entiers aléatoires à générer. Dans ce cas, elle génère un tableau de 5 entiers aléatoires compris entre 0 (inclusif) et 11 (exclusif).

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

# Création d'un tableau NumPy 'x' contenant les éléments 1, 4, 6 et 9
x = np.array([1, 4, 6, 9])

# Afficher le Vecteur-1
print("Vecteur-1:", x)

# Générer un tableau NumPy 'y' contenant 4 entiers aléatoires entre 0 et 10 en utilisant np.random.randint()
y = np.random.randint(0, 11, 4)

# Afficher le Vecteur-2
print("Vecteur-2:", y)

# Effectuer une multiplication par éléments entre les tableaux 'x' et 'y' et stocker le résultat dans la variable 'result'.
result = x * y

print("Multiplication des valeurs de deux vecteurs:",result)

Sortie:

Vecteur-1: [1 4 6 9]
Vecteur-2: [8 6 10 10]
Multiplication des valeurs de deux vecteurs: [8 24 60 90]

Explication:

np.array([1, 8, 3, 5]) crée un tableau NumPy ‘x’ avec les éléments spécifiés [1, 4, 6, 9].

np.random.randint(0, 11, 4) crée un tableau NumPy « y » de 4 entiers aléatoires compris entre 0 (inclus) et 11 (exclus).

x * y effectue une multiplication par éléments entre les tableaux ‘x’ et ‘y’. Les éléments correspondants de ‘x’ et ‘y’ sont multipliés ensemble, ce qui donne un nouveau tableau ‘result’ ayant la même forme que les tableaux originaux

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

# Création d'un tableau NumPy 'm' contenant des entiers de 10 à 21 et transformation en une matrice 3x4 à l'aide de np.arange() et .reshape()
m = np.arange(10, 22).reshape((3, 4))

# Affichage du tableau 'm' représentant une matrice 3x4
print(m)

Sortie:

[[10 11 12 13]
 [14 15 16 17]
 [18 19 20 21]]

Explication:

Dans le code ci-dessus, la fonction np.arange() crée un tableau NumPy contenant des entiers de 10 à 21. La fonction np.arange() génère un tableau de valeurs régulièrement espacées dans un intervalle spécifié. Dans ce cas, elle génère un tableau commençant à 10 et se terminant avant 22, avec une taille de pas par défaut de 1, ce qui donne un tableau d’entiers compris entre 10 et 21. Ensuite, la méthode reshape() est utilisée pour changer la forme du tableau généré en une matrice 3×4 (3 lignes et 4 colonnes).

Enfin, print(m) affiche le tableau remodelé « m » sur la console. La sortie sera une matrice 3×4 contenant des entiers de 10 à 21 disposés selon la forme spécifiée.

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

# Création d'un tableau NumPy 'm' contenant des entiers de 10 à 21 et transformation en une matrice 3x4 à l'aide de np.arange() et .reshape()
m = np.arange(10, 22).reshape((3, 4))

# Affichage d'un message indiquant la matrice d'origine m.
print("Matrice originale:")
print(m)

print("Nombre de lignes et de colonnes de la matrice est:")
print(m.shape)

Sortie:

Matrice originale:
[[10 11 12 13]
 [14 15 16 17]
 [18 19 20 21]]
Nombre de lignes et de colonnes de la matrice est:
(3, 4)

Explication:

Dans le code ci-dessus, la fonction np.arange() génère un tableau de valeurs régulièrement espacées dans un intervalle spécifié. Dans ce cas, elle génère un tableau commençant à 10 et se terminant avant 22, avec une taille de pas par défaut de 1, ce qui donne un tableau d’entiers de 10 à 21. Ensuite, la méthode reshape() est utilisée pour changer la forme du tableau généré en une matrice 3×4 (3 lignes et 4 colonnes).

Ensuite, print(m) affiche le tableau remodelé « m » sur la console. La sortie sera une matrice 3×4 contenant des entiers de 10 à 21..

Enfin, print(m.shape) affiche la forme du tableau ‘m’ sur la console.

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

# Création d'une matrice identité 3x3 à l'aide de np.eye()
x = np.eye(3)

# Affichage de la matrice d'identité 3x3 créée x.
print(x)

Sortie:

[[1. 0. 0.]
 [0. 1. 0.]
 [0. 0. 1.]]

Explication:

Une matrice identité est une matrice carrée dont la diagonale principale comporte des uns et les autres des zéros.

Dans le code ci-dessus, la ligne « x = np.eye(3) » utilise la fonction np.eye() pour créer une matrice identité carrée bidimensionnelle « x » de taille 3×3.

Enfin, print(x) affiche la matrice d’identité générée sur la console.

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

# Création d'une matrice 10x10 remplie de 1 en utilisant np.ones()
x = np.ones((10, 10))

# Mise à 0 des valeurs internes de la matrice x (à l'exclusion des bords) à l'aide du découpage en tranches
x[1:-1, 1:-1] = 0

# Affichage de la matrice modifiée x
print(x) 

Sortie:

[[1. 1. 1. 1. 1. 1. 1. 1. 1. 1.]
 [1. 0. 0. 0. 0. 0. 0. 0. 0. 1.]
 [1. 0. 0. 0. 0. 0. 0. 0. 0. 1.]
 [1. 0. 0. 0. 0. 0. 0. 0. 0. 1.]
 [1. 0. 0. 0. 0. 0. 0. 0. 0. 1.]
 [1. 0. 0. 0. 0. 0. 0. 0. 0. 1.]
 [1. 0. 0. 0. 0. 0. 0. 0. 0. 1.]
 [1. 0. 0. 0. 0. 0. 0. 0. 0. 1.]
 [1. 0. 0. 0. 0. 0. 0. 0. 0. 1.]
 [1. 1. 1. 1. 1. 1. 1. 1. 1. 1.]]

Explication:

Dans le code ci-dessus : np.ones((10, 10)) crée un tableau 10×10 ‘x’ rempli de uns.

x[1:-1, 1:-1] = 0 utilise le découpage du tableau pour sélectionner la région interne du tableau “x” et mettre ses éléments à zéro. Le découpage 1:-1 signifie « du deuxième élément à l’avant-dernier élément » dans les lignes et les colonnes. En conséquence, la région intérieure du tableau sera remplie de zéros, laissant une bordure de uns.

Enfin, print(x) affiche le tableau modifié sur la console.

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

# Création d'une matrice diagonale avec les éléments diagonaux 1, 2, 3, 4, 5 en utilisant np.diag()
x = np.diag([1, 2, 3, 4, 5])

# Affichage de la matrice diagonale x
print(x)

Sortie:

[[1 0 0 0 0]
 [0 2 0 0 0]
 [0 0 3 0 0]
 [0 0 0 4 0]
 [0 0 0 0 5]]

Explication:

L’exercice ci-dessus crée une matrice carrée 5×5 avec les éléments de la diagonale principale [1, 2, 3, 4, 5] et des zéros ailleurs, et affiche la matrice résultante.

Dans le code ci-dessus, np.diag([1, 2, 3, 4, 5]) crée une matrice carrée 2D avec les éléments diagonaux spécifiés [1, 2, 3, 4, 5]. Les autres éléments de la matrice sont remplis de zéros.

Enfin, print(x) affiche la matrice générée sur la console.

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

# Création d'une matrice 4x4 remplie de zéros en utilisant np.zeros()
x = np.zeros((4, 4))

# Définition des éléments dans les lignes et les colonnes alternées à 1
# Fixe à 1 les éléments des lignes paires (indexation basée sur 0) et des colonnes impaires
x[::2, 1::2] = 1

# Fixer à 1 les éléments des lignes impaires et des colonnes paires
x[1::2, ::2] = 1

# Affichage de la matrice modifiée x
print(x)

Sortie:

[[0. 1. 0. 1.]
 [1. 0. 1. 0.]
 [0. 1. 0. 1.]
 [1. 0. 1. 0.]]

Explication:

Dans le code ci-dessus : Dans l’instruction ‘x = np.zeros((4, 4))’, la fonction np.zeros() est utilisée pour créer un tableau 4×4 ‘x’ rempli de zéros.

x[::2, 1::2] = 1 : Cette ligne utilise le découpage en tranches du tableau pour sélectionner une ligne sur deux (à partir de la première ligne) et une colonne sur deux (à partir de la deuxième colonne) dans le tableau « x » et donne à leurs éléments la valeur « 1 ». La tranche ::2 signifie « un élément sur deux » dans les lignes et les colonnes, tandis que la tranche 1::2 signifie « un élément sur deux, à partir du deuxième élément ».

x[1::2, ::2] = 1 : Cette ligne utilise le découpage de tableau pour sélectionner une ligne sur deux (à partir de la deuxième ligne) et une colonne sur deux (à partir de la première colonne) dans le tableau « x » et définit leurs éléments à des uns. Le découpage 1::2 signifie « un élément sur deux, à partir du deuxième élément », à la fois dans les lignes et dans les colonnes.

Enfin, print(x) affiche le tableau modifié sur la console.