Exercice Corrigé: NumPy – Partie 5

septembre 8, 2024septembre 16, 2024 Thomas Aucun commentaire

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:

Écrire un programme NumPy pour convertir les dtypes numpy en types Python natifs.

Exemple:

<class 'numpy.float32'>
<class 'float'>

Solution:

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

# Création d'une valeur numpy.float32 'x' initialisée à 0
x = np.float32(0)

# Affichage du type de 'x'
print(type(x))

# Extraction de la valeur float Python de numpy.float32 'x' à l'aide de la méthode item()
py = x.item()

# Affichage du type de la valeur flottante Python extraite.
print(type(py))

Sortie:

<class 'numpy.float32'>
<class 'float'>

Explication:

Dans le code ci-dessus: np.float32(0) crée un scalaire NumPy de type float32 dans la variable ‘x’ et l’initialise avec la valeur 0.

print(type(x)) affiche le type de ‘x’, qui est un scalaire NumPy.

L’instruction x.item() convertit le scalaire NumPy « x » en un type natif Python à l’aide de la méthode « item() ». Dans ce cas, le type natif Python est « float ». Le résultat est stocké dans la variable « py ».

L’instruction print(type(py)) affiche le type de « py », qui est un type natif Python.

Exercice 2:

Ecrire un programme NumPy pour convertir une liste donnée en un tableau, puis la convertir à nouveau en une liste. Vérifier que la liste initiale et la liste finale sont égales ou non.

Solution:

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

# Création d'une liste imbriquée contenant des listes comme éléments
liste = [[1, 2], [3, 4]]

# Conversion de la liste imbriquée 'liste' en un tableau NumPy 'tab' en utilisant np.array()
tab = np.array(liste)

# Conversion du tableau NumPy 'tab' en liste imbriquée Python 'liste2' à l'aide de la méthode tolist()
liste2 = tab.tolist()

# Vérifier si la liste originale 'liste' et la liste convertie 'liste2' sont égales
# Cette comparaison vérifie si leurs éléments et leur structure sont identiques.
print(liste == liste2)

Sortie:

True

Explication:

Dans le code ci-dessus: liste = [[1, 2], [3, 4]] crée une liste imbriquée ‘liste’ avec deux sous-listes contenant des entiers.

L’instruction np.array(liste) convertit la liste imbriquée « liste » en un tableau NumPy 2D et la stocke dans la variable « tab ».

L’instruction liste2 = tab.tolist() reconvertit le tableau NumPy ‘tab’ en une liste imbriquée nommée ‘liste2’ en utilisant la méthode ‘tolist()’.

Enfin, print(liste == liste2) vérifie si la liste imbriquée originale « liste » et la liste imbriquée reconstruite « liste2 » sont égales. Si c’est le cas, la commande affiche « True » (vrai); sinon, elle affiche « False » (faux).

Exercice 3:

Ecrivez un programme NumPy pour créer un vecteur nul de taille 10 et mettre à jour la sixième valeur à 5.

Exemple:

[ 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]
Mise à jour de la sixième valeur à 5
[ 0. 0. 0. 0. 0. 0. 5. 0. 0. 0.]

Solution:

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

# Création d'un tableau NumPy 'tab' rempli de zéros de longueur 10
tab = np.zeros(10)

# Affichage du tableau initial 'tab' rempli de zéros
print(tab)

# Modifier la sixième valeur (index 6) du tableau en 5
print("Mise à jour de la sixième valeur à 5")
tab[6] = 5

# Affichage du tableau 'tab' mis à jour après modification de la sixième valeur
print(tab)

Sortie:

[ 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]
Mise à jour de la sixième valeur à 5
[ 0. 0. 0. 0. 0. 0. 5. 0. 0. 0.]

Explication:

Dans le code ci-dessus : np.zeros(10) : Crée un tableau NumPy unidimensionnel de longueur 10, dont tous les éléments sont initialisés à 0.

x[6] = 5 : Définit le 7ème élément du tableau NumPy (à l’index 6, puisque Python utilise l’indexation basée sur zéro) à la valeur 5.

print(x) : Affiche le tableau NumPy modifié.

Exercice 4:

Ecrivez un programme NumPy pour créer un tableau avec des valeurs allant de 10 à 20.

Exemple:

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

Solution:

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

# Création d'un tableau à l'aide de la fonction arange() avec des valeurs comprises entre 10 et 20 (inclus)
tab = np.arange(10, 21)

# Affichage du tableau contenant des valeurs comprises entre 10 et 20
print(tab)

Sortie:

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

Explication:

Dans le code ci-dessus : np.arange(10, 21) : crée un tableau NumPy unidimensionnel contenant une plage d’entiers allant de 10 (inclus) à 21 (non inclus). Le résultat sera un tableau de longueur 11 contenant des entiers de 10 à 20.

print(tab) : Affiche le tableau NumPy créé.

Exercice 5:

Ecrire un programme NumPy pour inverser un tableau (le premier élément devient le dernier).

Exemple:

Tableau original:
[10 11 12 13 14 15 16 17 18 19 20]
Tableau inversé:
[20 19 18 17 16 15 14 13 12 11 10]

Solution:

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

tab = np.arange(10, 21)

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

print("Tableau inversé:")
tab = tab[::-1]
print(tab)

Sortie:

Tableau original:
[10 11 12 13 14 15 16 17 18 19 20]
Tableau inversé:
[20 19 18 17 16 15 14 13 12 11 10]

Explication:

Dans le code ci-dessus: np.arange(10, 21) : crée un tableau NumPy unidimensionnel contenant une plage d’entiers allant de 10 (inclus) à 21 (non inclus). Le résultat sera un tableau de longueur 11 contenant des entiers de 10 à 20.

tab = tab[::-1]: Inverse l’ordre des éléments du tableau NumPy ‘tab’ en utilisant le principe des tranches avec un pas de -1. Le résultat sera un nouveau tableau NumPy avec les éléments dans l’ordre inverse.

Exercice 6:

Écrire un programme NumPy pour convertir un tableau en un type flottant.

Exemple:

Tableau original
[1, 2, 3, 4]
Tableau converti en type flottant:
[ 1. 2. 3. 4.]

Solution:

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

# Définir une liste Python contenant des entiers
liste = [1, 2, 3, 4]

print("Tableau original")
print(liste)

# Convertir le tableau en un tableau NumPy de type float en utilisant asfarray()
tab = np.asfarray(liste)

# Affichage du tableau 'tab' après conversion en un tableau de type flottant
print("Tableau converti en un type flottant:")
print(tab)

Sortie:

Tableau original
[1, 2, 3, 4]
Tableau converti en type flottant:
[ 1. 2. 3. 4.]

Explication:

Dans le code ci-dessus, liste = [1, 2, 3, 4] : Définit une liste contenant les entiers 1, 2, 3 et 4.

tab = np.asfarray(liste) : La fonction np.asfarray() convertit la liste donnée en un tableau NumPy unidimensionnel avec un type de données à virgule flottante (par défaut, elle utilise float64). Dans ce cas, la liste contient des entiers, ils seront donc convertis en nombres à virgule flottante dans le tableau NumPy résultant ‘tab’.

Exercice 7:

Ecrivez un programme NumPy pour créer un tableau 2D avec 1 sur le bord et 0 à l’intérieur.

Exemple:

Tableau original:
[[1. 1. 1. 1. 1.]
 [1. 1. 1. 1. 1.]
 [1. 1. 1. 1. 1.]
 [1. 1. 1. 1. 1.]
 [1. 1. 1. 1. 1.]]

Tableau modifié:
[[1. 1. 1. 1. 1.]
 [1. 0. 0. 0. 1.]
 [1. 0. 0. 0. 1.]
 [1. 0. 0. 0. 1.]
 [1. 1. 1. 1. 1.]]

Solution:

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

# Création d'un tableau NumPy de 5x5 rempli de uns
tab = np.ones((5, 5))

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

# Modifier le tableau 'tab' pour mettre les éléments de la bordure à 1 et les éléments intérieurs à 0
tab[1:-1, 1:-1] = 0

# Affichage du tableau 'tab' modifié
print("\nTableau modifié:")
print(tab)

Sortie:

Tableau original:
[[1. 1. 1. 1. 1.]
 [1. 1. 1. 1. 1.]
 [1. 1. 1. 1. 1.]
 [1. 1. 1. 1. 1.]
 [1. 1. 1. 1. 1.]]

Tableau modifié:
[[1. 1. 1. 1. 1.]
 [1. 0. 0. 0. 1.]
 [1. 0. 0. 0. 1.]
 [1. 0. 0. 0. 1.]
 [1. 1. 1. 1. 1.]]

Explication:

Dans le code ci-dessus, tab = np.ones((5,5)) : Crée un tableau NumPy de 5×5 rempli de uns.

tab[1:-1,1:-1] = 0 : Cette opération d’indexation fixe la valeur des éléments internes du tableau à zéro en découpant les lignes et les colonnes de l’indice 1 à l’avant-dernier indice (c’est-à-dire en excluant les premières et dernières lignes et colonnes). L’opération d’affectation (= 0) met les éléments sélectionnés à zéro.

Exercice 8:

Ecrire un programme NumPy pour ajouter une bordure (remplie de 0) autour d’un tableau existant.

Exemple:

Tableau original:
[[1. 1. 1.]
 [1. 1. 1.]
 [1. 1. 1.]]

0 sur le bord et 1 à l'intérieur du tableau
[[0. 0. 0. 0. 0.]
 [0. 1. 1. 1. 0.]
 [0. 1. 1. 1. 0.]
 [0. 1. 1. 1. 0.]
 [0. 0. 0. 0. 0.]]

Solution:

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

# Création d'un tableau NumPy 3x3 rempli de 1
tab = np.ones((3, 3))

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

# Modifier le tableau 'tab' pour mettre des 0 sur le bord et des 1 à l'intérieur du tableau en utilisant la fonction np.pad
print("\n0 sur le bord et 1 à l'intérieur du tableau")
tab = np.pad(tab, pad_width=1, mode='constant', constant_values=0)
print(tab)

Sortie:

Tableau original:
[[1. 1. 1.]
 [1. 1. 1.]
 [1. 1. 1.]]

0 sur le bord et 1 à l'intérieur du tableau
[[0. 0. 0. 0. 0.]
 [0. 1. 1. 1. 0.]
 [0. 1. 1. 1. 0.]
 [0. 1. 1. 1. 0.]
 [0. 0. 0. 0. 0.]]

Explication:

Dans le code ci-dessus : tab = np.ones((3,3)) : Crée un tableau NumPy 3×3 rempli de uns.

tab = np.pad(tab, pad_width=1, mode='constant', constant_values=0) : La fonction np.pad est utilisée pour remplir le tableau d’entrée tab avec une bordure de largeur et de valeurs spécifiées. Dans ce cas, pad_width=1 ajoute une bordure de largeur 1 autour du tableau. Le mode=’constant’ spécifie que le remplissage doit être effectué avec des valeurs constantes, et constant_values=0 indique que la valeur constante pour le remplissage doit être 0.

Exercice 9:

Ecrivez un programme NumPy pour créer une matrice 8×8 et la remplir avec un schéma en damier.

Exemple:

Schéma en damier:
[[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

print("Schéma en damier:")

# Création d'un tableau NumPy 4x4 rempli de zéros et mise à 1 des éléments alternatifs pour créer un damier.
tab = np.zeros((4, 4), dtype=int)
tab[1::2, ::2] = 1  # Mise à 1 des lignes alternées à partir de la 2éme ligne et des colonnes alternées
tab[::2, 1::2] = 1  # Mise à 1 des lignes alternées à partir de la 1er ligne et des colonnes alternées

print(tab)

Sortie:

Schéma en damier:
[[0 1 0 1]
 [1 0 1 0]
 [0 1 0 1]
 [1 0 1 0]]

Explication:

Dans le code ci-dessus : tab = np.zeros((4,4),dtype=int) : Crée un tableau NumPy 4×4 rempli de zéros, avec un type de données entier.

tab[1::2,::2] = 1 : Attribue la valeur 1 à tous les éléments de toutes les lignes, à partir de la deuxième ligne (index 1).

tab[::2,1::2] = 1 : Attribue la valeur 1 à tous les autres éléments de toutes les autres colonnes, à partir de la deuxième colonne (indice 1).

print(tab) : Affiche le tableau NumPy 4×4.

Exercice 10:

Écrire un programme NumPy pour convertir une liste et un tuple en tableaux.

Exemple:

[1, 2, 3, 4] -> [1 2 3 4]
(1, 2, 3, 4)-> [1 2 3 4]

Solution:

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

# Conversion de la liste Python en tableau NumPy
my_list = [1, 2, 3, 4]
print("Liste en tableau: ")
print(np.asarray(my_list))

# Conversion du tuple Python en tableau NumPy
my_tuple = (1, 2, 3, 4)
print("Tuple en tableau: ")
print(np.asarray(my_tuple))

Sortie:

Liste en tableau: 
[1 2 3 4]
Tuple en tableau: 
[1 2 3 4]

Explication:

print(np.asarray(my_tuple)) : Convertit le tuple ‘my_tuple’ en un tableau NumPy à l’aide de la fonction np.asarray() et affiche le tableau résultant.

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

Exercice Corrigé: NumPy – Partie 1
Exercice Corrigé: NumPy – Partie 2
Exercice Corrigé: NumPy – Partie 3
Exercice Corrigé: NumPy – Partie 4
Exercice Corrigé: NumPy – Partie 5
Exercice Corrigé: NumPy – Partie 6
Exercice Corrigé: NumPy – Partie 7
Exercice Corrigé: NumPy – Partie 8

Exercice 1:

Exercice 2:

Exercice 3:

Exercice 4:

Exercice 5:

Exercice 6:

Exercice 7:

Exercice 8:

Exercice 9:

Exercice 10:

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

Vous pourrez aussi aimer

Exercice Corrigé: Les fichiers en Python – Partie 2

Exercice Corrigé: NumPy – Partie 7

Exercice Corrigé: Boucle While en Python

Laisser un commentaire Annuler la réponse