NumPy en Python: Dominando los Arreglos para Ingeniería

Hola controleros y controleras. Bienvenidos a una nueva lección de nuestro curso de Python desde Cero. Hoy vamos a dar un paso fundamental en nuestra formación como ingenieros y programadores: vamos a dominar NumPy.

Si estás aquí, probablemente ya sabes usar listas en Python. Pero cuando hablamos de control de procesos, visión artificial o simulación de sistemas dinámicos, las listas se quedan cortas. Necesitamos velocidad, eficiencia y herramientas matemáticas potentes. Ahí es donde entra NumPy (Numerical Python), el estándar universal para la computación científica.

Si prefieres ver la clase en video, aquí te lo dejo. Pero si eres de los que prefiere leer y tener el código a mano para copiar y pegar, ¡sigue bajando que aquí está todo explicado al detalle!

¿Qué es NumPy y por qué no usar simplemente listas?

Imagina que tienes que procesar una imagen de 4K o simular un controlador predictivo. Una lista de Python es como una navaja suiza: sirve para todo (puedes guardar enteros, textos, booleanos juntos), pero no es experta en nada. NumPy, en cambio, introduce el objeto ndarray.

La diferencia clave es la homogeneidad: en un array de NumPy, todos los datos deben ser del mismo tipo. Esto permite que se almacenen en bloques de memoria contiguos, haciendo que las operaciones sean muchísimo más rápidas y consuman menos memoria. Es la base sobre la que se construyen gigantes como Pandas, Matplotlib y Scikit-learn.

Instalación y Primeros Pasos

Para usar NumPy, primero debemos instalarlo. Si usas Anaconda (muy común en nuestro gremio), usa conda install numpy. Si prefieres pip, el comando es pip install numpy.

En nuestro código, siempre lo importaremos con el alias np. Es una convención mundial, así que acostumbrémonos a ella:

Python

import numpy as np

Creación de Arrays: Más allá de las listas

Podemos crear arrays desde listas o tuplas usando np.array(). Fíjate que al imprimirlo, Python nos dice que es de tipo numpy.ndarray:

Python

# Desde una lista
array1 = np.array([1, 2, 3, 4])

# Desde una tupla
array2 = np.array((5, 6, 7, 8))

Pero en ingeniería, rara vez escribimos los datos a mano. Usamos generadores automáticos:

• np.zeros(5): Crea un vector de 5 ceros (útil para inicializar variables de estado).
• np.ones(3): Un vector de unos.
• np.arange(inicio, fin, paso): Similar al range de Python, pero devuelve un array. Ej: np.arange(2, 9, 2) nos da [2, 4, 6, 8].
• np.linspace(inicio, fin, num_puntos): Vital para gráficas. Genera puntos linealmente espaciados.

Entendiendo las Dimensiones (Shape y Ndim)

Aquí es donde muchos estudiantes se confunden, así que vamos despacio. NumPy nos permite trabajar con escalares (0-D), vectores (1-D), matrices (2-D) y tensores (3-D o más).

Para saber qué tenemos entre manos, usamos tres propiedades clave:

1. .ndim: Número de dimensiones (ejes).
2. .size: Cantidad total de elementos.
3. .shape: La forma exacta (filas, columnas, profundidad).

Por ejemplo, una matriz de 2 filas y 3 columnas tendría un shape de (2, 3).

Remodelando datos (Reshape)

A veces recibimos datos en un vector largo y necesitamos convertirlo en matriz. Para eso usamos .reshape(). La única regla es que la cantidad total de elementos se mantenga:

Python

a = np.arange(6)       # [0, 1, 2, 3, 4, 5]
b = a.reshape(3, 2)    # Matriz de 3 filas, 2 columnas

Recorriendo Arreglos: Del Bucle For a nditer

Una pregunta frecuente cuando venimos de usar listas en Python es: «¿Cómo hago un for para recorrer mi matriz?». La respuesta tiene matices importantes en ingeniería. Aunque en NumPy siempre preferimos operar con vectores completos (es más rápido), a veces es inevitable tener que visitar cada elemento uno por uno.

El Bucle For Clásico

Si trabajamos con un arreglo de una dimensión (1D), la iteración es idéntica a la de una lista estándar de Python:

Python

d1 = np.array([1.5, 3.2, 4.0])

# Iterating over a 1D array
for i in d1:
    print(i)

Sin embargo, la cosa se complica cuando subimos de dimensiones. Si intentas usar un solo for en una matriz 2D, NumPy no te devolverá los números individuales, sino que imprimirá filas completas. Para acceder a los escalares, tendrías que anidar bucles, un for dentro de otro for:

Python

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

# Iterating over a 2D array (requires nested loops)
for row in d2:
    for element in row:
        print(element)

Imagina ahora que trabajas con un tensor 3D (común en procesamiento de imágenes a color). Tendrías que escribir tres bucles anidados solo para leer los datos. Esto hace que el código sea difícil de leer y mantener.

La Solución Profesional: np.nditer()

Aquí es donde entra la magia de NumPy. En lugar de escribir bucles infinitos o usar trucos como reshape(-1) (que puede ser ineficiente en memoria con arreglos gigantes ), la librería nos ofrece una función optimizada diseñada específicamente para esto: np.nditer().

Esta función crea un objeto iterable que recorre eficientemente todos los elementos del arreglo, sin importar si tiene 1, 2, 3 o 10 dimensiones. Es la forma «pythónica» y correcta de hacerlo en ingeniería:

Python

d3 = np.array([[[1, 2

Accediendo a los Datos (Indexing y Slicing)

Acceder a un array 1D es igual que en una lista: array[0] es el primer elemento. Pero en matrices multidimensionales, usamos una notación más potente con comas:

$$\text{array}[\text{fila}, \text{columna}]$$

Si tienes una matriz a2, a2[0, 1] accede a la fila 0, columna 1. También podemos usar el slicing (rebanado) para obtener sub-matrices, por ejemplo a2[:, 1] nos daría toda la columna 1.

Tipos de Datos (Dtypes)

A diferencia de Python puro, NumPy nos da control total sobre los bits. Podemos definir si queremos enteros de 32 bits (int32), flotantes (float), complejos (complex), booleanos, etc. Podemos verificar el tipo de dato de cualquier array con .dtype.

Cuidado con esto: Copias vs Vistas

Este es un error clásico de principiante que te puede costar horas de depuración.

Cuando igualas un array a otro (b = a), no estás creando una copia, estás creando una referencia. Si modificas b, ¡también se modifica a! Esto se conoce como Side Effects.

Para evitarlo y trabajar seguro, usa siempre el método .copy():

Python

# Forma Correcta
c = a.copy()
# Ahora 'c' es independiente de 'a'

Operaciones Matemáticas y Álgebra Lineal

NumPy está diseñado para operar elemento a elemento (element-wise). Si sumas dos arrays, se suman posición a posición. No necesitas bucles for.

Python

a1 = np.array([1, 2, 3])
a2 = np.array([10, 20, 30])

suma = a1 + a2      # Resultado: [11, 22, 33]
producto = a1 * a2  # Resultado: [10, 40, 90]

Además, tenemos funciones universales como np.sqrt(), np.sin(), np.exp(), etc., que se aplican a todo el array instantáneamente.

Para los ingenieros: Si necesitas la transpuesta de una matriz, simplemente usa .T. Y si buscas operaciones de álgebra lineal más complejas (inversas, determinantes), el submódulo numpy.linalg será tu mejor amigo.

Manipulación Avanzada: Concatenar y Dividir

A menudo necesitamos unir datos de diferentes sensores o experimentos. NumPy nos ofrece varias formas de concatenar:

• np.concatenate((a1, a2)): La forma genérica.
• np.vstack((a1, a2)): Apila verticalmente (agrega filas).
• np.hstack((a1, a2)): Apila horizontalmente (agrega columnas).

Y el proceso inverso es np.array_split(), que nos permite dividir un array en varias partes.

Filtrado de Datos

Finalmente, una de mis funcionalidades favoritas: el filtrado booleano. Podemos extraer datos que cumplan una condición lógica. Por ejemplo, si queremos todos los valores mayores a 5:

Python

data = np.array([1, 10, 2, 8, 3])
filtrados = data[data > 5]  # Resultado: [10, 8]

También existen herramientas como np.where() para reemplazar valores condicionalmente (muy útil para saturar señales en control) o np.unique() para eliminar repetidos.

---

Eso es todo por la entrada de hoy. Como ven, NumPy es una bestia parda del cálculo numérico. Si dominan estos conceptos, el resto de librerías de Python para ingeniería serán pan comido.

Recuerden que tienen el código disponible en el repositorio y los ejercicios resueltos. ¡Nos vemos en la siguiente clase!