Exercice Corrigé: NumPy – Partie 2

NumPy est une bibliothèque Python fondamentale pour le calcul scientifique, offrant un objet array multidimensionnel et diverses routines pour des opérations de tableaux rapides. Elle prend en charge les opérations mathématiques, logiques, la manipulation de formes, le tri, les entrées/sorties, les transformations de Fourier, l’algèbre linéaire, les statistiques, les simulations aléatoires, etc.

La meilleure façon d’apprendre est de pratiquer et de s’exercer. Ici, vous pouvez pratiquer les concepts de NumPy avec des exercices allant du plus simple au plus complexe, chacun accompagné d’un exemple de solution et d’une explication. Il est recommandé d’essayer ces exercices par vous-même avant de vérifier les solutions.
 
 

Exercice 1:

Ecrire un programme NumPy pour créer un vecteur avec des valeurs allant de 15 à 34 et afficher toutes les valeurs à l’exception de la première et de la dernière.

Exemple:

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]
Solution:

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]
 

Exercice 2:

Ecrire un programme NumPy pour créer un tableau 3X4 et le parcourir.

Exemple:

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 
Solution:

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 
 

Exercice 3:

Ecrivez un programme NumPy pour créer un vecteur de longueur 5 rempli d’entiers arbitraires de 0 à 10.

Exemple:

[7 9 5 1 6]
Solution:

# 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).

 

Exercice 4:

Ecrire un programme NumPy pour multiplier les valeurs de deux vecteurs donnés.

Exemple:

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

# 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

 

Exercice 5:

Ecrivez un programme NumPy pour créer une matrice 3×4 remplie avec des valeurs de 10 à 21.

Exemple:

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

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

 

Exercice 6:

Ecrire un programme NumPy pour trouver le nombre de lignes et de colonnes dans une matrice donnée.

Exemple:

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)
Solution:

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

 

Exercice 7:

Ecrivez un programme NumPy pour créer une matrice identité 3×3, c’est-à-dire que les éléments diagonaux valent 1, les autres valent 0.

Exemple:

[[1. 0. 0.]
 [0. 1. 0.]
 [0. 0. 1.]]
Solution:

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

 

Exercice 8:

Ecrivez un programme NumPy pour créer une matrice 10×10, dans laquelle les éléments sur les bords seront égaux à 1, et à l’intérieur à 0.

Exemple:

[[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.]]
Solution:

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

 

Exercice 9:

Ecrivez un programme NumPy pour créer une matrice 5×5 zéro avec des éléments sur la diagonale principale égaux à 1, 2, 3, 4, 5.

Exemple:

[[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]]
Solution:

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

 

Exercice 10:

Ecrivez un programme NumPy pour créer une matrice 4×4 dans laquelle les 0 et les 1 sont décalés, avec des zéros sur la diagonale principale.

Exemple:

[[0. 1. 0. 1.]
 [1. 0. 1. 0.]
 [0. 1. 0. 1.]
 [1. 0. 1. 0.]]
Solution:

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

 

Éditeur de code Python: Testez votre code en ligne!


 

QCM Python

Laisser un commentaire

Votre adresse e-mail ne sera pas publiée. Les champs obligatoires sont indiqués avec *