NumPy es la biblioteca fundamental para cálculo numérico en Python. Su estructura principal, el array multidimensional, permite almacenar datos homogéneos y realizar operaciones vectorizadas con menos código que una serie de bucles manuales. Se utiliza en análisis de datos, ciencia, ingeniería, aprendizaje automático, procesamiento de imágenes y muchas bibliotecas que trabajan sobre matrices.
Antes de avanzar conviene conocer las listas en Python, el tutorial de análisis de datos con Pandas y NumPy, la guía de Pandas, los bucles for y la instalación de bibliotecas con pip.
Las fuentes externas principales son la guía oficial de NumPy para principiantes y la guía rápida oficial.
Instalar NumPy
python -m pip install numpy
Trabaja dentro de un entorno virtual para evitar conflictos. Comprueba la versión y el intérprete:
import sys
import numpy as np
print(sys.executable)
print(np.__version__)
Crear el primer array
import numpy as np
valores = np.array([10, 20, 30, 40])
print(valores)
print(type(valores))
A diferencia de una lista, un array suele mantener un único tipo de dato. NumPy elige el tipo a partir de los valores, aunque puedes definirlo:
precios = np.array([10, 20, 30], dtype=np.float64)
Atributos importantes
matriz = np.array([
[1, 2, 3],
[4, 5, 6],
])
print(matriz.ndim)
print(matriz.shape)
print(matriz.size)
print(matriz.dtype)
ndim indica dimensiones, shape describe el tamaño de cada eje, size cuenta elementos y dtype muestra el tipo almacenado. Revisarlos ayuda a detectar errores antes de una operación matricial.
Crear arrays automáticamente
ceros = np.zeros((2, 3))
unos = np.ones((3, 3))
secuencia = np.arange(0, 10, 2)
puntos = np.linspace(0, 1, 5)
identidad = np.eye(3)
arange trabaja con inicio, límite y paso. linspace crea una cantidad exacta de puntos entre dos límites, algo útil en gráficos y simulaciones.
Indexación y slicing
datos = np.array([5, 10, 15, 20, 25])
print(datos[0])
print(datos[-1])
print(datos[1:4])
print(datos[::2])
En matrices utiliza filas y columnas:
matriz = np.array([[1, 2, 3], [4, 5, 6]])
print(matriz[0, 1])
print(matriz[:, 0])
print(matriz[1, :])
Las vistas y las copias
Muchos slices de NumPy crean vistas que comparten memoria:
original = np.array([1, 2, 3, 4])
parte = original[1:3]
parte[0] = 99
print(original)
Si necesitas independencia, crea una copia:
parte = original[1:3].copy()
Comprender esta diferencia evita modificaciones inesperadas.
Operaciones vectorizadas
precios = np.array([10.0, 20.0, 30.0])
con_impuesto = precios * 1.18
print(con_impuesto)
La operación se aplica a todos los elementos sin escribir un bucle explícito. También puedes sumar arrays elemento a elemento:
a = np.array([1, 2, 3])
b = np.array([10, 20, 30])
print(a + b)
Broadcasting
Broadcasting permite combinar formas compatibles:
matriz = np.array([[1, 2, 3], [4, 5, 6]])
ajuste = np.array([10, 20, 30])
print(matriz + ajuste)
NumPy extiende conceptualmente el vector por cada fila. Si las formas no son compatibles, genera un error. Antes de operar, revisa shape y evita redimensionar sin comprender el eje correcto.
Filtrado booleano
notas = np.array([4.5, 7.0, 8.5, 3.0, 9.0])
aprobadas = notas[notas >= 6]
print(aprobadas)
Puedes combinar condiciones con & y |, usando paréntesis:
seleccion = notas[(notas >= 6) & (notas < 9)]
No uses and para comparar arrays completos.
Estadísticas básicas
datos = np.array([10, 20, 30, 40])
print(datos.sum())
print(datos.mean())
print(np.median(datos))
print(datos.min())
print(datos.max())
print(datos.std())
En matrices puedes elegir un eje:
matriz = np.array([[1, 2, 3], [4, 5, 6]])
print(matriz.sum(axis=0))
print(matriz.mean(axis=1))
axis=0 reduce filas y devuelve un resultado por columna; axis=1 reduce columnas y devuelve un resultado por fila.
Cambiar la forma
datos = np.arange(12)
matriz = datos.reshape(3, 4)
print(matriz)
La cantidad total de elementos debe permanecer igual. Para aplanar:
plano = matriz.ravel()
copia_plana = matriz.flatten()
ravel intenta devolver una vista; flatten crea una copia.
Concatenar arrays
a = np.array([1, 2])
b = np.array([3, 4])
print(np.concatenate([a, b]))
Para matrices:
arriba_abajo = np.vstack([matriz, matriz])
lado_a_lado = np.hstack([matriz, matriz])
Verifica dimensiones y ejes antes de concatenar.
Números aleatorios
rng = np.random.default_rng(42)
enteros = rng.integers(1, 101, size=10)
normales = rng.normal(loc=0, scale=1, size=1000)
Usar un generador y una semilla facilita reproducir pruebas y análisis. Para seguridad criptográfica no uses NumPy; emplea el módulo secrets.
Valores ausentes y NaN
datos = np.array([10.0, np.nan, 30.0])
print(np.isnan(datos))
print(np.nanmean(datos))
NaN es un valor flotante especial. No lo compares con igualdad. Usa np.isnan y funciones que sepan ignorarlo cuando esa decisión sea válida.
Tipos y memoria
grandes = np.array([1, 2, 3], dtype=np.int64)
pequenos = grandes.astype(np.int16)
print(grandes.nbytes)
print(pequenos.nbytes)
Reducir el tipo puede ahorrar memoria, pero existe riesgo de desbordamiento o pérdida de precisión. Comprueba los rangos con np.iinfo y np.finfo.
Producto matricial
a = np.array([[1, 2], [3, 4]])
b = np.array([[5, 6], [7, 8]])
print(a @ b)
print(np.matmul(a, b))
No confundas *, que multiplica elemento a elemento, con @, que realiza el producto matricial.
Cargar y guardar datos
np.save("datos.npy", matriz)
recuperada = np.load("datos.npy")
Para texto:
np.savetxt("datos.csv", matriz, delimiter=",", fmt="%d")
recuperada = np.loadtxt("datos.csv", delimiter=",")
Para tablas con encabezados, valores ausentes o tipos mezclados, Pandas suele ser más apropiado.
Comparar floats
a = np.array([0.1 + 0.2])
b = np.array([0.3])
print(np.allclose(a, b))
No confíes en igualdad exacta para resultados flotantes. Ajusta tolerancias solo cuando comprendas el error numérico aceptable.
Errores frecuentes
Los problemas habituales son confundir listas con arrays, ignorar el dtype, modificar una vista creyendo que es copia, usar and con máscaras, mezclar formas incompatibles y confundir multiplicación elemento a elemento con producto matricial. Otro error es vectorizar una lógica ilegible solo para evitar un bucle pequeño.
Conclusión
NumPy ofrece arrays eficientes, operaciones vectorizadas, estadísticas, filtros y herramientas matriciales. Empieza revisando forma y tipo, aprende cómo funcionan las vistas y usa broadcasting con intención. Con estas bases puedes procesar datos numéricos de manera clara y preparar el camino para Pandas, visualización y aprendizaje automático.
