Última actualización: 2026-11-11

Contenido de esta página

• ¿Qué es NumPy y para qué sirve?
• ¿Por qué una lista de Python no basta para el cálculo numérico?
• ¿Cómo se crea un array de NumPy?
• Indexación y rebanado: ¿vista o copia?
• Broadcasting: cómo opera NumPy con arrays de formas distintas
• Operaciones elemento a elemento, agregaciones y el parámetro axis
• Un ejemplo con precios: una canasta simulada
• Números aleatorios con NumPy: default_rng y la semilla
• Álgebra lineal con NumPy: lo justo para empezar
• SciPy: el escalón siguiente a NumPy
• NumPy frente a las herramientas vecinas
• Lo que dejó la división entre Numeric y Numarray

En 1995, Jim Hugunin era estudiante de posgrado en el MIT, el Instituto Tecnológico de Massachusetts. Ese año escribió Numeric, un paquete para calcular con arreglos de números en Python, a partir de un trabajo previo de Jim Fulton [2]. Uno de los primeros usos de Numeric fue manejar, desde Python, programas escritos en C++ para investigación en fusión nuclear por confinamiento inercial, en el Laboratorio Nacional Lawrence Livermore de Estados Unidos [1].

Luego llegaron las imágenes del telescopio espacial Hubble. Eran imágenes astronómicas grandes, y para manejarlas se escribió otra versión del mismo paquete, llamada Numarray [1]. La desarrolló el Space Telescope Science Institute, el instituto científico del telescopio, que había empezado a usar Python en 1998 [2].

Los dos paquetes eran muy compatibles entre sí. Aun así, tenían diferencias suficientes para dividir a la comunidad [1].

En 2005, Travis Oliphant, que mantenía Numeric, encabezó el trabajo de unirlos e hizo la mayor parte [2]. De ahí salió la primera versión de NumPy. El equipo del proyecto la describe en la revista Nature como una unificación «lo mejor de ambos mundos» [1]. Juntaba las funciones de Numarray con la rapidez de Numeric en arreglos pequeños y su completa interfaz para programar en C [1].

Esa división entre dos formatos para la misma cosa dejó una lección que sigue vigente. Lo valioso de NumPy no es una función en particular, sino que todo el cálculo numérico de Python habla el mismo idioma: el array.

¿Qué es NumPy y para qué sirve?

NumPy es una librería gratuita de Python, es decir, un paquete de código ya escrito, para hacer cálculos con arrays. Un array, o arreglo, es un bloque de números del mismo tipo organizados en filas, columnas o más dimensiones. NumPy sirve para sumar, multiplicar, filtrar y resumir miles o millones de esos números con una sola instrucción [3][4].

Su objeto central se llama ndarray, que abrevia «arreglo de n dimensiones» en inglés [4]. Uno de una dimensión se parece a una fila de casillas; uno de dos, a una tabla; uno de tres, a varias tablas apiladas como páginas de un libro [4].

En el trabajo diario de un analista, NumPy aparece de dos maneras. A veces se usa directamente, para simular, calcular índices o hacer operaciones con matrices. Y muchas otras veces trabaja por debajo de otras herramientas, porque casi todas las librerías de Python que hacen cálculo científico o numérico se apoyan en ella [1].

Es software libre: se distribuye con una licencia BSD, que permite usarlo y redistribuirlo, con o sin cambios, siempre que se conserve su aviso de derechos [3]. La versión más reciente en el índice oficial de paquetes de Python es la 2.5.4, publicada el 10 de octubre de 2026, y exige Python 3.12 o superior [11]. Todos los ejemplos de esta página los ejecuté con esa versión.

Si todavía no sabe dónde escribir y correr código, empiece por la guía de Python para el análisis de datos. Luego abra un cuaderno de Jupyter Notebook: ahí puede pegar cada bloque y ver el resultado debajo.

¿Por qué una lista de Python no basta para el cálculo numérico?

La lista de Python es un contenedor de uso general. Puede mezclar textos, números y otras listas, y es bastante rápida cuando se opera con pocos elementos, uno a la vez [4]. El problema aparece con muchos números del mismo tipo. Para multiplicar dos listas hay que escribir un bucle, una instrucción que repite la operación elemento por elemento, y con millones de datos ese recorrido se paga en tiempo [3].

La mayoría de los arrays de NumPy aceptan restricciones que la lista no tiene. La guía oficial da tres, por ejemplo [4]:

1. Todos sus elementos son del mismo tipo de dato, el dtype: por ejemplo, todos enteros o todos decimales.
2. Su tamaño total queda fijo al crearlo.
3. Su forma es rectangular: cada fila de una tabla tiene el mismo número de columnas.

A cambio de esas reglas, la documentación oficial dice que NumPy vuelve el array más rápido, más eficiente con la memoria y más cómodo de usar [4].

Memoria contigua y un solo tipo de dato

Por dentro, un array tiene dos partes: un bloque continuo de memoria con los datos, y unos metadatos, la información que describe cómo leer ese bloque [5]. Como todos los elementos son del mismo tipo, cada uno ocupa el mismo número de bytes, la unidad con que se mide la memoria [1].

Piense en un tren de vagones idénticos sobre una sola vía. Para llegar al vagón 500 no hay que revisar los 499 anteriores: basta multiplicar el largo de un vagón por la posición. Así encuentra NumPy cada dato. Los metadatos guardan, entre otras cosas, el tipo de dato, la forma y los pasos en bytes para saltar de una fila a la siguiente [1][5].

Vectorización: operar con el array completo

Vectorizar es escribir la operación sobre el array entero, sin bucles visibles. Los bucles siguen existiendo, pero los ejecuta código ya compilado en C, un lenguaje más cercano a la máquina, y no el intérprete de Python [3]. Por eso, con NumPy, la expresión c = a * b multiplica dos arrays elemento a elemento a velocidades cercanas a las de C, según la documentación [3].

El equipo de NumPy lo dejó escrito en Nature en 2020: «la vectorización, operar sobre arreglos completos en lugar de sus elementos individuales, es esencial para la programación con arreglos» [1]. El mismo artículo dice que lo que en C tomaría muchas decenas de líneas a menudo cabe en una sola expresión de Python, clara [1].

La documentación lo resume pensando en el procesador central del computador, la CPU: «NumPy brilla cuando hay grandes cantidades de datos “homogéneos” (del mismo tipo) que procesar en la CPU» [4].

Lista contra array: la prueba en mi computador

Quise medirlo en lugar de repetir cifras ajenas. Tomé un millón de números decimales al azar, con semilla fija, y los guardé dos veces: como lista y como array. Después medí con timeit, el módulo de Python para cronometrar código, dos tareas: sumar todos los números y multiplicar dos colecciones elemento a elemento.

# Prueba propia: lista de Python contra array de NumPy
import timeit
import numpy as np

N = 1_000_000                       # un millón de elementos
rng = np.random.default_rng(42)     # semilla fija: siempre los mismos números
a_arr = rng.random(N)
b_arr = rng.random(N)
a_lis = a_arr.tolist()              # los mismos números, ahora como listas
b_lis = b_arr.tolist()

pruebas = {
    "suma con lista": lambda: sum(a_lis),
    "suma con array": lambda: a_arr.sum(),
    "producto con lista": lambda: [x * y for x, y in zip(a_lis, b_lis)],
    "producto con array": lambda: a_arr * b_arr,
}

for nombre, f in pruebas.items():
    # 7 repeticiones de 10 ejecuciones; se guarda la mejor, en milisegundos
    t = timeit.repeat(f, number=10, repeat=7)
    print(nombre, round(min(t) / 10 * 1000, 2), "ms")

# Comprobación: los dos caminos dan el mismo resultado
print(abs(sum(a_lis) - a_arr.sum()) < 1e-6)
print(np.allclose([x * y for x, y in zip(a_lis, b_lis)], a_arr * b_arr))

Corrí el programa cuatro veces en mi computador, con Windows 11, Python 3.13.13 y NumPy 2.5.4. La tabla muestra el rango del mejor tiempo de cada corrida. La comprobación del final dio verdadero en todas: los dos caminos llegan al mismo resultado.

Tarea (un millón de números)	Lista de Python	Array de NumPy
Sumar todos los elementos	8,86 a 9,72 ms	0,48 a 0,71 ms
Multiplicar elemento a elemento	88,61 a 92,67 ms	2,58 a 2,78 ms

Leo esta tabla con cuidado: son mis tiempos, en mi máquina y con estas versiones. En otro equipo los números cambian, y por eso no saco de aquí un factor de aceleración general. Lo que sí se ve es la dirección. Y en mis corridas, la distancia fue mayor en la multiplicación elemento a elemento que en la suma.

¿Cómo se crea un array de NumPy?

Un array se crea a partir de una lista de Python o con funciones que lo llenan solas. Por una convención muy extendida, NumPy se importa con el nombre corto np [4]. Estas son cinco de las funciones de creación que presenta la guía oficial para principiantes [4]:

Función	Qué crea	Ejemplo y resultado
np.array	Un array a partir de una lista	np.array([3, 1, 4]) da [3 1 4]
np.zeros	Un array lleno de ceros, con la forma que se pida	np.zeros((2, 3)) da 2 filas y 3 columnas de ceros
np.ones	Un array lleno de unos	np.ones(4) da [1. 1. 1. 1.]
np.arange	Números desde un inicio hasta antes de un final, con un paso	np.arange(0, 10, 2) da [0 2 4 6 8]
np.linspace	Una cantidad dada de números igualmente espaciados en un intervalo	np.linspace(0, 1, 5) da [0. 0.25 0.5 0.75 1.]

Todo array trae atributos, datos que describen al propio array. Los tres básicos son shape, la forma (cuántos elementos hay en cada dimensión); ndim, el número de dimensiones; y dtype, el tipo de dato [4].

import numpy as np

a = np.array([3, 1, 4, 1, 5])      # desde una lista de Python
ceros = np.zeros((2, 3))           # 2 filas y 3 columnas de ceros
pares = np.arange(0, 10, 2)        # de 0 a 10 (sin incluirlo), de 2 en 2
puntos = np.linspace(0, 1, 5)      # 5 valores igualmente espaciados entre 0 y 1

print(a.dtype, a.shape, a.ndim)              # int64 (5,) 1
print(ceros.dtype, ceros.shape, ceros.ndim)  # float64 (2, 3) 2
print(pares)                                 # [0 2 4 6 8]
print(puntos)                                # [0.   0.25 0.5  0.75 1.  ]

Fíjese en el tipo. Los enteros salieron como int64, enteros de 64 bits, y los ceros como float64, decimales de 64 bits. Si no se le indica otra cosa, NumPy usa decimales de ese tamaño por defecto al llenar con ceros [4].

Indexación y rebanado: ¿vista o copia?

Indexar es tomar un elemento por su posición, y rebanar es tomar un tramo con la notación de dos puntos, como x[2:5]. NumPy cuenta desde cero, igual que Python [4]. La diferencia importante con la lista está en lo que devuelve el rebanado.

En una lista, rebanar copia los elementos a una lista nueva. En un array, el rebanado básico devuelve una vista: un objeto que mira los mismos datos del array original [4][5]. Si se cambia la vista, cambia el original. Una copia, en cambio, duplica los datos, y lo que se le haga no toca el array de origen [5].

La documentación reconoce el doble filo. La vista ahorra tiempo y memoria, pero puede causar problemas si quien programa no sabe cómo funciona [5]. Lo comprobé con np.shares_memory, una función que responde si dos arrays comparten memoria:

import numpy as np

x = np.arange(10)                 # [0 1 2 3 4 5 6 7 8 9]
rebanada = x[2:5]                 # rebanado básico: una VISTA
rebanada[0] = 99                  # cambiar la vista...
print(x)                          # [ 0  1 99  3  4  5  6  7  8  9]: cambió el original
print(np.shares_memory(x, rebanada))    # True

copia = x[2:5].copy()             # copia explícita
copia[0] = -1
print(x[2], np.shares_memory(x, copia))  # 99 False: el original no se tocó

# Indexación booleana: filtra con una condición y devuelve una COPIA
mayores = x[x > 5]
print(mayores, np.shares_memory(x, mayores))  # [99  6  7  8  9] False

# La lista de Python copia al rebanar
lista = list(range(10))
trozo = lista[2:5]
trozo[0] = 99
print(lista[2])                   # 2: la lista original sigue igual

La última parte del ejemplo usa indexación booleana. Se escribe una condición, como x > 5, que produce un array de verdaderos y falsos, y con él se seleccionan solo los elementos que la cumplen [6]. Es la forma más directa de filtrar datos en NumPy. Pertenece a la indexación avanzada, y la indexación avanzada siempre devuelve una copia [5][6].

La regla práctica: si va a modificar un tramo y no quiere tocar el original, use .copy().

Broadcasting: cómo opera NumPy con arrays de formas distintas

El broadcasting, que se podría traducir como difusión, es la regla con que NumPy opera dos arrays de formas distintas. El caso más simple es sumar un número a un array: el número se aplica a cada elemento [7]. El mismo mecanismo permite, por ejemplo, sumarle una fila a cada fila de una tabla.

NumPy no copia de verdad el array pequeño para hacerlo. Según el artículo de Nature, uno o ambos arrays se duplican de manera virtual, sin copiar datos en memoria, hasta que las formas coinciden [1].

La documentación oficial da la regla de compatibilidad así [7]:

1. NumPy compara las formas de los dos arrays dimensión por dimensión, empezando por la última, la de más a la derecha, y avanzando hacia la izquierda.
2. Dos dimensiones son compatibles si son iguales o si una de ellas vale 1.
3. Si a un array le faltan dimensiones, se asume que valen 1.
4. Si alguna pareja no cumple, NumPy lanza un error del tipo ValueError que dice que los operandos no se pudieron combinar.

Un ejemplo mínimo, con una tabla de 2 filas y 3 columnas:

import numpy as np

m = np.array([[1, 2, 3],
              [4, 5, 6]])          # forma (2, 3)
fila = np.array([10, 20, 30])      # forma (3,): encaja con la última dimensión
print(m + fila)                    # [[11 22 33]
                                   #  [14 25 36]]

columna = np.array([[100], [200]]) # forma (2, 1): el 1 se estira a 3
print(m + columna)                 # [[101 102 103]
                                   #  [204 205 206]]

try:
    m + np.array([1, 2])           # forma (2,): 2 no encaja con 3
except ValueError as e:
    print("ValueError:", e)
# ValueError: operands could not be broadcast together with shapes (2,3) (2,)

El último caso es el error más común al empezar. Un array de 2 elementos no encaja con las 3 columnas, aunque la tabla tenga 2 filas, porque la comparación arranca por la derecha. Si lo que quería era sumar un valor por fila, la salida es darle forma de columna, como en el segundo caso.

Operaciones elemento a elemento, agregaciones y el parámetro axis

Las operaciones elemento a elemento actúan sobre cada casilla por separado y devuelven un array de la misma forma. Así funcionan la suma, la resta, la multiplicación y funciones como np.sqrt, la raíz cuadrada [1][3]. Las agregaciones, en cambio, resumen muchos valores en menos: sum suma, mean promedia y max busca el máximo [1].

Aquí aparece la confusión más frecuente de NumPy: el parámetro axis, el eje. Un array de dos dimensiones tiene dos ejes. El primer índice, el eje 0, cuenta las filas; el segundo, el eje 1, cuenta las columnas [4]. Si no se indica eje, la suma toma todos los elementos [8].

La forma más segura de recordarlo: el eje que usted nombra es el que desaparece. Con la tabla m = [[1, 2, 3], [4, 5, 6]]:

Instrucción	Qué hace	Resultado
m.sum()	Suma todos los elementos	21
m.sum(axis=0)	Colapsa las filas: un total por columna	[5 7 9]
m.sum(axis=1)	Colapsa las columnas: un total por fila	[ 6 15]
m.mean(axis=0)	Promedio de cada columna	[2.5 3.5 4.5]

Lo comprobé ejecutando cada instrucción. El artículo de Nature lo dice de forma general: sumar un array de n dimensiones sobre d de sus ejes deja un array de n menos d dimensiones [1].

Un ejemplo con precios: una canasta simulada

Aviso antes de empezar: los precios de este ejemplo son inventados. No vienen del DANE, el Departamento Administrativo Nacional de Estadística, ni de ningún mercado real. Sirven para ver la vectorización y el broadcasting en un problema conocido en cualquier hogar colombiano: cuánto cuesta la misma compra mes a mes.

La tabla tiene 4 meses en las filas y 3 productos en las columnas. La canasta dice cuántas unidades se compran de cada producto al mes.

import numpy as np

# DATOS SINTÉTICOS: precios inventados, en pesos por unidad.
# Columnas: arroz, huevos, papa. Filas: meses 1 a 4.
precios = np.array([
    [4200, 650, 2100],
    [4250, 670, 2300],
    [4300, 700, 2250],
    [4400, 690, 2400],
])                                   # forma (4, 3)
cantidades = np.array([2, 30, 5])    # canasta inventada: unidades por mes

# 1. Índice de cada precio frente al mes 1 (broadcasting: (4, 3) entre (3,))
indice = precios / precios[0] * 100
print(np.round(indice, 1))
# [[100.  100.  100. ]
#  [101.2 103.1 109.5]
#  [102.4 107.7 107.1]
#  [104.8 106.2 114.3]]

# 2. Costo de la canasta cada mes, sin un solo bucle
costo = (precios * cantidades).sum(axis=1)
print(costo)                         # [38400 40100 40850 41500]

# 3. Variación porcentual del costo de un mes al siguiente
print(np.round(np.diff(costo) / costo[:-1] * 100, 2))   # [4.43 1.87 1.59]

Tres líneas hacen todo el trabajo. En la primera, precios[0], la fila del mes 1, tiene forma (3,) y se aplica a las cuatro filas por broadcasting. En la segunda, las cantidades multiplican cada fila, y axis=1 suma a lo largo de los productos para dejar un total por mes. La tercera usa np.diff, que resta cada valor del siguiente.

Con datos reales, la misma lógica sirve para revisar cuánto cambia el costo de una lista de compras. Eso sí, un índice oficial de precios sigue una metodología propia que esta cuenta de juguete no reproduce.

Números aleatorios con NumPy: default_rng y la semilla

El módulo numpy.random produce números pseudoaleatorios: secuencias que parecen al azar, pero que salen de un cálculo determinista [9]. Sirven para simular, tomar muestras y probar un análisis con datos de ensayo. La forma recomendada es crear un generador con np.random.default_rng y pedirle los números a ese generador [9].

La semilla es el número con que arranca la secuencia. Con la misma semilla, el generador entrega siempre los mismos números; sin semilla, toma datos impredecibles del sistema operativo y cambia en cada corrida [9]. Esa es la base de la reproducibilidad: otra persona puede volver a correr su simulación y obtener lo mismo.

import numpy as np

rng = np.random.default_rng(20261111)       # semilla fija
print(rng.integers(1, 7, size=5))           # cinco lanzamientos de un dado: [6 3 2 6 6]
print(np.round(rng.normal(0, 1, size=3), 4))  # tres valores de una normal estándar

rng2 = np.random.default_rng(20261111)      # la misma semilla...
print(rng2.integers(1, 7, size=5))          # ...da los mismos números: [6 3 2 6 6]

En código viejo y en muchos tutoriales verá np.random.seed. Es el estilo heredado, que funciona sobre la clase RandomState. La documentación la considera congelada: no recibirá mejoras y solo conviene si hace falta repetir exactamente los números de versiones antiguas [10]. El generador nuevo llegó en NumPy 1.17.0, y el proyecto recomienda pasarse a él cuando se pueda [9].

Una advertencia de la propia documentación: estos generadores están hechos para modelos estadísticos y simulación, no para seguridad ni criptografía [9]. Para una contraseña o un código de acceso se usa el módulo secrets de Python.

Álgebra lineal con NumPy: lo justo para empezar

El álgebra lineal es la parte de las matemáticas que trabaja con vectores, matrices y sistemas de ecuaciones. NumPy trae lo básico en su submódulo numpy.linalg [12]. Para un analista, dos herramientas bastan al principio: el producto matricial y la solución de un sistema de ecuaciones.

El producto matricial se escribe con el operador @, que existe desde NumPy 1.10.0 y que la documentación prefiere frente a otros métodos para multiplicar arrays de dos dimensiones [12]. Ojo: A * B multiplica elemento a elemento, y A @ B hace el producto de matrices. No es lo mismo.

np.linalg.solve resuelve un sistema de ecuaciones lineales con tantas ecuaciones como incógnitas, siempre que tenga una solución única [13]:

import numpy as np

# Sistema: 2x + y = 5  y  x + 3y = 10
A = np.array([[2, 1],
              [1, 3]])
b = np.array([5, 10])
x = np.linalg.solve(A, b)
print(x)                     # [1. 3.]  -> x = 1, y = 3
print(np.allclose(A @ x, b)) # True: al multiplicar se recupera b

Por debajo, estas funciones se apoyan en bibliotecas especializadas de álgebra lineal, que pueden venir con NumPy o estar optimizadas para el procesador de cada equipo [12]. La matemática que hay detrás, en cambio, ya es otro tema: la encuentra en la guía de estadística para análisis de datos.

SciPy: el escalón siguiente a NumPy

SciPy es una librería gratuita de Python construida sobre NumPy para el cálculo científico [14][15]. Su sitio la presenta como «algoritmos fundamentales para el cálculo científico en Python», y enumera problemas que cubre: optimización, integración, interpolación, ecuaciones diferenciales y estadística, entre otros [14].

La relación es de escalera. NumPy pone el array y las operaciones básicas; SciPy añade algoritmos especializados que trabajan sobre ese array. Se organiza en subpaquetes por área, como scipy.stats para estadística, scipy.optimize para optimización y scipy.linalg para álgebra lineal [15].

Ese último amplía al de NumPy. Según la documentación de NumPy, scipy.linalg contiene funciones que no están en numpy.linalg [12]. Un ejemplo son las de la descomposición LU, una forma de partir una matriz en dos más simples [12]. La versión más reciente que anuncia su sitio es SciPy 1.18.1, del 21 de agosto de 2026, y se distribuye con licencia BSD [14].

Mi recomendación es no saltar a SciPy antes de tiempo. Cuando NumPy le quede corto para un problema concreto, ese es el momento.

NumPy frente a las herramientas vecinas

NumPy no es la herramienta para todo, y conviene saber dónde termina. La pregunta «NumPy o pandas» se responde rápido: NumPy calcula con arrays de un solo tipo de dato, y pandas, otra librería construida sobre él, maneja tablas cuyas columnas pueden tener tipos distintos [16]. Hacer gráficos con estos arrays e instalar las librerías en su equipo son temas aparte.

Si lo que busca es entrenar modelos que aprenden de los datos, el paso siguiente es el machine learning, con la base de arrays que vio aquí.

Lo que dejó la división entre Numeric y Numarray

Vuelvo a 2005. Los propios autores de NumPy escriben que la división entre Numeric y Numarray partió a la comunidad [2]. También dicen que, al final, empujó el avance más lejos y más rápido de lo que habría sido posible sin ella [2]. Agregan que hoy es mucho más difícil que una nueva librería de arrays fracture a la comunidad, por todo el trabajo que ya se apoya en NumPy [1].

Va mi opinión, sin rodeos. Quien salta directo a las tablas de pandas tarde o temprano se pregunta por qué un filtro le cambió los datos originales, o por qué una suma salió por filas. Son preguntas de NumPy. Una tarde con vistas, broadcasting y axis ahorra semanas de errores silenciosos.

Y hay un argumento de acceso. NumPy no cobra licencia, y la prueba de velocidad de esta página la puede repetir cualquiera con el mismo código. Para una universidad regional o una oficina de estadística municipal con poco presupuesto, eso significa trabajar sobre la misma base sobre la que se apoyan casi todas las librerías de cálculo científico de Python [1].

Preguntas frecuentes

¿NumPy es gratis? Sí. NumPy es software libre con licencia BSD: se puede usar y redistribuir, con o sin modificaciones [3]. La condición es respetar la licencia, por ejemplo conservando el aviso de derechos de autor [3]. No hay que pagar por él. Lo que sí cuesta es el tiempo de aprendizaje y un computador donde correr Python.

¿Qué versión de Python necesito para NumPy? Depende de la versión de NumPy. La 2.5.4, la más reciente en el índice oficial de paquetes al momento de esta revisión, pide Python 3.12 o superior [11]. Con una versión anterior de Python tendrá que usar una versión de NumPy más vieja, que la admita. Revise siempre las dos versiones antes de comparar resultados con otra persona.

¿Por qué mi array cambió si yo modifiqué otra variable? Casi siempre es una vista. Al rebanar un array con dos puntos, NumPy no crea datos nuevos: la nueva variable mira la misma memoria que la original [5]. Por eso, al modificar una, cambia la otra. Para trabajar sobre un tramo sin tocar el array de origen, haga una copia explícita con el método copy. Si tiene dudas, la función shares_memory se lo confirma.

¿Qué significa el error «operands could not be broadcast together»? Significa que las formas de los dos arrays no son compatibles para operar. NumPy compara las dimensiones desde la derecha, y cada pareja debe ser igual o tener un 1 [7]. Imprima la forma de cada array con el atributo shape y compárelas. A menudo la solución es convertir un vector en columna, con forma de n filas por 1 columna.

¿Para qué sirve la semilla en los números aleatorios? La semilla fija el punto de partida del generador, así que con la misma semilla se obtienen los mismos números en cada corrida [9]. Sirve para que una simulación o una muestra se pueda repetir y revisar. Sin semilla, el generador toma datos del sistema operativo y cada ejecución da resultados distintos.

Referencias

Las citas en otro idioma son traducción propia.

1. Harris, Charles R.; Millman, K. Jarrod; van der Walt, Stéfan J. et al. Array programming with NumPy, Nature, vol. 585, 2020, pp. 357-362 — Numeric nació a mediados de los noventa y una de sus primeras aplicaciones fue manejar aplicaciones en C++ para investigación en fusión por confinamiento inercial en el Lawrence Livermore National Laboratory; Numarray, una reimplementación de Numeric, nació para manejar las grandes imágenes astronómicas del telescopio Hubble; las diferencias entre ambos «divided the community» hasta que en 2005 NumPy surgió como una unificación «best of both worlds»; casi toda librería de Python de cálculo científico o numérico se apoya en NumPy; «An array has a single data type, and each element of an array occupies the same number of bytes in memory»; metadatos de tipo, forma y pasos (strides); «Vectorization—operating on entire arrays rather than their individual elements—is essential to array programming»; lo que en C tomaría muchas decenas de líneas a menudo cabe en una sola expresión de Python; en el broadcasting los arrays se duplican de forma virtual, sin copiar datos; las reducciones (sum, mean, maximum) agregan a lo largo de uno, varios o todos los ejes; sumar un array de n dimensiones sobre d ejes deja uno de n menos d dimensiones; es más difícil que nuevas librerías fracturen a la comunidad dado el trabajo que se apoya en NumPy. Nature: Array programming with NumPy, DOI 10.1038/s41586-020-2649-2 · PubMed Central: texto completo abierto — Consultada: 2026-11-11.
2. Harris, Charles R. et al. Array Programming with NumPy, versión preliminar en arXiv (2006.10256v1, 18 de junio de 2020), sección de agradecimientos — «Jim Hugunin wrote Numeric in 1995, while a graduate student at MIT»; el Space Telescope Science Institute empezó a usar Python en 1998 y en 2000 comenzó a desarrollar Numarray; «The Numeric/Numarray split divided the community, yet ultimately pushed progress much further and faster than would otherwise have been possible»; poco después del inicio de Numarray, T. E. Oliphant asumió el mantenimiento de Numeric y en 2005 «led the effort and did most of the work to unify Numeric and Numarray, and produce the first version of NumPy». arXiv: Array Programming with NumPy, 2006.10256 — Consultada: 2026-11-11.
3. NumPy Developers. What is NumPy?, manual de NumPy 2.5 — el ndarray encapsula arreglos de n dimensiones de tipos de datos homogéneos; los arrays tienen tamaño fijo al crearse, a diferencia de las listas; las operaciones sobre grandes cantidades de datos «typically» se ejecutan con más eficiencia y menos código que con las secuencias de Python; con listas hay que pagar el precio de los bucles en Python cuando hay millones de números; «c = a * b» opera «at near-C speeds»; la vectorización ocurre «behind the scenes» en código C precompilado; vectorización y broadcasting son la base de su potencia. Portada: «Distributed under a liberal BSD license». Licencia: «Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met», entre ellas conservar el aviso de copyright. NumPy: What is NumPy? · NumPy: portada del proyecto · NumPy: License — Consultada: 2026-11-11.
4. NumPy Developers. NumPy: the absolute basics for beginners, manual de NumPy 2.5 — las listas de Python son contenedores de uso general, pueden ser «heterogeneous» y son bastante rápidas con unos pocos elementos; «NumPy shines when there are large quantities of “homogeneous” (same-type) data to be processed on the CPU»; el ndarray como arreglo de N dimensiones (fila, tabla, tablas apiladas como páginas); restricciones: un solo tipo de dato, tamaño fijo, forma rectangular, a cambio de un array más rápido, más eficiente en memoria y más cómodo; índice desde 0; rebanar una lista copia y rebanar un array devuelve una vista; atributos ndim, shape, size y dtype; funciones array, zeros, ones, empty, arange y linspace; el tipo por defecto es float64; dimensiones llamadas «axis»; en a[1, 3] el elemento está en la fila 1 y la columna 3; «import numpy as np» es una «widespread convention». NumPy: the absolute basics for beginners — Consultada: 2026-11-11.
5. NumPy Developers. Copies and views (NumPy fundamentals), manual de NumPy 2.5 — el array tiene dos partes, «the contiguous data buffer with the actual data elements and the metadata»; una vista comparte el búfer de datos y sus cambios se reflejan en el original; una copia duplica búfer y metadatos, es más lenta y consume memoria; la vista da buen rendimiento pero puede causar problemas si el usuario no sabe cómo funciona; «basic indexing always creates views»; «Advanced indexing, on the other hand, always creates copies». NumPy: Copies and views · NumPy: NumPy fundamentals — Consultada: 2026-11-11.
6. NumPy Developers. Indexing on ndarrays, manual de NumPy 2.5 — la indexación booleana es indexación avanzada que ocurre cuando el índice es un array de tipo booleano, como el que devuelven los operadores de comparación; «Advanced indexing always returns a copy of the data». NumPy: Indexing on ndarrays — Consultada: 2026-11-11.
7. NumPy Developers. Broadcasting, manual de NumPy 2.5 — al operar dos arrays, NumPy compara sus formas elemento a elemento, empezando por la dimensión de más a la derecha; dos dimensiones son compatibles si son iguales o si una vale 1; si no se cumple, se lanza «ValueError: operands could not be broadcast together»; las dimensiones faltantes se asumen de tamaño uno; el caso más simple es combinar un array y un escalar. NumPy: Broadcasting — Consultada: 2026-11-11.
8. NumPy Developers. numpy.sum, manual de NumPy 2.5 — el parámetro axis indica el eje o ejes sobre los que se suma; con el valor por defecto, axis=None, se suman todos los elementos. NumPy: numpy.sum — Consultada: 2026-11-11.
9. NumPy Developers. Random sampling, manual de NumPy 2.5 — numpy.random implementa generadores de números pseudoaleatorios; en general se crea un Generator con default_rng; «Our RNGs are deterministic sequences and can be reproduced by specifying a seed integer»; sin semilla, default_rng toma datos no deterministas del sistema operativo y genera números distintos cada vez; no son adecuados para seguridad o criptografía (usar secrets); Generator se introdujo en NumPy 1.17.0 y se recomienda la transición desde RandomState. NumPy: Random sampling — Consultada: 2026-11-11.
10. NumPy Developers. Legacy random generation, manual de NumPy 2.5 — RandomState «is considered frozen and will have no further improvements»; solo debe usarse si es esencial reproducir valores de versiones anteriores de NumPy; numpy.random.seed figura entre las funciones heredadas. NumPy: Legacy random generation — Consultada: 2026-11-11.
11. Python Package Index (PyPI). numpy — versión 2.5.4, publicada el 2026-10-10; requiere Python 3.12 o superior. PyPI: numpy — Consultada: 2026-11-11.
12. NumPy Developers. Linear algebra (numpy.linalg), manual de NumPy 2.5 — las funciones de álgebra lineal se apoyan en BLAS y LAPACK, que NumPy puede traer en versiones de referencia o que pueden ser bibliotecas optimizadas para el procesador; el operador @, introducido en NumPy 1.10.0, es preferible para el producto matricial entre arrays de dos dimensiones; scipy.linalg contiene funciones que no están en numpy.linalg, como las relacionadas con la descomposición LU. NumPy: Linear algebra — Consultada: 2026-11-11.
13. NumPy Developers. numpy.linalg.solve, manual de NumPy 2.5 — resuelve una ecuación matricial lineal o un sistema de ecuaciones escalares lineales; calcula la solución «exact» de la ecuación ax = b bien determinada, es decir, de rango completo. NumPy: numpy.linalg.solve — Consultada: 2026-11-11.
14. SciPy Developers. Portada del proyecto — «Fundamental algorithms for scientific computing in Python»; algoritmos para optimización, integración, interpolación, problemas de valores propios, ecuaciones algebraicas y diferenciales, estadística y otros; «Extends NumPy providing additional tools for array computing»; licencia BSD; «SciPy 1.18.1 released!», 2026-08-21. SciPy: portada — Consultada: 2026-11-11.
15. SciPy Developers. SciPy User Guide, manual de SciPy 1.18.0 — «SciPy is a collection of mathematical algorithms and convenience functions built on NumPy»; se organiza en subpaquetes por dominio, entre ellos stats, optimize y linalg. SciPy: User Guide — Consultada: 2026-11-11.
16. pandas development team. Package overview, documentación de pandas 3.1.1 — pandas sirve para «Tabular data with heterogeneously-typed columns»; «pandas is built on top of NumPy and is intended to integrate well within a scientific computing environment». pandas: Package overview — Consultada: 2026-11-11.

Cómo investigamos esta página

• Pregunta que responde: qué resuelve NumPy frente a la lista de Python y cómo se usan sus arrays en análisis de datos
• Fuentes: identificadas 26 → incluidas 20
• Criterios de inclusión: documentación oficial de NumPy, SciPy, pandas y PyPI, y Harris et al. 2020, leídos en texto crudo
• Fecha de corte de los datos: 2026-11-11