Exercice Corrigé: NumPy – Partie 7

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

# Créer un tableau NumPy 'tab'
tab = np.array([[5, 6], [3, 1]])

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

print("Trier selon le premier axe: ")
x = np.sort(tab, axis=0)
print(x)

print("Trier selon le dernier axe: ")
y = np.sort(x, axis=1)
print(y) 

Sortie:

Tableau original:
[[5 6]
 [3 1]]
Trier selon le premier axe: 
[[3 1]
 [5 6]]
Trier selon le dernier axe: 
[[1 3]
 [5 6]]

Explication:

Dans le code ci-dessus : tab = np.array([[5, 6],[3, 1]]) : Un tableau NumPy 2D est créé avec la forme (2, 2) et les éléments sont [[5, 6], [3, 1]].

x = np.sort(tab, axis=0) : La fonction np.sort trie le tableau d’entrée selon l’axe spécifié, qui est 0 (colonnes) dans ce cas. Le résultat est stocké dans la variable ‘x’, qui est un tableau de la même forme que tab, mais dont les éléments sont triés sur chaque colonne. Le tableau ‘x’ résultant est [[3, 1], [5, 6]].

y = np.sort(x, axis=1) : La fonction np.sort est appelée à nouveau, cette fois avec le tableau d’entrée « x » et l’axe spécifié fixé à 1 (lignes). La fonction trie les éléments sur chaque ligne et le résultat est stocké dans la variable « y ». Le tableau y résultant est [[1, 3], [5, 6]].

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

# Création d'un tableau 4x4 rempli de zéros
n = np.zeros((4,4))

# Calculer la mémoire totale occupée par le tableau et l'afficher en octets
print("%d octets" % (n.size * n.itemsize))

Sortie:

128 octets

Explication:

Le code ci-dessus crée un tableau NumPy rempli de zéros et calcule sa taille mémoire en octets.

n = np.zeros((4,4)) : Cette instruction crée un tableau NumPy n de forme (4, 4) rempli de zéros. Par défaut, le dtype est ‘float64’, ce qui signifie que chaque élément occupe 8 octets de mémoire.

print("%d octets" % (n.size * n.itemsize)) : Cette instruction calcule la taille totale de la mémoire du tableau en octets et affiche cette valeur. L’attribut .size renvoie le nombre d’éléments du tableau (4 * 4 = 16) et l’attribut .itemsize renvoie la taille mémoire d’un élément en octets (8 octets pour un float64). Le produit de ces deux valeurs (16 * 8 = 128) donne la taille mémoire totale du tableau en octets.

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

print("Créer un tableau de zéros")
x = np.zeros((1,2))
print("Le type par défaut est float")
print(x)

print("Changement de type en int")
x = np.zeros((1,2), dtype=np.int)
print(x)

print("Créer un tableau de uns")
y = np.ones((1,2))
print("Le type par défaut est float")
print(y)

print("Changement de type en int")
y = np.ones((1,2), dtype=np.int)
print(y)

Sortie:

Créer un tableau de zéros
Le type par défaut est float
[[0. 0.]]
Changement de type en int
[[0 0]]
Créer un tableau de uns
Le type par défaut est float
[[1. 1.]]
Changement de type en int
[[1 1]]

Explication:

Dans le code ci-dessus : x = np.zeros((1,2)) : Cette ligne crée un tableau NumPy ‘x’ de forme (1, 2) rempli de zéros. Par défaut, le dtype est ‘float64’.

x = np.zeros((1,2), dtype = np.int) : Cette ligne réaffecte ‘x’ à un nouveau tableau de même forme (1, 2) rempli de zéros, mais dont le dtype est ‘int’ (entier).

print(x) : Cette ligne affiche le tableau d’entiers x rempli de zéros.

y = np.ones((1,2)) : Cette ligne crée un tableau NumPy ‘y’ de forme (1, 2) rempli de uns. Par défaut, le dtype est ‘float64’.

y = np.ones((1,2), dtype = np.int) : Cette ligne réaffecte ‘y’ à un nouveau tableau de même forme (1, 2) rempli de uns, mais dont le dtype est ‘int’ (entier).

print(y) : Cette ligne affiche le tableau d’entiers ‘y’ rempli de uns.

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

x = np.array([[1, 2, 3], [2, 4, 5]])
print("Tableau original:")
print(x)

# Transformer le tableau 'x' en un tableau 1D à l'aide de np.ravel
y = np.ravel(x)
# Afficher le tableau aplati 'y'
print("Nouveau tableau aplati:")
print(y)

Sortie:

Tableau original:
[[1 2 3]
 [2 4 5]]
Nouveau tableau aplati:
[1 2 3 2 4 5]

Explication:

y = np.ravel(x): Cette ligne aplatit le tableau bidimensionnel « x » en un tableau unidimensionnel « y » à l’aide de la fonction np.ravel().

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

x = np.array([[1, 2, 3], [2, 4, 5]], np.int32)
print(type(x))
print(x.shape)
print(x.dtype) 

Sortie:

<class 'numpy.ndarray'>
(2, 3)
int32

Explication:

print(type(x)) : Cette ligne affiche le type du tableau ‘x’, qui est <classe ‘numpy.ndarray’>.

print(x.shape) : Cette ligne affiche la forme du tableau ‘x’, qui est (2, 3) – deux lignes et trois colonnes.

print(x.dtype) : Cette ligne affiche le type de données des éléments du tableau ‘x’, qui est int32, comme spécifié lors de la création du tableau.

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

x = np.array([1, 2, 3, 4, 5, 6])

# Transformer le tableau 'x' en une matrice 3x2 et l'affecter à la variable 'y'.
y = np.reshape(x, (3, 2))
print("Reshape 3x2:")
print(y) 

# Transformer le tableau 'x' en une matrice 2x3 et l'affecter à la variable 'z'.
z = np.reshape(x, (2, 3))
print("Reshape 2x3:")
print(z)

Sortie:

Reshape 3x2:
[[1 2]
 [3 4]
 [5 6]]
Reshape 2x3:
[[1 2 3]
 [4 5 6]]

Explication:

y = np.reshape(x,(3,2)) : Cette ligne transforme le tableau « x » en un nouveau tableau bidimensionnel « y » avec 3 lignes et 2 colonnes. Les éléments de ‘x’ sont placés dans le sens des lignes dans la nouvelle forme.

z = np.reshape(x,(2,3)) : Cette ligne transforme le tableau « x » en un autre tableau bidimensionnel « z » avec 2 lignes et 3 colonnes. Une fois encore, les éléments de ‘x’ sont placés dans le sens des lignes dans la nouvelle forme.

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

# Création d'un tableau à deux dimensions avec les éléments diagonaux
matrix = np.diagflat([3, 4, 5, 6])

print(matrix)

Sortie:

[[3 0 0 0]
 [0 4 0 0]
 [0 0 5 0]
 [0 0 0 6]]

Explication:

matrix = np.diagflat([3, 4, 5, 6]): Cette ligne crée une matrice diagonale « x » à l’aide de la fonction np.diagflat(). La fonction prend un argument, qui est une liste ou un objet de type tableau contenant les valeurs à placer sur la diagonale de la matrice résultante.

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

# Générer une matrice triangulaire inférieure de taille 4x3 avec les uns décalés de -1
matrix = np.tri(4, 3, -1)

print(matrix) 

Sortie:

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

Explication:

Le code ci-dessus montre comment créer un tableau NumPy à l’aide de la fonction np.tri().

matrix = np.tri(4, 3, -1) : Cette ligne crée un tableau NumPy matrix à l’aide de la fonction np.tri(). La fonction prend trois arguments : le nombre de lignes (4), le nombre de colonnes (3) et la diagonale en dessous de laquelle les éléments doivent être mis à 1 (-1). Le tableau est créé avec des uns au niveau et en dessous de la diagonale spécifiée et des zéros ailleurs.

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

# Création d'un tableau 4x3 avec des valeurs de 3 à 14
matrix = np.triu(np.arange(3, 15).reshape(4, 3), -1)

print(matrix)

Sortie:

[[ 3  4  5]
 [ 6  7  8]
 [ 0 10 11]
 [ 0  0 14]]

# 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
matrix = np.eye(3)

print("Tableau 3D:")
print(matrix)

# Transformer la matrice 3x3 en ordre Fortran (colonne-major) pour créer un tableau unidimensionnel
tab = np.ravel(matrix, order='F')

print("Tableau à une dimension:")
print(tab)

Sortie:

Tableau 3D:
[[1. 0. 0.]
 [0. 1. 0.]
 [0. 0. 1.]]
Tableau à une dimension:
[1. 0. 0. 0. 1. 0. 0. 0. 1.]

Explication:

tab = np.ravel(matrix, order='F'): La fonction np.ravel() est utilisée pour aplatir la matrice d’entrée matrix en un tableau unidimensionnel. Le paramètre order est fixé à ‘F’ (Fortran order), ce qui spécifie que les éléments doivent être aplatis dans l’ordre des colonnes (c’est-à-dire en descendant d’abord les colonnes, puis en passant à la colonne suivante).