Tableaux Structurés dans NumPy

Introduction

Dans ce laboratoire, vous apprendrez les tableaux structurés (structured arrays) dans NumPy. Les tableaux structurés sont une fonctionnalité puissante pour travailler avec des données hétérogènes, similaires aux tables d'une base de données ou d'une feuille de calcul. Chaque élément d'un tableau structuré peut être considéré comme une ligne, avec des colonnes nommées appelées "champs" (fields). Cela les rend idéaux pour organiser et manipuler des données tabulaires directement en Python.

Tout au long de ce laboratoire, vous écrirez et exécuterez du code Python dans le fichier structured_arrays.py fourni dans le WebIDE.

Création et Accès à un Tableau Structuré

Tout d'abord, créons un tableau structuré simple. Le type de données (dtype) d'un tableau structuré est défini comme une liste de tuples. Chaque tuple spécifie un champ avec son (nom, type_de_données). Cela nous permet de stocker différents types de données, comme des chaînes de caractères et des entiers, dans le même tableau.

Ouvrez le fichier structured_arrays.py depuis l'explorateur de fichiers dans le panneau de gauche. Ajoutez le code suivant pour créer un tableau structuré représentant une liste de personnes avec leurs noms et âges.

## Create a structured array
data = np.array([('Alice', 25, 55.5), ('Bob', 30, 68.0)],
                dtype=[('name', 'U10'), ('age', 'i4'), ('weight', 'f4')])

print("Original Array:")
print(data)

## Access a specific field by its name
names = data['name']
print("\nNames field:")
print(names)

Explication du code :

• import numpy as np : Cette ligne importe la bibliothèque NumPy.
• np.array([...], dtype=[...]) : Nous créons un tableau. Le premier argument est une liste de tuples, où chaque tuple ('Alice', 25, 55.5) représente une ligne de données.
• dtype=[('name', 'U10'), ('age', 'i4'), ('weight', 'f4')] : C'est la partie cruciale. Nous définissons trois champs :
  • 'name' : Une chaîne de caractères Unicode avec une longueur maximale de 10 caractères (U10).
  • 'age' : Un entier de 4 octets (32 bits) (i4).
  • 'weight' : Un flottant de 4 octets (32 bits) (f4).
• data['name'] : Nous pouvons accéder à toutes les valeurs d'un champ (colonne) spécifique en utilisant son nom comme index, ce qui renvoie un nouveau tableau NumPy.

Maintenant, enregistrez le fichier et exécutez-le depuis le terminal pour voir la sortie.

python structured_arrays.py

Vous devriez voir la sortie suivante, qui montre le tableau structuré complet et le tableau ne contenant que les noms.

Original Array:
[('Alice', 25, 55.5) ('Bob', 30, 68. )]

Names field:
['Alice' 'Bob']

Modification des Champs et Indexation

Les tableaux structurés sont mutables, ce qui signifie que vous pouvez modifier leurs valeurs. Vous pouvez modifier un champ entier à la fois ou accéder à un élément spécifique par son index, puis modifier son champ. Vous pouvez également créer un nouveau tableau contenant un sous-ensemble des champs d'origine.

Ajoutez le code suivant à la fin de votre script structured_arrays.py.

## Modify the 'age' field
data['age'] = [26, 31]
print("\nArray after modifying age:")
print(data)

## Access a single element (the first row)
first_person = data[0]
print("\nFirst person's data:")
print(first_person)

## Create a new array with a subset of fields
subset = data[['name', 'weight']]
print("\nSubset of array (name and weight):")
print(subset)

Explication du code :

• data['age'] = [26, 31] : Ceci assigne une nouvelle liste de valeurs au champ age, mettant à jour toute la colonne.
• data[0] : Ceci accède au premier élément (ligne) du tableau. Le résultat est un scalaire NumPy de type void, qui contient les données de cette seule ligne.
• data[['name', 'weight']] : En passant une liste de noms de champs, vous pouvez sélectionner plusieurs colonnes, ce qui crée un nouveau tableau structuré avec uniquement ces champs.

Enregistrez le fichier et exécutez-le à nouveau depuis le terminal.

python structured_arrays.py

Votre sortie inclura maintenant les nouvelles sections, montrant le tableau modifié et le sous-ensemble.

... (previous output) ...

Array after modifying age:
[('Alice', 26, 55.5) ('Bob', 31, 68. )]

First person's data:
('Alice', 26, 55.5)

Subset of array (name and weight):
[('Alice', 55.5) ('Bob', 68. )]

Utilisation des Tableaux d'Enregistrements pour l'Accès aux Attributs

Bien que l'indexation par nom (par exemple, data['name']) soit puissante, elle peut être verbeuse. NumPy fournit une sous-classe spéciale de ndarray appelée tableau d'enregistrements (np.recarray). Les tableaux d'enregistrements vous permettent d'accéder aux champs en tant qu'attributs, en utilisant la notation par points (par exemple, record_array.name), ce qui peut rendre votre code plus propre et plus lisible.

Vous pouvez créer un tableau d'enregistrements directement ou convertir un tableau structuré existant. Voyons comment faire les deux. Ajoutez le code suivant à la fin de structured_arrays.py.

## Convert the structured array to a record array using view()
record_array = data.view(np.recarray)

print("\nType of the new view:")
print(type(record_array))

## Access fields using attribute (dot) notation
print("\nAccessing names via attribute:")
print(record_array.name)

print("\nAccessing ages via attribute:")
print(record_array.age)

Explication du code :

• data.view(np.recarray) : La méthode .view() crée un nouvel objet tableau qui visualise les mêmes données. En spécifiant np.recarray, nous obtenons une vue de tableau d'enregistrements des données de notre tableau structuré. Aucune donnée n'est copiée ; c'est simplement une manière différente d'interagir avec elle.
• record_array.name : C'est la caractéristique principale des tableaux d'enregistrements. Vous pouvez accéder au champ name comme s'il s'agissait d'un attribut de l'objet. Ceci est équivalent à record_array['name'].

Enregistrez le fichier et exécutez-le.

python structured_arrays.py

La sortie affichera désormais le type de la nouvelle vue du tableau et démontrera l'accès aux attributs.

... (previous output) ...

Type of the new view:
<class 'numpy.recarray'>

Accessing names via attribute:
['Alice' 'Bob']

Accessing ages via attribute:
[26 31]

Résumé

Dans ce laboratoire, vous avez appris les bases de l'utilisation des tableaux structurés dans NumPy. Vous avez commencé par créer un tableau structuré avec des champs nommés et plusieurs types de données. Vous avez ensuite pratiqué l'accès à des champs spécifiques (colonnes) en utilisant l'indexation par clé de style dictionnaire et la modification de leurs valeurs. Enfin, vous avez exploré les tableaux d'enregistrements (record arrays), une alternative pratique qui permet d'accéder aux champs en tant qu'attributs, et vous avez appris à convertir entre les tableaux structurés standard et les tableaux d'enregistrements à l'aide de la méthode .view().

Les tableaux structurés sont un outil essentiel pour traiter des jeux de données tabulaires complexes en calcul scientifique et en analyse de données avec Python.