Arrays Estructurados en NumPy

Introducción

En este laboratorio, aprenderá sobre los arrays estructurados en NumPy. Los arrays estructurados son una característica potente para trabajar con datos heterogéneos, similar a las tablas en una base de datos o una hoja de cálculo. Cada elemento de un array estructurado puede considerarse como una fila, con columnas con nombre llamadas "campos" (fields). Esto los hace ideales para organizar y manipular datos tabulares directamente dentro de Python.

A lo largo de este laboratorio, escribirá y ejecutará código Python en el archivo structured_arrays.py proporcionado en el WebIDE.

Creación y Acceso a un Array Estructurado

Primero, creemos un array estructurado simple. El tipo de datos (dtype) de un array estructurado se define como una lista de tuplas. Cada tupla especifica un campo con su (nombre, tipo_de_dato). Esto nos permite almacenar diferentes tipos de datos, como cadenas de texto y enteros, en el mismo array.

Abra el archivo structured_arrays.py desde el explorador de archivos en el panel izquierdo. Agregue el siguiente código para crear un array estructurado que represente una lista de personas con sus nombres y edades.

## 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)

Explicación del Código:

• import numpy as np: Esta línea importa la biblioteca NumPy.
• np.array([...], dtype=[...]): Creamos un array. El primer argumento es una lista de tuplas, donde cada tupla ('Alice', 25, 55.5) representa una fila de datos.
• dtype=[('name', 'U10'), ('age', 'i4'), ('weight', 'f4')]: Esta es la parte crucial. Definimos tres campos:
  • 'name': Una cadena de texto Unicode con una longitud máxima de 10 caracteres (U10).
  • 'age': Un entero de 4 bytes (32 bits) (i4).
  • 'weight': Un número flotante de 4 bytes (32 bits) (f4).
• data['name']: Podemos acceder a todos los valores de un campo (columna) específico utilizando su nombre como índice, lo que devuelve un nuevo array de NumPy.

Ahora, guarde el archivo y ejecútelo desde la terminal para ver la salida.

python structured_arrays.py

Debería ver la siguiente salida, que muestra el array estructurado completo y el array que contiene solo los nombres.

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

Names field:
['Alice' 'Bob']

Modificación de Campos e Indexación

Los arrays estructurados son mutables, lo que significa que puedes cambiar sus valores. Puedes modificar un campo completo a la vez o acceder a un elemento específico por su índice y luego modificar su campo. También puedes crear un nuevo array que contenga un subconjunto de los campos originales.

Agrega el siguiente código al final de tu 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)

Explicación del Código:

• data['age'] = [26, 31]: Esto asigna una nueva lista de valores al campo age, actualizando toda la columna.
• data[0]: Esto accede al primer elemento (fila) del array. El resultado es un escalar void de NumPy (NumPy void scalar), que contiene los datos de esa única fila.
• data[['name', 'weight']]: Al pasar una lista de nombres de campos, puedes seleccionar múltiples columnas, lo que crea un nuevo array estructurado solo con esos campos.

Guarda el archivo y ejecútalo de nuevo desde la terminal.

python structured_arrays.py

Tu salida ahora incluirá las nuevas secciones, mostrando el array modificado y el subconjunto.

... (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. )]

Uso de Arrays de Registros para Acceso a Atributos

Si bien la indexación por nombre (por ejemplo, data['name']) es potente, puede ser verbosa. NumPy proporciona una subclase especial de ndarray llamada array de registro (np.recarray). Los arrays de registro te permiten acceder a los campos como atributos, utilizando la notación de punto (por ejemplo, record_array.name), lo que puede hacer que tu código sea más limpio y legible.

Puedes crear un array de registro directamente o convertir un array estructurado existente. Veamos cómo hacer ambas cosas. Agrega el siguiente código al final 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)

Explicación del Código:

• data.view(np.recarray): El método .view() crea un nuevo objeto de array que mira los mismos datos. Al especificar np.recarray, obtenemos una vista de array de registro de los datos de nuestro array estructurado. No se copian datos; es solo una forma diferente de interactuar con ellos.
• record_array.name: Esta es la característica clave de los arrays de registro. Puedes acceder al campo name como si fuera un atributo del objeto. Esto es equivalente a record_array['name'].

Guarda el archivo y ejecútalo.

python structured_arrays.py

La salida ahora mostrará el tipo de la nueva vista del array y demostrará el acceso a atributos.

... (previous output) ...

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

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

Accessing ages via attribute:
[26 31]

Resumen

En este laboratorio, has aprendido los fundamentos del uso de arrays estructurados en NumPy. Comenzaste creando un array estructurado con campos con nombre y múltiples tipos de datos. Luego practicaste el acceso a campos específicos (columnas) utilizando indexación de claves estilo diccionario y la modificación de sus valores. Finalmente, exploraste los arrays de registro, una alternativa conveniente que permite acceder a los campos como atributos, y aprendiste a convertir entre arrays estructurados estándar y arrays de registro utilizando el método .view().

Los arrays estructurados son una herramienta esencial para manejar conjuntos de datos tabulares complejos en la computación científica y el análisis de datos con Python.