Attributs des tableaux NumPy
Dans ce chapitre, nous allons découvrir quelques attributs de base des tableaux NumPy.
Le nombre de dimensions d'un tableau NumPy est appelé son rang. Le rang est le nombre d'axes, c'est-à-dire le nombre de dimensions du tableau.
Un tableau unidimensionnel a un rang de 1, un tableau bidimensionnel a un rang de 2, et ainsi de suite.
Dans NumPy, chaque dimension d'un tableau est appelée un axe, qui est également une dimension.
Par exemple, un tableau bidimensionnel peut être considéré comme un « tableau unidimensionnel composé de tableaux unidimensionnels » : chaque élément du tableau externe est lui-même un tableau unidimensionnel.
Ici, l'axe 0 correspond à la direction du tableau le plus externe, l'axe 1 correspond à la direction du tableau interne, et ainsi de suite.
Le nombre d'axes — le rang — est le nombre de dimensions du tableau.
De nombreuses fonctions NumPy prennent en charge le paramètre axis.
Pour un tableau bidimensionnel, axis=0 signifie opérer le long de l'axe 0, c'est-à-dire opérer sur chaque colonne ; axis=1 signifie opérer le long de l'axe 1, c'est-à-dire opérer sur chaque ligne.
Ci-dessous, en prenant comme exemple un tableau à deux dimensions de forme (2, 3), nous montrons visuellement les directions des deux axes et la signification des attributs :
axis indique « dans quelle direction compresser », et non « quelle ligne/colonne » : une somme selon axis=0 compresse plusieurs lignes en une seule ligne, le résultat est donc la somme de chaque colonne.
Exemple
a = np.array([[1, 2, 3], [4, 5, 6]])
# Somme selon axis 0 : compresser selon les lignes, sommer chaque colonne
print(a.sum(axis=0))
# Somme selon axis 1 : compresser selon les colonnes, sommer chaque ligne
print(a.sum(axis=1))
Résultat de sortie :
[5 7 9] [ 6 15]
La démonstration interactive ci-dessous peut montrer plus intuitivement la direction de sommation des deux axes. Cliquez sur les boutons pour basculer :
a.sum(axis=0) → [5 7 9], compresser les éléments de chaque colonne selon axis 0 en un seul nombreParmi les attributs d'objet ndarray les plus importants des tableaux NumPy, on trouve :
| Attribut | Description |
|---|---|
ndarray.ndim | Le rang du tableau, c'est-à-dire le nombre de dimensions ou le nombre d'axes du tableau. |
ndarray.shape | Les dimensions du tableau, représentant la taille du tableau sur chaque axe. Pour un tableau à deux dimensions (matrice), elles représentent le nombre de lignes et de colonnes. |
ndarray.size | Le nombre total d'éléments dans le tableau, égal àndarray.shapele produit des tailles de chaque axe dans shape. |
ndarray.dtype | Le type de données des éléments dans le tableau. |
ndarray.itemsize | La taille de chaque élément dans le tableau, en bytes. |
ndarray.flags | Contient des informations sur la disposition de la mémoire, comme le fait qu'il s'agisse d'un stockage contigu C ou Fortran, qu'il soit en lecture seule, etc. |
ndarray.real | La partie réelle de chaque élément dans le tableau (si le type d'élément est complexe). |
ndarray.imag | La partie imaginaire de chaque élément dans le tableau (si le type d'élément est complexe). |
ndarray.data | Le tampon qui stocke réellement les éléments du tableau, généralement accessible par indexation, et cet attribut n'est pas utilisé directement. |
ndarray.ndim
ndarray.ndim est utilisé pour obtenir le nombre de dimensions d'un tableau (c'est-à-dire le nombre d'axes), qui est le rang.
Exemple
a = np.arange(24)
print(a.ndim) # a n'a maintenant qu'une seule dimension
# Utilisez reshape pour ajuster sa taille, en le transformant en 2 pages, 4 lignes et 3 colonnes
b = a.reshape(2, 4, 3) # b a maintenant trois dimensions
print(b.ndim)
Résultat de sortie :
1 3
ndarray.shape
ndarray.shape représente les dimensions du tableau et renvoie un tuple. La longueur de ce tuple est le nombre de dimensions, c'est-à-dire la propriété ndim (rang).
Par exemple, la forme d'un tableau à deux dimensions représente son « nombre de lignes » et son « nombre de colonnes ».
L'ordre du tuple de forme est cohérent avec l'ordre des axes : l'élément 0 est la taille de l'axe 0 (nombre de lignes), et l'élément 1 est la taille de l'axe 1 (nombre de colonnes).
Exemple
a = np.array([[1, 2, 3], [4, 5, 6]])
print(a.shape)
Résultat de sortie :
(2, 3)
ndarray.shape peut aussi servir à ajuster la taille du tableau.
Exemple
a = np.array([[1, 2, 3], [4, 5, 6]])
a.shape = (3, 2)
print(a)
Résultat de sortie :
[[1 2] [3 4] [5 6]]
NumPy fournit également la fonction reshape pour ajuster la taille des tableaux.
Exemple
a = np.array([[1, 2, 3], [4, 5, 6]])
b = a.reshape(3, 2)
print(b)
Résultat de sortie :
[[1 2] [3 4] [5 6]]
La différence entre les deux méthodes : affecter directement une valeur à a.shape modifie le tableau a lui-même en place ; tandis que a.reshape(3, 2) renvoie un nouvel objet tableau (partageant généralement les mêmes données avec a), et a lui-même reste inchangé.
ndarray.size
ndarray.size renvoie le nombre total d'éléments dans le tableau, égal au produit des tailles de chaque axe dans shape.
Exemple
a = np.array([[1, 2, 3], [4, 5, 6]])
print(a.shape) # la forme est (2, 3)
print(a.size) # Nombre total d'éléments : 2 × 3 = 6
Résultat de sortie :
(2, 3) 6
ndarray.dtype
ndarray.dtype renvoie le type de données des éléments du tableau.
L'objet dtype contient des informations telles que le nom du type et la largeur en bits des éléments. Par exemple, int64 représente un entier 64 bits, et float32 représente un nombre à virgule flottante 32 bits.
Exemple
# Les listes d'entiers créent un tableau int64 par défaut (int32 par défaut sous Windows)
a = np.array([1, 2, 3])
print(a.dtype)
# Lors de la création, vous pouvez spécifier explicitement le type de données avec le paramètre dtype
b = np.array([1, 2, 3], dtype=np.float32)
print(b.dtype)
Résultat de sortie :
int64 float32
ndarray.real et ndarray.imag
ndarray.real et ndarray.imag renvoient respectivement la partie réelle et la partie imaginaire de chaque élément du tableau, principalement utilisés lorsque le type d'élément est complexe.
Exemple
# Créez un tableau complexe, le type par défaut est complex128
a = np.array([1+2j, 3+4j, 5+6j])
print(a.real) # La partie réelle de chaque élément
print(a.imag) # La partie imaginaire de chaque élément
Résultat de sortie :
[1. 3. 5.] [2. 4. 6.]
ndarray.itemsize
ndarray.itemsize renvoie la taille de chaque élément du tableau en octets.
Par exemple, pour un tableau avec un type d'élément float64, la valeur de l'attribut itemsize est 8 (float64 occupe 64 bits, et chaque 8 bits correspond à 1 octet, donc 64 ÷ 8 = 8 octets).
Autre exemple, pour un tableau avec un type d'élément int32, la valeur de l'attribut itemsize est 4 (32 ÷ 8).
Le produit de size et itemsize est le nombre total d'octets occupés par les données du tableau, ce qui correspond à la valeur de l'attribut ndarray.nbytes.
Exemple
# Le dtype du tableau est int8, chaque élément occupe 1 octet
x = np.array([1, 2, 3, 4, 5], dtype=np.int8)
print(x.itemsize)
# Le dtype du tableau est float64, chaque élément occupe 8 octets
y = np.array([1, 2, 3, 4, 5], dtype=np.float64)
print(y.itemsize)
Résultat de sortie :
1 8
ndarray.flags
ndarray.flags renvoie les informations mémoire de l'objet ndarray, y compris les attributs suivants :
| Attribut | Description |
|---|---|
| C_CONTIGUOUS (C) | Les données se trouvent dans une seule région mémoire contiguë de style C. |
| F_CONTIGUOUS (F) | Les données se trouvent dans une seule région mémoire contiguë de style Fortran. |
| OWNDATA (O) | Le tableau possède la mémoire qu'il utilise, plutôt que de l'emprunter à d'autres objets. |
| WRITEABLE (W) | La zone de données peut être écrite ; définir cette valeur sur False rend les données en lecture seule. |
| ALIGNED (A) | Les données et tous les éléments sont correctement alignés sur le matériel. |
| WRITEBACKIFCOPY (X) | Ce tableau est une copie d'un autre tableau ; lorsque ce tableau est libéré, son contenu sera réécrit dans le tableau d'origine. |
L'UPDATEIFCOPY hérité (U) est l'ancien nom de WRITEBACKIFCOPY. Il a été déprécié dans NumPy 1.14 et complètement supprimé à partir de NumPy 2.0, il ne doit donc plus être utilisé désormais.
C_CONTIGUOUS et F_CONTIGUOUS décrivent l'ordre dans lequel les mêmes données sont disposées en mémoire. Pour un même tableau à deux dimensions, il existe deux méthodes de stockage typiques :
Exemple
x = np.array([1, 2, 3, 4, 5])
print(x.flags)
Le résultat de sortie est:
C_CONTIGUOUS : True F_CONTIGUOUS : True OWNDATA : True WRITEABLE : True ALIGNED : True WRITEBACKIFCOPY : FalseAutres extensions