Tutorial de NumPy

NumPy (Numerical Python) es la biblioteca fundamental para la computación numérica en Python. Introduce el ndarray — un array multidimensional rápido y de tipo fijo — y lo complementa con cientos de funciones matemáticas que operan sobre arrays completos de una sola vez. Prácticamente todas las bibliotecas científicas de Python (Pandas, SciPy, Matplotlib, scikit-learn) están construidas sobre NumPy.

Este capítulo abarca:

• Qué es NumPy y por qué es más rápido que las listas de Python
• Instalar NumPy y la convención de importación estándar
• Crear arrays con np.array, np.zeros, np.ones, np.arange y np.linspace
• Indexación, slicing y enmascaramiento boolean
• Reorganización y transposición
• Broadcasting — operar en arrays con diferentes formas
• Funciones de agregación (sum, mean, std, min, max)
• Matemáticas elemento a elemento y álgebra lineal
• Funciones de utilidad comunes (sort, unique, where, concatenate)

¿Qué es NumPy?

NumPy es una biblioteca de Python de código abierto que proporciona:

1. Un potente objeto array N-dimensional (ndarray).
2. Funciones matemáticas elemento a elemento (ufuncs) que se aplican a cada elemento de un array en código C compilado, en lugar de un bucle de Python.
3. Álgebra lineal, transformadas de Fourier y rutinas de números aleatorios.

Por qué NumPy es más rápido que las listas de Python

Una lista de Python puede contener elementos de cualquier tipo, por lo que cada elemento almacena una etiqueta de tipo y un puntero al valor real. Los arrays de NumPy almacenan datos numéricos sin procesar en un bloque contiguo de memoria — sin punteros ni búsquedas de tipo. Combinado con bucles C vectorizados (ufuncs), las operaciones sobre un array de NumPy de un millón de elementos suelen ejecutarse 10–100× más rápido que el código equivalente con bucle for de Python.

Instalación de NumPy

NumPy está incluido en la distribución Anaconda. Para instalarlo manualmente con pip:

pip install numpy

Importar NumPy

La convención universal es importar NumPy como np:

import numpy as np

Todos los ejemplos de este capítulo asumen que esta importación ya está disponible.

Creación de Arrays

Desde una lista de Python

Pasa cualquier lista (o lista de listas) a np.array():

[1 2 3 4 5]
int64
(5,)

Un array 2-D (matriz) usa una lista de listas:

[[1 2 3]
 [4 5 6]
 [7 8 9]]
(3, 3)

Atajos para crear arrays

import numpy as np

print(np.zeros((2, 3)))
print(np.ones(4, dtype=int))
print(np.arange(0, 10, 2))
print(np.linspace(0, 1, 5))

[[0. 0. 0.]
 [0. 0. 0.]]
[1 1 1 1]
[0 2 4 6 8]
[0.   0.25 0.5  0.75 1.  ]

np.linspace es especialmente útil cuando necesitas una cantidad precisa de puntos — por ejemplo, al preparar el eje x para un gráfico. Consulta el capítulo de Introducción a Matplotlib para ver cómo combinarlo con funciones de graficación.

Indexación y Slicing

Indexación y slicing en 1-D

NumPy usa la misma sintaxis [start:stop:step] que las listas de Python, pero también admite índices negativos y strides.

import numpy as np

a = np.array([10, 20, 30, 40, 50])

print(a[0])      # first element
print(a[-1])     # last element
print(a[1:4])    # elements at index 1, 2, 3
print(a[::2])    # every other element

10
50
[20 30 40]
[10 30 50]

Indexación en 2-D

Para un array 2-D, usa [fila, columna]:

import numpy as np

b = np.array([[1, 2, 3],
              [4, 5, 6],
              [7, 8, 9]])

print(b[1, 2])    # row 1, col 2 → 6
print(b[0, :])    # first row  → [1 2 3]
print(b[:, 1])    # second column → [2 5 8]
print(b[0:2, 1:3])  # sub-matrix

6
[1 2 3]
[2 5 8]
[[2 3]
 [5 6]]

Enmascaramiento boolean

Pasa un array boolean como índice para seleccionar solo los elementos donde la condición sea True:

import numpy as np

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

print(a[a > 3])        # elements greater than 3
print(a[a % 2 == 0])   # even elements

[4 5]
[2 4]

Las máscaras boolean son el reemplazo idiomático de NumPy para las comprensiones de listas filtradas y son muchas veces más rápidas en arrays grandes.

Reorganización y Transposición

Reorganización

np.reshape() (o el método .reshape()) devuelve una vista de los datos con una nueva forma. El número total de elementos debe permanecer igual.

[[1 2 3]
 [4 5 6]]

Usa -1 para una dimensión que quieras que NumPy infiera automáticamente:

import numpy as np

a = np.arange(12)
print(a.reshape(3, -1))   # 3 rows, NumPy infers 4 columns

[[ 0  1  2  3]
 [ 4  5  6  7]
 [ 8  9 10 11]]

Transposición

.T o np.transpose() intercambia ejes (filas ↔ columnas para arrays 2-D):

[[1 3 5]
 [2 4 6]]
(2, 3)

Agregar y Eliminar Elementos

Agregar elementos

np.append() devuelve un nuevo array plano — no modifica el original en el lugar (a diferencia de list.append).

[1 2 3 4 5 6]

Para adiciones repetidas dentro de un bucle, construir una lista de Python y convertirla de una vez con np.array() al final es mucho más eficiente que llamar a np.append() repetidamente.

Eliminar elementos

np.delete(arr, indices) devuelve un nuevo array con los índices especificados eliminados:

[1 2 5]

Concatenar arrays

np.concatenate() une dos o más arrays a lo largo de un eje existente:

import numpy as np

a = np.array([1, 2])
b = np.array([3, 4])
print(np.concatenate([a, b]))

[1 2 3 4]

Broadcasting

Broadcasting es la regla de NumPy para aplicar operaciones entre arrays de diferentes formas — sin copiar datos. El ejemplo clásico es sumar un escalar a un array:

import numpy as np

a = np.array([1, 2, 3])
print(a + 10)    # 10 is broadcast across all elements

[11 12 13]

Un caso más potente: sumar un array 1-D a cada fila de un array 2-D:

import numpy as np

matrix = np.array([[1, 2, 3],
                   [4, 5, 6]])
row    = np.array([10, 20, 30])

print(matrix + row)

[[11 22 33]
 [14 25 36]]

NumPy compara las formas de derecha a izquierda: (2, 3) + (3,) es válido porque las dimensiones finales coinciden; row se extiende conceptualmente a un array de (2, 3) sin ninguna asignación de memoria.

Operaciones Matemáticas

Aritmética elemento a elemento

Todos los operadores estándar (+, -, *, /, **) funcionan elemento a elemento en arrays de la misma forma. Las funciones equivalentes con nombre (np.add, np.subtract, np.multiply, np.divide) pueden ser útiles cuando se pasan operaciones como argumentos.

[5 7 9]
[ 4 10 18]
[1 4 9]

Funciones matemáticas universales (ufuncs)

NumPy proporciona versiones vectorizadas de todas las funciones matemáticas estándar:

import numpy as np

a = np.array([0, 1, 4, 9, 16], dtype=float)

print(np.sqrt(a))
print(np.log(np.array([1, np.e, np.e**2])))   # natural log
print(np.sin(np.array([0, np.pi/2, np.pi])))

[0. 1. 2. 3. 4.]
[0. 1. 2.]
[ 0.000e+00  1.000e+00 -8.742e-08]

El pequeño valor cercano a cero para sin(π) es un redondeo normal de punto flotante — np.pi es una aproximación de π.

Funciones de Agregación

Las funciones de agregación reducen un array (o uno de sus ejes) a un único valor:

import numpy as np

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

print(np.sum(a))    # 15
print(np.mean(a))   # 3.0
print(np.std(a))    # 1.4142135623730951
print(np.min(a))    # 1
print(np.max(a))    # 5

15
3.0
1.4142135623730951
1
5

Para arrays 2-D, pasa axis=0 para agregar a lo largo de las columnas o axis=1 para agregar a lo largo de las filas:

import numpy as np

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

print(np.sum(m, axis=0))   # column totals: [5 7 9]
print(np.sum(m, axis=1))   # row totals:    [6 15]

[5 7 9]
[ 6 15]

Álgebra Lineal

np.dot() de NumPy calcula el producto punto de dos vectores 1-D o el producto matricial de dos arrays 2-D. Para la multiplicación de matrices, el operador @ (Python 3.5+) es la abreviatura moderna.

import numpy as np

a = np.array([1, 2])
b = np.array([3, 4])
print(np.dot(a, b))     # 1*3 + 2*4 = 11

A = np.array([[1, 2], [3, 4]])
B = np.array([[5, 6], [7, 8]])
print(A @ B)            # matrix product

11
[[19 22]
 [43 50]]

np.linalg contiene operaciones más avanzadas:

Funciones de Utilidad

Ordenamiento

import numpy as np

a = np.array([3, 1, 4, 1, 5, 9, 2, 6])
print(np.sort(a))         # returns a sorted copy
print(np.argsort(a))      # indices that would sort the array

[1 1 2 3 4 5 6 9]
[1 3 6 0 2 4 7 5]

Valores únicos

import numpy as np

a = np.array([1, 2, 2, 3, 3, 3])
print(np.unique(a))

[1 2 3]

Selección condicional con np.where

np.where(condition, x, y) devuelve x donde la condición es True e y en el resto:

import numpy as np

a = np.array([1, 2, 3, 4, 5])
print(np.where(a > 2, a, 0))

[0 0 3 4 5]

NumPy con Matplotlib

NumPy y Matplotlib están diseñados para trabajar juntos. np.linspace genera los valores de x; los ufuncs de NumPy calculan y; Matplotlib grafica el resultado:

import numpy as np
import matplotlib.pyplot as plt

x = np.linspace(0, 2 * np.pi, 200)
plt.plot(x, np.sin(x), label='sin')
plt.plot(x, np.cos(x), label='cos')
plt.legend()
plt.title('Sine and Cosine')
plt.show()

Este ejemplo requiere que Matplotlib esté instalado (pip install matplotlib) y una pantalla o un backend Agg para entornos sin cabecera. Consulta el capítulo de Introducción a Matplotlib para un recorrido detallado.

Qué Aprender a Continuación

• Tutorial de SciPy — computación científica de nivel superior (integración, optimización, procesamiento de señales) construida sobre arrays de NumPy.
• Introducción a Matplotlib — visualiza arrays de NumPy como gráficos de líneas, diagramas de dispersión, histogramas y más.
• Graficación con Matplotlib — ajusta el diseño de figuras, ejes y estilos.