Attributs de tableaux NumPy

Si tu prends une personne et que tu listes ses attributs, cela ressemblerait à ceci👇,

• Taille : 1m75
• Poids : 68 kg
• Âge : 24 ans
• etc…

De même, les attributs d’un tableau NumPy sont les suivants,

• dtype – Type de données
• ndim – Nombre de dimensions
• shape – Forme du tableau (qui est simplement le nombre de lignes et de colonnes en fonction des dimensions)
• size – Nombre d’éléments présents dans le tableau
• itemsize – Consommation de mémoire d’un seul élément du tableau
• nbytes – Consommation totale de mémoire d’un tableau entier

Codons-les :

dtype

Nous l’avons déjà vu, ne nous attardons pas sur ce point.

arr1 = np.array([1, 2, 3, 4])
arr2 = np.array(['a', 'b', 'c', 'd'])
arr3 = np.array([1.1, 2.2, 3.3, 4.4])
arr4 = np.array([True, False, True, False])
arr1.dtype, arr2.dtype, arr3.dtype, arr4.dtype

# (dtype('int64'), dtype('<U1'), dtype('float64'), dtype('bool'))

Exercice : Créer différents ensembles de tableaux et trouver leur type de données à l’aide de l’attribut dtype.

ndim

Nous l’avons déjà vu, mais passons rapidement en revue ces éléments.

arr4 = np.array([1, 2, 3, 4])
arr5 = np.array([[1, 2, 3], [4, 5, 6]])
arr6 = np.array([[[1, 2, 3], [4, 5, 6]], [[7, 8, 9], [10, 11, 12]]])
arr4.ndim, arr5.ndim, arr6.ndim

# (1, 2, 3)

Dans le code ci-dessus, j’ai créé 3 tableaux, à savoir arr4, arr5 et arr6. Ces trois tableaux ont des dimensions, des formes et des tailles différentes.

En utilisant l’attribut ndim, nous avons trouvé les dimensions de ces tableaux.

Découvrons la forme et la taille de ces tableaux à l’aide des attributs shape et size.

shape

arr4.shape, arr5.shape, arr6.shape

# ((4,), (2, 3), (2, 2, 3))

La sortie indique la forme de,

• arr4 – (4, )
• arr5 – (2, 3)
• arr6 – (2, 2, 3)

Décomposons cela.

Si on regarde arr4, il n’y a qu’un seul jeu de crochets ([]). Et dans cet ensemble de crochets, nous avons 4 éléments, à savoir 1, 2, 3, 4.

La forme est donc de 4.

Voyons maintenant arr5, il y a deux séries de crochets ([]). Dans la première série de crochets, nous avons 2 éléments, à savoir [1, 2, 3], [4, 5, 6], et dans la deuxième série de crochets, nous avons 3 éléments chacun, à savoir 1, 2, 3 et 4, 5, 6.

La forme est donc (2, 3).

Pour faciliter la compréhension, imagine le tableau comme une matrice :

[1, 2, 3]
[4, 5, 6]

La matrice ci-dessus a 2 lignes et 3 colonnes, sa forme est donc (2, 3).

Dans arr6,

Le premier ensemble de crochets a 2 éléments → [[1, 2, 3], [4, 5, 6]], [[7, 8, 9], [10, 11, 12]]

Le deuxième ensemble de crochets a 2 éléments chacun → [1, 2, 3], [4, 5, 6] et [7, 8, 9], [10, 11, 12]

Le troisième ensemble de crochets a 3 éléments chacun → 1, 2, 3 | 4, 5, 6 et 7, 8, 9 | 10, 11, 12

La forme est donc (2, 2, 3).

J’espère que tu as bien compris le concept d’attribut de forme/shape.

size

arr4.size, arr5.size, arr6.size

# (4, 6, 12)

L’attribut size est un concept très simple à comprendre.

Il donne la valeur du nombre d’éléments présents dans le tableau.

Dans arr4, nous n’avons que 4 éléments → 1, 2, 3, 4

Dans arr5, nous avons 6 éléments → 1, 2, 3, 4, 5, 6

Dans arr6, nous avons 12 éléments → 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12

Il suffit de compter le nombre de nombres présents dans un tableau qui correspond à la taille de ce tableau. C’est aussi simple que cela.

Les deux attributs suivants itemsize et nbytes sont liés à la consommation de mémoire. Voyons comment ils fonctionnent.

itemsize

arr4.itemsize, arr5.itemsize, arr6.itemsize

# (8, 8, 8)

Si tu te souviens de l’une de nos leçons précédentes sur les types de données, tu sais que lorsque nous créons un tableau d’entiers, il aura par défaut le type 'int64', ce qui signifie que chaque élément du tableau occupera 8 octets de mémoire.

C’est ce qui s’est passé dans le code ci-dessus.

L’attribut itemsize nous donne la consommation de mémoire d’un seul élément du tableau.

Essayons de changer le dtype de 'int64' à 'int32'.

arr4 = np.array([1, 2, 3, 4], dtype='int32')

arr4.itemsize, arr5.itemsize, arr6.itemsize

# (4, 8, 8)

Nous venons de modifier le dtype de arr4 de 'int64' à 'int32', ce qui permet de réduire la consommation de mémoire de ses éléments individuels de 8 octets à 4 octets.

Exercice : Essaye de changer le dtype de arr5 et arr6 en 'int16' et vois ce qu’il se passe.

nbytes

L’attribut nbytes indique la consommation totale de mémoire du tableau.

arr4.nbytes, arr5.nbytes, arr6.nbytes

# (16, 48, 96)

Dans la section itemsize, nous avons dit qu’un élément unique dans arr4 occupe 4 octets de mémoire et que dans arr4 nous avons un total de 4 éléments (1, 2, 3, 4), donc 4 x 4 = 16 octets.

La consommation totale de mémoire est de 16.

Pour arr5, un seul élément occupe 8 octets d’espace mémoire. Nous avons un total de 6 éléments.

Ainsi, 8 x 6 = 48 octets.

Exercice : Essaye de décomposer la consommation totale de mémoire de arr6.

C’est très bien ! Nous en avons terminé avec les attributs NumPy.

Il est temps d’apprendre 👉 Création de tableaux avec les fonctions NumPy.