Exercice Corrigé: NumPy – Partie 3

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

# Création d'un tableau 3x3x3 rempli de nombres aléatoires entre 0 et 1 en utilisant np.random.random()
x = np.random.random((3, 3, 3))

# Affichage du tableau 3x3x3 généré aléatoirement x.
print(x)

Explication:

Le code ci-dessus crée un tableau 3D de nombres aléatoires entre 0 et 1 avec la forme (3, 3, 3) et affiche le tableau résultant.

Ici, ‘np.random.random((3, 3, 3))’ crée un tableau 3D de la forme (3, 3, 3), rempli de nombres aléatoires compris entre 0 et 1. L’entrée de np.random.random() est un tuple représentant la forme souhaitée du tableau de sortie.

Enfin, print(x) affiche le tableau 3D généré sur la console.

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

# Création d'un tableau NumPy 'x' avec une forme 2x2
x = np.array([[0, 1], [2, 3]])

print("Tableau original:")
print(x)

# Calculer et afficher la somme de tous les éléments du tableau 'x' en utilisant np.sum()
print("Somme de tous les éléments:")
print(np.sum(x))

# Calculer et afficher la somme de chaque colonne du tableau 'x' en utilisant np.sum() avec axis=0
print("Somme de chaque colonne:")
print(np.sum(x, axis=0))

# Calculer et afficher la somme de chaque ligne du tableau 'x' en utilisant np.sum() avec axis=1
print("Somme de chaque ligne:")
print(np.sum(x, axis=1)) 

Sortie:

Tableau original:
[[0 1]
 [2 3]]
Somme de tous les éléments:
6
Somme de chaque colonne:
[2 4]
Somme de chaque ligne:
[1 5]

Explication:

Dans le code ci-dessus: x = np.array([[0, 1], [2, 3]]) crée un tableau 2D ‘x’ de forme (2, 2) avec les éléments [[0, 1], [2, 3]].

Dans l’instruction print(np.sum(x)), la fonction np.sum() est utilisée pour calculer la somme de tous les éléments du tableau ‘x’ et afficher le résultat. Dans ce cas, la somme est 0+1+2+3 = 6.

Dans l’instruction print(np.sum(x, axis=0)), la fonction np.sum() est utilisée pour calculer la somme des éléments du tableau ‘x’ le long du premier axe (axe 0, correspondant aux colonnes). Le résultat est un tableau 1D avec la somme de chaque colonne : [0+2, 1+3] = [2, 4]. La sortie est ensuite affichée.

Enfin, dans l’instruction print(np.sum(x, axis=1)), la fonction np.sum() calcule la somme des éléments du tableau ‘x’ le long du deuxième axe (axe 1, correspondant aux lignes). Le résultat est un tableau 1D avec la somme de chaque ligne : [0+1, 2+3] = [1, 5]. La sortie est ensuite affichée.

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

# Création des tableaux NumPy 'x' et 'y' avec les valeurs respectives [4, 5] et [7, 10]
x = np.array([4, 5])
y = np.array([7, 10])

print("Vecteurs originaux:")
print(x)
print(y)

# Calculer et afficher le produit scalaire des vecteurs 'x' et 'y' en utilisant np.dot()
print("Produit scalaire de ces vecteurs:")
print(np.dot(x, y))

Sortie:

Vecteurs originaux:
[4 5]
[ 7 10]
Produit scalaire de ces vecteurs:
78

Explication:

Le code ci-dessus crée deux tableaux 1D ‘x’ et ‘y’ et calcule leur produit, qui est ensuite affiché en sortie.

x = np.array([4, 5]): Cette instruction crée un tableau 1D ‘x’ avec les éléments [4, 5].

y = np.array([7, 10]): Cette instruction crée un tableau 1D ‘y’ avec les éléments [7, 10].

Enfin, dans l’instruction print(np.dot(x, y)), la fonction np.dot() est utilisée pour calculer le produit des deux tableaux 1D ‘x’ et ‘y’. Le produit est calculé comme suit: (4 * 7) + (5 * 10) = 28 + 50 = 78. Le résultat, 78, est ensuite affiché sur la console.

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

# Création d'un tableau NumPy 'm' représentant une matrice de 3 lignes et 3 colonnes
m = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])

# Création d'un tableau NumPy 'v' représentant un vecteur à 3 éléments
v = np.array([1, 1, 0])

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

print("Matrice originale:")
print(m)

# Création d'une matrice vide 'result' ayant la même forme que 'm' en utilisant np.empty_like()
result = np.empty_like(m)

# Addition du vecteur v à chaque ligne de la matrice m à l'aide d'une boucle for.
for i in range(3):
    result[i, :] = m[i, :] + v

print("\nAprès addition du vecteur à chaque ligne de la matrice:")
print(result)

Sortie:

Vecteur original:
[1 1 0]
Matrice originale:
[[1 2 3]
 [4 5 6]
 [7 8 9]]

Après addition du vecteur à chaque ligne de la matrice:
[[2 3 3]
 [5 6 6]
 [8 9 9]]

Explication:

Dans le code ci-dessus : np.array([[1,2,3], [4,5,6], [7,8,9]]) crée un tableau 2D et stocke dans la variable ‘m’ la forme (3, 3) et les éléments [[1, 2, 3], [4, 5, 6], [7, 8, 9]].

np.array([1, 1, 0]) crée un tableau 1D et le stocke dans la variable ‘v’ avec les éléments [1, 1, 0].

result = np.empty_like(m) : Cette ligne crée un tableau vide « result » ayant la même forme et le même type de données que le tableau ‘m’. Le contenu de « result » n’est pas initialisé et sera remplacé à l’étape suivante.

for i in range(3): : Cette ligne démarre une boucle qui parcourt les 3 lignes du tableau 2D ‘m’.

result[i, :] = m[i, :] + v : Cette ligne ajoute le tableau 1D ‘v’ à la ligne courante ‘i’ du tableau 2D ‘m’, et affecte le résultat à la ligne correspondante ‘i’ dans le tableau ‘result’.

Enfin, print(result) affiche le tableau 2D résultant après que le tableau 1D ‘v’ a été ajouté à chaque ligne du tableau 2D ‘m’.

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

# Importer le module os pour les fonctionnalités dépendant du système d'exploitation
import os

# Création d'un tableau NumPy 'x' avec des entiers de 0 à 11 et transformation en une matrice 4x3 à l'aide de np.arange() et .reshape()
x = np.arange(12).reshape(4, 3)

print("Tableau original:")
print(x)

# Création d'une chaîne 'header' contenant les noms de colonnes 'col1 col2 col3'.
header = 'col1 col2 col3'

# Enregistrer le tableau 'x' dans un fichier texte nommé 'temp.txt' en utilisant np.savetxt()
# Spécifier le format '%d' (entier) et inclure un en-tête avec les noms des colonnes
np.savetxt('temp.txt', x, fmt="%d", header=header)

# Affichage d'un message indiquant le contenu du fichier texte après son chargement
print("Après le chargement, le contenu du fichier texte:")

# Chargement des données de 'temp.txt' dans la variable 'result' en utilisant np.loadtxt()
result = np.loadtxt('temp.txt')

# Affichage des données chargées à partir du fichier texte
print(result)

Sortie:

Tableau original:
[[ 0  1  2]
 [ 3  4  5]
 [ 6  7  8]
 [ 9 10 11]]
 
Après le chargement, le contenu du fichier texte:
[[ 0.  1.  2.]
 [ 3.  4.  5.]
 [ 6.  7.  8.]
 [ 9. 10. 11.]]

Explication:

Dans le code ci-dessus : L’instruction x = np.arange(12).reshape(4, 3) crée un tableau 1D dont les éléments sont compris entre 0 et 11, puis le remodèle en un tableau 2D ‘x’ de forme (4, 3).

L’instruction header = 'col1 col2 col3' crée une chaîne ‘header’ qui sera utilisée comme en-tête du fichier texte.

L’instruction np.savetxt('temp.txt', x, fmt='%d', header=header) enregistre le tableau NumPy 2D ‘x’ dans un fichier texte nommé ‘temp.txt’ en utilisant le format entier (‘%d’) pour les éléments, et ajoute l’en-tête spécifié au fichier.

L’instruction result = np.loadtxt('temp.txt') charge le contenu du fichier ‘temp.txt’ dans un tableau NumPy nommé ‘result’.

Enfin, print(result) affiche le tableau ‘result’ chargé.

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

# Création de deux tableaux NumPy 'tab1' et 'tab2' contenant des matrices 2x3
tab1 = np.array([[2, 5, 2],
              [1, 5, 5]])

tab2 = np.array([[5, 3, 4],
              [3, 2, 5]])

print("Tableau 1:") 
print(tab1)

print("Tableau 2:") 
print(tab2)

# Multiplication par élément des tableaux 'tab1' et 'tab2' à l'aide de np.multiply()
# Cette opération multiplie les éléments correspondants des deux tableaux
print("\nMultiplier ces tableaux de même taille élément par élément:")
print(np.multiply(tab1, tab2)) 

Sortie:

Tableau 1:
[[2 5 2]
 [1 5 5]]
Tableau 2:
[[5 3 4]
 [3 2 5]]

Multiplier ces tableaux de même taille élément par élément:
[[10 15  8]
 [ 3 10 25]]

Explication:

Dans le code ci-dessus: tab1 = np.array([[2, 5, 2], [1, 5, 5]]) : Crée un tableau NumPy 2D de forme (2, 3) avec les valeurs spécifiées et le stocke dans une variable « tab1 ».

tab2 = np.array([[5, 3, 4], [3, 2, 5]]): Crée un autre tableau NumPy 2D de forme (2, 3) avec les valeurs spécifiées et le stocke dans une variable « tab2 ».

print(np.multiply(tab1, tab2)): Utilise la fonction np.multiply() pour effectuer une multiplication par éléments des deux tableaux tab1 et tab2. Le tableau résultant a la même forme que les tableaux d’entrée (2, 3).

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

# Création d'un tableau NumPy 'tab' contenant un tableau 2D unique de quatre lignes et quatre colonnes
tab = np.array([[[1, 2, 3, 4],
               [0, 0, 5, 5],
               [8, 8, 9, 9],
               [4, 4, 3, 3]]])

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

# Échange des lignes et des colonnes du tableau 'tab' dans l'ordre inverse en utilisant le découpage en tranches
# Inverser les lignes et les colonnes en utilisant [::-1, ::-1]
new_tab = tab[::-1, ::-1]

print("\nÉchanger les lignes et les colonnes dans l'ordre inverse:")
print(new_tab)

Sortie:

Tableau original:
[[[1 2 3 4]
  [0 0 5 5]
  [8 8 9 9]
  [4 4 3 3]]]

Échanger les lignes et les colonnes dans l'ordre inverse:
[[[4 4 3 3]
  [8 8 9 9]
  [0 0 5 5]
  [1 2 3 4]]]

Explication:

Dans le code ci-dessus : np.array([[1, 2, 3, 4], [0, 0, 5, 5], [8, 8, 9, 9], [4, 4, 3, 3]]) crée un tableau NumPy 2D de forme (1, 4, 4) avec les valeurs spécifiées.

tab[::-1, ::-1] : L’opération de découpage [::-1] est appliquée au premier et au deuxième axe (lignes et colonnes), ce qui a pour effet d’inverser leur ordre.

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

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

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

# Création d'un nouveau tableau 'new_tab' en échangeant la première et la dernière colonne du tableau 'tab'.
# Ceci est fait en utilisant le découpage avec un pas de -1 pour inverser l'ordre des colonnes
new_tab = tab[:, ::-1]

print("\nAprès avoir échangé la première et la dernière colonne:")
print(new_tab) 

Sortie:

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

Après avoir échangé la première et la dernière colonne:
[[ 3  2  1  0]
 [ 7  6  5  4]
 [11 10  9  8]
 [15 14 13 12]]

Explication:

Dans le code ci-dessus: np.arange(16, dtype='int').reshape(-1, 4) crée un tableau NumPy 2D de forme (4, 4) avec des valeurs entières de 0 à 15 inclus. Le -1 de la fonction reshape() est utilisé pour calculer automatiquement le nombre approprié de lignes en fonction du nombre de colonnes spécifié (4).

tab[:, ::-1]: L’opération de découpage [::-1] est appliquée aux colonnes, inversant ainsi leur ordre.

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

# Création d'un tableau NumPy 'tab' contenant un tableau multidimensionnel 3x5x4
tab = np.array([[[1, 4, 3, 0],
               [6, 4, 5, 6],
               [6, 4, 0, 6],
               [7, 4, 9, 0],
               [8, 4, 3, 2]],
              
              [[1, 2, 3, 2],
               [4, 0, 0, 5],
               [8, 3, 2, 2],
               [5, 1, 0, 0],               
               [9, 3, 9, 2]],
              
              [[3, 1, 5, 2],
               [7, 1, 6, 1],
               [1, 6, 0, 7],
               [0, 3, 4, 0],               
               [2, 8, 2, 8]]]) 

print("Tableau multidimensionnel 3x5x4:")
print(tab) 

Sortie:

Tableau multidimensionnel 3x5x4:
[[[1 4 3 0]
  [6 4 5 6]
  [6 4 0 6]
  [7 4 9 0]
  [8 4 3 2]]

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

 [[3 1 5 2]
  [7 1 6 1]
  [1 6 0 7]
  [0 3 4 0]
  [2 8 2 8]]]

Explication:

Le code ci-dessus montre la création d’un tableau NumPy tridimensionnel avec des valeurs données et il affiche ce tableau.

tab = np.array([...]) L’instruction crée un tableau NumPy tridimensionnel de forme (3, 5, 4) et le stocke dans une variable « tab ». La dimension extérieure comporte 3 éléments (matrices), chacun ayant 5 lignes et 4 colonnes.

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

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

tab = np.array([[2.55, 5.39, 6.89],
              [4.83, 6.13, 7.88],
              [2.32, 3.78, 9.14]])
print("Tableau original:")
print(tab)
print("\nNouveau tableau de même forme/type, rempli par 0:")
print(np.zeros_like(tab))

Sortie:

Tableau original:
[[2.55 5.39 6.89]
 [4.83 6.13 7.88]
 [2.32 3.78 9.14]]

Nouveau tableau de même forme/type, rempli par 0:
[[0. 0. 0.]
 [0. 0. 0.]
 [0. 0. 0.]]

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

print(np.zeros_like(tab)): La fonction np.zeros_like() prend le tableau tab en entrée et crée un nouveau tableau NumPy avec la même forme (3×3) et le même type de données (float) que tab. Le nouveau tableau est rempli de zéros et les résultats sont affichés.