Arreglos de NumPy y computación vectorizada

NumPy almacena datos numéricos en arreglos para que una expresión pueda operar sobre muchos valores. Impórtalo con import numpy as np; el nombre corto np es la forma habitual de llamar a sus funciones.

Interpreta la estructura de un arreglo

Un arreglo multidimensional es una cuadrícula rectangular cuyos elementos comparten un mismo tipo de datos. Una dimensión también se llama eje. Comienza con una tabla pequeña:

import numpy as np
a = np.array([[1, 2, 3], [4, 5, 6]])

Sus atributos responden a cuatro preguntas distintas:

El eje 0 indexa las filas; el eje 1 indexa las columnas. Una tabla de datos con una fila por persona y columnas de altura, masa y edad tendría la forma (100, 3) para 100 personas. El producto de las dimensiones de la forma da el tamaño.

Un vector no tiene eje de filas ni de columnas

np.array([2, 4, 6, 8]) tiene forma (4,) y un eje. La coma indica que es una tupla de un solo elemento. La forma (1, 4) tiene dos ejes: una fila y cuatro columnas. La forma (4, 1) también tiene dos ejes, pero cuatro filas y una columna. Estos arreglos contienen cuatro valores, pero se comportan de forma distinta al combinarlos con otros arreglos. np.array(7) es un arreglo de dimensión cero: su forma es () y su ndim es 0.

Los arreglos cambian el significado de los operadores

Una lista es un contenedor de uso general de Python. Un arreglo está diseñado para realizar cálculos en posiciones correspondientes.

En la suma de arreglos, 1 se empareja con 3 y 2 se empareja con 4. El arreglo mantiene el mismo tamaño.

Por qué son eficientes los arreglos numéricos

Un arreglo numérico recién creado almacena juntos en memoria valores del mismo tipo. NumPy ejecuta el bucle sobre estos valores en código compilado y evita una operación independiente al nivel de Python para cada número. Un millón de valores float64 ocupa 8 000 000 de bytes de almacenamiento de elementos, que se pueden consultar como a.nbytes en un arreglo de ese tamaño. Una lista de Python también almacena referencias a objetos de Python, por lo que necesita bastante más espacio. Las mejoras de rendimiento dependen del cálculo y de la computadora.

El tamaño de un arreglo no aumenta mediante un método append in situ. np.append(a, value) reserva un arreglo nuevo. Para datos recogidos un valor a la vez, crea una lista de Python y conviértela una sola vez. Los datos de entrada anidados deben ser rectangulares: np.array([[1, 2], [3]]) genera ValueError porque las longitudes de sus filas son distintas.

Reconoce los resultados mostrados

print(np.array([1, 2, 3])) muestra [1 2 3]. Una visualización interactiva usa array([1, 2, 3]). Para np.array([5, 6])[0] en una computadora de 64 bits, NumPy 2 muestra np.int64(5); este valor participa en operaciones aritméticas como el número 5.

Elige una función de creación preguntándote qué conoces: los valores concretos, una forma y un valor de relleno, un paso o un número de puntos necesario. Esa elección permite que el código exprese cómo deben construirse los datos.

Parte de valores o de una forma

np.array([3, 1, 4]) crea un vector. Una lista de listas de igual longitud crea una tabla. Pasa los valores como una sola secuencia; np.array(1, 2, 3) no proporciona correctamente tres elementos.

Para una forma multidimensional, los paréntesis importan. np.zeros((2, 3)) pasa una sola tupla. En np.zeros(2, 3), Python envía 3 como argumento del tipo de datos, lo que provoca un error de tipo. Los ceros y unos usan float64 de forma predeterminada; full infiere su tipo de datos a partir del valor de relleno. Añade dtype=int cuando necesites almacenar números enteros.

empty no garantiza ceros ni valores iniciales significativos. Lee sus valores solo después de asignar todos los elementos que vayas a utilizar. zeros es una opción más sencilla cuando un cero inicial tiene significado.

Elige un paso o un número de puntos

np.arange(start, stop, step) sigue la idea de los pasos de range de Python. np.arange(2, 11, 3) da [2 5 8]: comienza en 2 y suma 3 mientras permanezca por debajo de 11. Con un argumento, np.arange(5) comienza en 0 y da [0 1 2 3 4].

Los pasos de coma flotante pueden producir extremos inesperados. Por ejemplo, np.arange(1, 1.3, 0.1) incluye el valor mostrado 1,3 porque el redondeo binario afecta al cálculo de la secuencia. Para una cuadrícula decimal con un número fijo de puntos, utiliza linspace:

grid = np.linspace(0, 1, 5)
# array([0.  , 0.25, 0.5 , 0.75, 1.  ])

Ambos extremos se incluyen de forma predeterminada. Cinco puntos forman cuatro intervalos. Diez puntos entre 0 y 1 forman nueve intervalos, por lo que su espaciado es aproximadamente 0,111; los pasos de 0,1 necesitan 11 puntos.

Reutiliza una estructura existente

np.zeros_like(a), np.ones_like(a) y np.full_like(a, value) crean arreglos nuevos con la forma y el tipo de datos de a. El tipo heredado importa: rellenar una plantilla de enteros con un decimal puede hacer que se pierda la parte decimal, salvo que solicites un tipo de coma flotante. np.eye(3) crea una matriz identidad cuadrada con unos en la diagonal y ceros en las demás posiciones.

Reserva una tabla de datos una sola vez

Para la lluvia en milímetros en tres estaciones durante cuatro semanas:

rain = np.zeros((3, 4))
rain[0] = [12.0, 0.0, 5.5, 8.0]

La primera asignación rellena una fila y conserva la forma (3, 4). Si se conoce el número de mediciones, reservar la tabla completa evita reservar repetidamente arreglos más grandes. Si se desconoce la cantidad de datos de entrada, acumula los valores en una lista y llama a np.array cuando termine la recogida.

El tipo de datos de un arreglo controla qué puede almacenar y cuánta memoria necesita cada valor. Elegir el tipo adecuado también evita que los cálculos pierdan información sin aviso.

Inspecciona el tipo de almacenamiento

int64 almacena números enteros de 64 bits, float64 almacena números binarios de coma flotante y bool almacena valores de verdadero o falso. Los tipos Unicode como <U5 almacenan texto con una longitud máxima de caracteres. a.itemsize son los bytes por elemento; a.nbytes es a.size * a.itemsize. Un float64 usa 8 bytes y tiene una precisión de unas 15 cifras decimales significativas.

En las computadoras típicas de 64 bits, los datos enteros utilizan enteros de 64 bits. NumPy 2 también usa ese valor predeterminado en Windows de 64 bits. Los datos decimales normalmente dan float64.

La inferencia elige un tipo compartido

np.array([1, 2.5]) se convierte en [1. 2.5]: el entero se representa como un número de coma flotante. np.array([True, 2]) se convierte en [1 2]. Mezclar números y texto puede convertir todo el arreglo en texto, por lo que una etiqueta como 'n/a' puede hacer que fallen las operaciones aritméticas posteriores. Inspecciona dtype cuando unos datos aparentemente numéricos no se puedan sumar o multiplicar.

Convierte de forma deliberada

astype devuelve una copia convertida:

x = np.array([1.7, -1.7, 2.5])
whole = x.astype(int)
# array([ 1, -1,  2])

Esta conversión trunca hacia cero; no redondea. np.round(x).astype(int) da [2 -2 2] porque los valores exactamente a mitad de camino se redondean al valor par más cercano. Un texto como '1.5' se convierte con astype(float), pero 'n/a' genera ValueError. Limpia los marcadores antes de la conversión.

Las asignaciones usan el tipo de datos del destino. Después de a = np.array([1, 2, 3]), asignar a[0] = 9.9 almacena 9 sin advertencia. Convertir primero todo el arreglo a coma flotante permite que las asignaciones posteriores conserven los decimales.

Los enteros de ancho fijo pueden desbordarse

Un int8 almacena valores de −128 a 127; un uint8 almacena de 0 a 255. Sumar dos arreglos uint8 que contienen 250 y 10 produce 4 al volver al otro extremo del intervalo. Multiplicar por 2 un arreglo int8 que contiene 100 produce −56. En cambio, un entero de Python que no cabe en el tipo del arreglo, como 300 sumado a un arreglo int8 en NumPy 2, genera OverflowError. Amplía los tipos enteros pequeños antes de realizar cálculos que puedan superar su intervalo.

División y decimales aproximados

La división por suelo redondea hacia abajo, en dirección al infinito negativo, lo que difiere del truncamiento para resultados negativos. La división verdadera devuelve resultados de coma flotante para entradas enteras.

Muchas fracciones decimales son aproximaciones en binario. 0.1 + 0.2 == 0.3 es falso; np.isclose compara valores correspondientes con una tolerancia y np.allclose da una respuesta para el arreglo completo.

El marcador de valor faltante np.nan es de coma flotante. Los arreglos de enteros no pueden almacenarlo. Por tanto, np.array([1, 2, np.nan]) se convierte en un arreglo de coma flotante; convertir valores faltantes a enteros no los corrige y puede producir resultados sin significado.

La indexación localiza valores por posición. La selección de segmentos elige una secuencia regular de posiciones. En una tabla, escribe un selector para cada eje, de modo que el código indique tanto las filas como las columnas que necesitas.

Lee un vector

Para a = np.array([10, 20, 30, 40, 50]), la posición 0 contiene 10 y la posición −1 contiene 50. Un segmento tiene la forma start:stop:step, con el extremo final excluido:

Omitir el inicio o el final extiende el segmento hasta el extremo correspondiente. Un segmento puede sobrepasar el arreglo y recortarse automáticamente. Una posición individual no válida, como a[5], genera IndexError.

Asigna a cada eje de la tabla su propio selector

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

m[1, 2] lee la fila 1, columna 2, y da 6. La coma separa los ejes. Dos puntos por sí solos seleccionan el eje completo: m[0, :] da la primera fila [1 2 3], y m[:, 1] da la segunda columna [2 5 8]. Para obtener un bloque, m[:2, 1:] selecciona las filas 0 y 1 y las columnas 1 y 2, y da [[2 3] [5 6]].

No consideres intercambiables la indexación con corchetes repetidos y la indexación con comas. m[1][2] localiza el mismo escalar que m[1, 2]. Pero m[:][0] toma primero todas las filas y después selecciona la primera fila. No selecciona la primera columna, que es m[:, 0].

Predice qué ejes permanecen

Un selector entero individual elimina su eje. Un segmento conserva su eje incluso cuando solo se selecciona una posición. Por tanto, m[:, 1] tiene forma (3,), mientras que m[:, 1:2] tiene forma (3, 1). Ambos seleccionan 2, 5 y 8, pero solo el segundo conserva un eje de columna. Esta diferencia importa al restar o multiplicar arreglos con otras formas.

La misma regla se extiende más allá de las tablas. Si t.shape es (2, 3, 4), t[0] tiene forma (3, 4), t[0, 1] tiene forma (4,) y t[:, :, 0] tiene forma (2, 3). Los ejes finales omitidos en el índice se seleccionan por completo.

Modifica las posiciones seleccionadas

La asignación mediante un índice escribe en el arreglo existente. a[1:3] = 0 sustituye ambos valores seleccionados por cero; el escalar se aplica a toda la selección. m[0] = [0, 0, 0] sustituye una fila completa. Los valores asignados deben ajustarse a la forma de la selección y se convierten a su tipo de datos.

Para cuatro estudiantes y tres pruebas:

scores = np.array([[78, 85, 92], [64, 70, 58],
                   [88, 91, 95], [72, 68, 80]])

scores[2] es el resultado [88 91 95] del tercer estudiante. scores[:, -1] da los resultados de la última prueba [92 58 95 80]. scores[1:3, :2] da [[64 70] [88 91]]: dos estudiantes, cada uno con dos columnas de pruebas.

Una selección puede compartir sus datos con el arreglo original o tener datos independientes. Saber cuál de las dos tienes evita que las modificaciones de una selección pequeña cambien inesperadamente una tabla más grande.

Distingue una referencia compartida, una vista y una copia

Para a = np.arange(6) y b = a[2:5], asignar b[0] = 99 hace que a sea igual a [0 1 99 3 4 5]. La primera posición de la vista se refiere a la posición 2 del original. Esto difiere de seleccionar un segmento de una lista de Python, que crea una lista nueva.

Copia antes de editar cuando el original deba permanecer intacto. Una vista pequeña que se conserva también puede mantener en memoria un bloque grande de datos originales; copiar esa pequeña parte permite que sea independiente.

Selecciona posiciones arbitrarias

La indexación avanzada utiliza una lista o un arreglo de enteros. Permite reordenar y repetir posiciones:

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

Para m = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]]), m[[0, 2]] selecciona la primera y la tercera fila. m[:, [2, 0]] selecciona la última y la primera columna en ese orden, y da [[3 1] [6 4] [9 7]].

Dos listas de enteros en un mismo índice seleccionan coordenadas emparejadas. m[[0, 2], [1, 2]] empareja la fila 0 con la columna 1 y la fila 2 con la columna 2, y produce [2 9]. No toma todas las combinaciones. Para obtener el bloque formado por ambas filas y ambas columnas, utiliza:

m[np.ix_([0, 2], [1, 2])]
# array([[2, 3], [8, 9]])

Seleccionar primero las filas y después las columnas, m[[0, 2]][:, [1, 2]], da el mismo bloque.

La lectura y la asignación se comportan de forma distinta

La indexación avanzada y el filtrado booleano devuelven copias. Si c = a[[0, 1]], modificar c[0] deja a sin cambios. Pero a[[0, 1]] = -1 escribe directamente en esas posiciones originales. Una selección guardada y una asignación mediante un índice son operaciones distintas.

Esto también explica por qué las modificaciones encadenadas pueden no llegar al origen. En a[[0, 1]][0] = -1, la primera selección ya es una copia temporal. La escritura final modifica ese arreglo temporal, no a.

Comprueba directamente si se comparte memoria

np.shares_memory(x, y) comprueba si dos arreglos se solapan en memoria. Devuelve verdadero para un segmento ordinario no vacío y falso para una copia obtenida por indexación avanzada. El atributo base puede identificar al propietario de los datos subyacentes, pero no tiene por qué identificar el arreglo del que obtuviste el segmento más reciente. Si a = np.arange(6), b = a[2:5] y c = b[0:2], entonces c.base is a es verdadero y c.base is b es falso. Utiliza shares_memory cuando la pregunta sea específicamente si dos arreglos comparten datos.

Una máscara booleana registra qué valores cumplen una condición. Una vez creada, las mismas decisiones de verdadero o falso pueden seleccionar valores, contar sucesos o elegir sustituciones.

Crea y aplica una máscara

t = np.array([18.5, 22.0, 15.2, 25.8, 21.1])
warm = t > 20
t[warm]
# array([22. , 25.8, 21.1])

La comparación produce [False True False True True]. La indexación booleana conserva las posiciones verdaderas y devuelve una copia. Una máscara de 1 dimensión utilizada sobre un eje debe tener la misma longitud que ese eje.

Para combinar condiciones, utiliza & para «y», | para «o» y ~ para «no». Pon cada comparación entre paréntesis:

comfortable = (t > 18) & (t < 23)
t[comfortable]
# array([18.5, 22. , 21.1])

and y or de Python intentan obtener un único valor de verdad de todo un arreglo y fallan con arreglos de varios elementos. Omitir los paréntesis también cambia la forma en que Python agrupa la expresión, porque los operadores bit a bit tienen prioridad sobre las comparaciones.

Cuenta, mide o comprueba condiciones

True aporta 1 y False aporta 0. warm.sum() es 3 y warm.mean() es 0,6, la proporción de días por encima de 20 °C. np.count_nonzero(warm) también cuenta las entradas verdaderas. warm.any() pregunta si al menos un día es cálido; warm.all() pregunta si todos los días son cálidos.

Estas operaciones responden a preguntas distintas de t[warm].mean(), que calcula la temperatura media de los días cálidos. La media de una máscara mide una proporción; la media de las mediciones seleccionadas conserva la unidad de la medición.

Sustituye valores o elige entre alternativas

La asignación mediante una máscara actualiza las posiciones seleccionadas. Con t2 = t.copy(), la línea t2[t2 < 16] = 16 eleva las mediciones bajas a 16. np.clip(t, 16, 25) devuelve un arreglo nuevo limitado por ambos extremos, [18.5 22. 16. 25. 21.1].

np.where(condition, x, y) crea un resultado nuevo que toma x en las posiciones verdaderas e y en las falsas. np.where(t > 20, 'warm', 'cool') proporciona una etiqueta en cada posición original. En cambio, el filtrado acorta el resultado. Con una sola condición, np.where(t > 20) devuelve una tupla de arreglos de índices, aquí (array([1, 3, 4]),).

Conserva valores o registros completos

Una máscara de la misma forma aplicada a un arreglo de 2 dimensiones extrae los elementos coincidentes en un único vector plano. En m[m > 5], se pierde la estructura de filas. Para conservar registros completos, obtén un valor booleano por fila a partir de una columna:

scores = np.array([[78, 85, 92], [64, 70, 58],
                   [88, 91, 95], [72, 68, 80]])
scores[scores[:, 2] >= 90]
# array([[78, 85, 92], [88, 91, 95]])

Detecta explícitamente los valores faltantes

NaN no es igual ni siquiera a sí mismo. Las comparaciones de igualdad y orden con NaN son falsas; la comparación de desigualdad es verdadera. Por tanto, ni x == np.nan ni x != np.nan identifican correctamente las entradas presentes y faltantes. np.isnan(x) marca las posiciones faltantes y x[~np.isnan(x)] conserva los valores presentes.

Cambiar la forma modifica cómo se agrupan los valores en ejes. Cambiar la forma, transponer y añadir un eje cumplen funciones distintas, aunque algunas produzcan la misma forma final.

Cambia la forma sin modificar el número de elementos

a = np.arange(6)
r = a.reshape(2, 3)
# array([[0, 1, 2], [3, 4, 5]])

El orden predeterminado rellena una fila a la vez: el último eje cambia más rápido. Cambiar la forma de los mismos valores a (3, 2) da [[0 1] [2 3] [4 5]]. El producto de las nuevas dimensiones debe ser igual al tamaño original. Doce elementos caben en (3, 4), pero no en (5, 3).

Una dimensión puede ser -1, lo que permite que NumPy infiera su longitud. np.arange(12).reshape(-1, 3) da cuatro filas de tres; reshape(2, -1) da dos filas de seis. No se permiten dos dimensiones desconocidas porque sus longitudes individuales no pueden determinarse solo a partir del total.

La transposición intercambia los ejes

Para el r anterior, r.T es [[0 3] [1 4] [2 5]], con forma (3, 2). Cada columna original es ahora una fila. Esa disposición difiere de r.reshape(3, 2), aunque las formas resultantes coincidan.

Una transposición es útil cuando la siguiente operación necesita el orden inverso de los ejes. Un cambio de forma es útil cuando una secuencia ya tiene una agrupación significativa, como meses agrupados en trimestres.

Transponer un arreglo de 1 dimensión no crea una columna

v = np.arange(3) tiene un solo eje, por lo que v.T sigue teniendo forma (3,). Añade un eje explícitamente:

column = v[:, np.newaxis]  # shape (3, 1)
row = v[np.newaxis, :]     # shape (1, 3)

v.reshape(-1, 1) y np.expand_dims(v, 1) también crean una columna. np.squeeze(column) elimina su eje de longitud uno y devuelve la forma (3,). Añadir un eje no cambia ningún valor, pero indica a las operaciones aritméticas posteriores cómo deben alinearse.

Aplanamiento y memoria compartida

r.ravel() y r.flatten() enumeran los valores en un resultado de 1 dimensión. ravel devuelve una vista cuando es posible; flatten siempre copia. reshape(-1) es otra forma de solicitar una disposición de 1 dimensión, pero que comparta memoria depende de la organización de los datos de entrada. El cambio de forma puede necesitar una copia; la transposición comparte datos en su vista del arreglo. Utiliza .copy() cuando necesites almacenamiento independiente.

Agrupa valores mensuales en trimestres

Para monthly = np.array([120, 135, 150, 160, 155, 170, 180, 175, 165, 150, 140, 130]), monthly.reshape(4, 3) crea cuatro filas trimestrales, cada una con tres meses. Sumar cada fila con .sum(axis=1) da [405 485 520 420]. El primer total es 120 + 135 + 150 = 405. El cambio de forma funciona porque los datos de entrada en orden cronológico ya colocan juntos los meses de cada trimestre.

La unión combina valores de varios arreglos. La división corta un arreglo en partes. Primero decide si la operación debe ampliar un eje existente o introducir uno nuevo.

Concatena a lo largo de un eje existente

np.concatenate([a, b], axis=0) une vectores por sus extremos. Unir [1 2] con [3 4 5] da [1 2 3 4 5].

Para dos arreglos, cada uno con forma (2, 3), el eje 0 añade filas y da (4, 3). El eje 1 añade columnas y da (2, 6). Solo el eje de unión puede tener distinta longitud. Por tanto, las formas (2, 3) y (2, 2) pueden unirse a lo largo del eje 1 para obtener (2, 5), pero no pueden unirse a lo largo del eje 0 porque sus números de columnas no coinciden.

Los arreglos deben pasarse juntos como una secuencia, por ejemplo [a, b]. La unión crea un arreglo combinado nuevo y copia los datos de entrada.

Apila a lo largo de un eje nuevo

Para p = np.array([1, 2, 3]) y q = np.array([4, 5, 6]):

stack requiere formas de entrada iguales y añade un eje. concatenate conserva el número de ejes. Las funciones auxiliares expresan disposiciones habituales: vstack([p, q]) crea filas, hstack([p, q]) une estos datos de 1 dimensión por sus extremos y column_stack([p, q]) crea columnas. El comportamiento de hstack con datos de 1 dimensión explica por qué su nombre no basta para predecir una tabla.

Divide por límites o por número de partes

np.split(np.arange(10), [3, 7]) corta antes de las posiciones 3 y 7, y produce [0 1 2], [3 4 5 6] y [7 8 9]. Las posiciones de corte son límites, no longitudes de las partes.

En cambio, un segundo argumento entero solicita partes iguales: np.split(x, 3) solicita tres partes iguales. Diez elementos no pueden dividirse en tres partes iguales de tamaño entero, por lo que esto genera ValueError. np.array_split(np.arange(10), 3) permite longitudes desiguales y produce 4, 3 y 3. Estas llamadas de división devuelven una colección de arreglos, no un único arreglo con un eje nuevo de apilamiento.

Crea una tabla de mediciones

h = np.array([1.62, 1.75, 1.80])  # meters
w = np.array([55.0, 72.5, 80.0])  # kilograms
data = np.column_stack([h, w])

La forma (3, 2) representa tres personas con altura y masa en las columnas. La expresión data[:, 1] / data[:, 0] ** 2 calcula la masa dividida entre la altura al cuadrado para cada fila, y da aproximadamente 21,0, 23,7 y 24,7 kg/m². Es esencial mantener los dos arreglos de mediciones en el mismo orden de personas.

Si los datos de entrada llegan en lotes, reúne los arreglos de los lotes en una lista de Python y llama a concatenate una sola vez. Volver a unir un arreglo cada vez mayor en cada pasada de un bucle copia repetidamente sus datos existentes.

La vectorización expresa un cálculo para arreglos completos. NumPy se encarga del trabajo repetido a nivel de elemento en código compilado, por lo que la expresión de Python puede mantenerse cercana al cálculo que quieres realizar.

Convierte un bucle en aritmética entre posiciones correspondientes

prices = np.array([2.50, 4.00, 1.20])
qty = np.array([3, 1, 5])
line_totals = prices * qty
order_total = line_totals.sum()

Los productos son [7.5 4. 6.] y su suma es 17,5. Cada precio se empareja con su propia cantidad. Un bucle de Python que actualiza un total produce el mismo resultado, pero hace que Python procese cada par por separado.

Todos los operadores aritméticos actúan elemento a elemento: +, -, *, /, //, % y **. Un escalar se aplica a cada entrada. 10 - np.array([1, 2, 3]) da [9 8 7]; el orden de los operandos sigue importando. Dos arreglos necesitan formas iguales o formas compatibles para la difusión.

Distingue los productos elemento a elemento de los matriciales

* multiplica las entradas correspondientes. Para A = np.array([[1, 2], [3, 4]]) y B = np.array([[5, 6], [7, 8]]), A * B da [[5 12] [21 32]]. La multiplicación matricial usa @ y daría [[19 22] [43 50]]. Elige * para mediciones emparejadas como precio y cantidad.

Las comparaciones también devuelven una respuesta por posición

a == b produce un arreglo booleano. No pregunta si dos arreglos son iguales como objetos completos. Una sentencia if necesita un solo valor de verdad, por lo que if a == b: falla para resultados de varios elementos. np.array_equal(a, b) comprueba la igualdad exacta de arreglos completos. Para decimales aproximados, np.allclose(a, b) comprueba si coinciden dentro de una tolerancia.

Comprende las advertencias de división

Con la configuración predeterminada de errores de NumPy, la división de números de coma flotante por cero produce una advertencia y valores especiales:

np.array([1.0, -1.0, 0.0]) / 0
# array([ inf, -inf, nan])

np.isfinite identifica los resultados que no son infinitos ni NaN. En cambio, la división entera por suelo entre cero devuelve ceros enteros con una advertencia. Esos ceros parecen finitos, así que inspecciona los denominadores enteros con (d == 0).any() antes de la división por suelo. Una advertencia merece atención aunque el programa continúe.

Decide si actualizas in situ

a += value modifica el almacenamiento existente y conserva su tipo de datos. Si a es un arreglo de enteros, a += 0.5 genera un error de conversión porque el resultado de coma flotante no puede almacenarse según la regla de conversión de esa operación. a = a + 0.5 crea un resultado de coma flotante y vincula a a él. Esto difiere de asignar un decimal a un elemento entero, lo que puede truncarlo sin aviso.

Crea una expresión de varios pasos

Para old = np.array([2.50, 4.00, 8.00]) y new = np.array([3.00, 3.00, 8.00]), (new - old) / old * 100 da [20. -25. 0.]. Primero calcula cada variación, después divídela entre su valor original y, por último, expresa la proporción como porcentaje. Los signos muestran una subida, una bajada y ningún cambio. Los valores originales deben ser distintos de cero para este cálculo porcentual.

Una función universal aplica un cálculo por separado en cada posición de un arreglo. Estas funciones amplían la vectorización más allá de la aritmética ordinaria a raíces, logaritmos, redondeo, comparaciones y otras operaciones numéricas.

Elige una función que opere con arreglos

Las funciones universales unarias aceptan una entrada. np.sqrt(np.array([1, 4, 9])) da [1. 2. 3.] y np.abs(np.array([-2, 3])) da [2 3]. np.exp es la función exponencial, np.log es el logaritmo natural y np.log10 es el logaritmo en base 10. Por ejemplo, np.exp(0) es 1,0 y np.log10(1000) es 3,0.

El módulo math de Python opera con números individuales. math.sqrt(np.array([1, 4])) no puede calcular ambas raíces y genera un error de tipo. Utiliza la versión de NumPy para arreglos numéricos. Los operadores también llaman a funciones universales: a + b corresponde a np.add(a, b) y a * b a np.multiply(a, b).

Compara valores correspondientes o reduce un arreglo completo

Las funciones universales binarias aceptan dos entradas. np.maximum([1, 5, 3], [4, 2, 6]) da [4 5 6], eligiendo el valor mayor en cada posición. np.minimum elige el menor y np.power eleva las bases correspondientes a potencias.

np.maximum(x, 0) establece las entradas negativas en cero en un resultado nuevo. Es distinta de np.max(x), una agregación que devuelve un único valor máximo. Para [1, 5, 3], max da 5; maximum necesita otra entrada y conserva la estructura elemento a elemento.

Redondea con la regla prevista

np.round(x, 2) conserva dos decimales. Las mitades exactas siguen la regla del par: np.round([0.5, 1.5, 2.5]) da [0. 2. 2.]. La aproximación binaria puede afectar a los valores que parecen estar exactamente a mitad de camino en decimal, así que interpreta los decimales mostrados teniendo en cuenta su representación en coma flotante.

Inspecciona los valores fuera del dominio de una función

Para entradas reales de coma flotante, np.sqrt(-1.0) devuelve NaN con una advertencia, mientras que np.log(0.0) devuelve infinito negativo con una advertencia bajo la configuración predeterminada de errores. A diferencia de math.sqrt(-1), estas llamadas normalmente no se detienen con una excepción de dominio. Comprueba las entradas cuando la operación matemática requiera un intervalo restringido. np.isnan marca NaN; np.isfinite marca los valores que no son NaN ni infinitos; np.isclose compara valores con una tolerancia.

Combina funciones universales en un cálculo útil

Para los arreglos de coordenadas x = np.array([3, 5, 8]) e y = np.array([4, 12, 15]), calcula la distancia al origen con np.sqrt(x ** 2 + y ** 2). Al elevar al cuadrado se obtiene [9 25 64] y [16 144 225]; al sumar se obtiene [25 169 289]; las raíces son [5. 13. 17.]. np.hypot(x, y) calcula esas distancias directamente.

La difusión permite que arreglos de distintas formas participen en cálculos elemento a elemento. Los ejes alineados determinan qué valores se emparejan y cuáles se repiten.

Compara las dimensiones desde la derecha

Alinea las formas por sus extremos derechos. Cada par de longitudes de eje debe ser igual o tener una longitud igual a 1. Los ejes iniciales que faltan cuentan como longitud 1. Un eje de longitud uno se expande conceptualmente para ajustarse a la otra longitud; NumPy no necesita copiar los valores de entrada repetidos.

Para (4, 3) y (3,), las últimas longitudes coinciden en 3. La dimensión inicial que falta actúa como 1 y se expande hasta 4. El resultado es (4, 3): el vector se aplica a cada fila. (4, 3) y (4,) fallan porque las longitudes finales 3 y 4 no coinciden y ninguna es 1. Un par incompatible genera ValueError.

Centra o estandariza columnas

X = np.array([[1, 10], [2, 20], [3, 30]])
centered = X - X.mean(axis=0)

Las medias de las columnas son [2. 20.], con forma (2,). Se alinean con el último eje de (3, 2) y dan [[-1. -10.] [0. 0.] [1. 10.]]. Dividir el resultado centrado por X.std(axis=0) estandariza cada columna y produce aproximadamente −1,22, 0 y 1,22 a lo largo de ambas columnas. La dispersión de cada columna debe ser distinta de cero para esta división.

Conserva un eje para los cálculos por fila

Utiliza una tabla de calificaciones con cuatro estudiantes y tres pruebas:

scores = np.array([[78, 85, 92], [64, 70, 58],
                   [88, 91, 95], [72, 68, 80]])

scores.mean(axis=1) tiene forma (4,). No puede difundirse como una media por fila frente a (4, 3). Conserva el eje eliminado:

row_mean = scores.mean(axis=1, keepdims=True)
centered = scores - row_mean

row_mean ahora tiene forma (4, 1). Su 4 inicial coincide con las filas; su 1 final se expande a lo largo de tres columnas. scores.mean(axis=1)[:, np.newaxis] crea la misma forma. Para la fila [78, 85, 92], restar su media de 85 da [-7. 0. 7.].

Usa la misma regla para crear una tabla

np.arange(1, 4)[:, np.newaxis] * np.arange(1, 5) combina (3, 1) y (4,). Ambos arreglos se expanden hasta la forma resultante (3, 4), y producen [[1 2 3 4] [2 4 6 8] [3 6 9 12]].

La expansión también puede ser accidental. Una columna (3, 1) menos un vector (3,) crea las nueve diferencias por pares, con forma (3, 3). Si querías tres diferencias correspondientes, haz que ambas entradas tengan forma (3,), por ejemplo con column.ravel().

Pondera cada columna antes de sumar

Para la misma tabla de calificaciones y w = np.array([0.2, 0.3, 0.5]), scores * w aplica las tres ponderaciones a cada fila. Sumar con .sum(axis=1) da [87.1 62.8 92.4 74.8]. El primer resultado es 15,6 + 25,5 + 46,0 = 87,1.

Una agregación combina valores en menos resultados: un total, una media, un extremo o una medida de dispersión. Elegir el eje forma parte de elegir la pregunta, porque determina qué grupos de valores se combinan.

Reduce el eje que indiques

Para una tabla (4, 3) con cuatro estudiantes y tres pruebas, una agregación sin axis utiliza los 12 valores. scores.sum() da un total. scores.mean(axis=0) reduce el eje de estudiantes y deja tres medias de pruebas. scores.mean(axis=1) reduce el eje de pruebas y deja cuatro medias de estudiantes.

scores = np.array([[78, 85, 92], [64, 70, 58],
                   [88, 91, 95], [72, 68, 80]])

Su suma total es 941. Las medias de las columnas son [75.5 78.5 81.25]; las medias de las filas son aproximadamente [85. 64. 91.33 73.33]. Pregúntate qué eje debe desaparecer. Decir «el eje 0 significa cada fila» invierte la operación: el eje 0 combina filas.

Elige la magnitud que se devolverá

Los métodos como a.sum() y las funciones como np.sum(a) expresan la misma operación básica. Los métodos de NumPy evitan el comportamiento diferente de las funciones incorporadas de Python. Por ejemplo, sum(scores) de Python suma los arreglos de las filas para producir los totales de las columnas, mientras que scores.sum() combina todas las entradas. max(scores) de Python intenta comparar filas y genera un error de valor de verdad ambiguo.

Las posiciones son distintas de los valores

scores.mean(axis=1).argmax() es 2: el tercer estudiante tiene la media más alta. argmax devuelve la primera posición cuando hay varios máximos iguales. Sin un eje en una tabla, devuelve un índice aplanado en orden por filas; scores.argmax() es 8. np.unravel_index(8, scores.shape) recupera la coordenada (2, 2).

Utiliza keepdims=True cuando un resumen deba alinearse con la tabla original. scores.sum(axis=1, keepdims=True) tiene forma (4, 1), por lo que sirve para un valor de normalización por fila. Sin él, el resultado tiene forma (4,).

Conserva los totales intermedios cuando importe el orden

np.cumsum([3, 1, 4, 1, 5]) da [3 4 8 9 14]. Cada posición es el total acumulado hasta ese punto. np.cumprod([1, 2, 3, 4]) da de forma similar [1 2 6 24]. np.diff([3, 1, 4, 1, 5]) da las cuatro variaciones entre valores vecinos [-2 3 -3 4]. En una tabla, especifica axis=1 para obtener sumas acumuladas independientes a lo largo de las filas.

Indica la convención de dispersión

std y var dividen el total de las desviaciones al cuadrado entre el número de valores de forma predeterminada: ddof=0. Utiliza ddof=1 para la fórmula muestral, cuyo divisor es una unidad menor. Para [2, 4, 4, 4, 5, 5, 7, 9], la media es 5, la desviación estándar predeterminada es 2,0 y la desviación estándar muestral es aproximadamente 2,14. Un informe debe dejar claro qué convención utiliza.

Los resúmenes basados en el orden describen dónde se sitúan los valores en una distribución ordenada. La ordenación también permite clasificar registros, pero una tabla requiere cuidado para mantener juntos los campos de cada registro.

Localiza el centro y los cuartiles

Para x = np.array([12, 15, 11, 20, 18, 14]), el orden es [11 12 14 15 18 20]. Con seis valores, np.median(x) calcula la media de los dos centrales, 14 y 15, y da 14,5. Para un número impar de valores, la mediana es el único valor central.

np.percentile(x, q) acepta un porcentaje de 0 a 100. np.quantile(x, q) acepta la fracción equivalente de 0 a 1. Su interpolación lineal predeterminada puede dar un valor entre observaciones. Para seis valores, la posición del percentil 25 contando desde cero es 0,25 × 5 = 1,25. Está a un cuarto del recorrido entre 12 y 14, lo que da 12,5. Los percentiles 50 y 75 son 14,5 y 17,25, por lo que el rango intercuartílico es 4,75.

La mediana resiste un valor extremo más que la media. Añadir 200 a estos datos desplaza la media de 15,0 a aproximadamente 41,4; la mediana pasa de 14,5 a 15,0. Ninguna de las dos medidas describe por sí sola toda la distribución.

Elige entre datos ordenados o posiciones de ordenación

np.sort(x) devuelve una copia ordenada. x.sort() modifica x y devuelve None, por lo que y = x.sort() no coloca los valores ordenados en y. Para obtener valores descendentes, utiliza np.sort(x)[::-1].

En un arreglo de 2 dimensiones, la ordenación se realiza de forma predeterminada sobre el último eje, ordenando cada fila de manera independiente. axis=0 ordena cada columna de manera independiente. Ninguna de las dos operaciones ordena registros. Para tab = np.array([[3, 1], [1, 2], [2, 0]]), np.sort(tab, axis=0) da [[1 0] [2 1] [3 2]], separando valores que originalmente pertenecían al mismo registro.

Para conservar los registros, obtén un orden a partir de la columna clave y aplícalo a las filas completas:

order = tab[:, 0].argsort()
ranked = tab[order]
# array([[1, 2], [2, 0], [3, 1]])

El mismo orden de índices puede reordenar vectores relacionados. Si avg = np.array([85.0, 64.0, 91.33, 73.33]) y names = np.array(['Ana', 'Ben', 'Chen', 'Dara']), order = np.argsort(avg)[::-1] ordena las medias de forma descendente. names[order] da ['Chen' 'Ana' 'Dara' 'Ben'].

Cuenta valores distintos y comprueba la pertenencia

np.unique devuelve valores distintos ordenados. Con return_counts=True, también devuelve los recuentos correspondientes:

colors = np.array(['red', 'blue', 'red', 'green', 'blue', 'red'])
values, counts = np.unique(colors, return_counts=True)

Los resultados son ['blue' 'green' 'red'] y [2 1 3]. values[counts.argmax()] encuentra el valor más frecuente, 'red'. Las posiciones de los recuentos corresponden a las de los valores distintos.

np.isin(a, allowed) devuelve una máscara de pertenencia a una colección. Para a = np.arange(1, 6), np.isin(a, [2, 4]) da [False True False True False], lista para seleccionar esos valores o sus registros asociados.

Los datos faltantes y los subconjuntos filtrados necesitan un criterio explícito de resumen. Un resultado numérico puede ser incorrecto aunque la operación con el arreglo se ejecute correctamente: un marcador puede contarse como una medición o un subconjunto vacío puede confundirse con una media significativa.

Detecta los valores faltantes antes de resumir

NaN se propaga en las sumas y medias ordinarias. Para x = np.array([3.0, np.nan, 5.0]), tanto x.sum() como x.mean() dan NaN. np.nansum(x) da 8,0 y np.nanmean(x) da 4,0, omitiendo la posición faltante. Las funciones relacionadas incluyen nanmax, nanmin, nanstd y nanmedian. Si todos los valores son faltantes, nanmean devuelve NaN con una advertencia porque no quedan valores observados.

Para mediciones de un sensor en °C:

r = np.array([21.5, np.nan, 22.1, 23.0, np.nan, 21.9])
missing = np.isnan(r)

missing.sum() es 2, missing.mean() es aproximadamente 0,33 y r[~missing] conserva cuatro mediciones. np.nanmean(r) es 22,125, usando solo esos cuatro valores. La comparación r == np.nan no marcaría las mediciones faltantes.

Convierte primero los códigos usados como marcadores

Un número como −999 puede representar datos faltantes en un sistema de entrada. NumPy lo trata como una medición real hasta que lo sustituyas:

v = np.array([12, -999, 15, -999, 9]).astype(float)
v[v == -999] = np.nan
np.nanmean(v)  # 12.0

Convierte primero a coma flotante porque un arreglo de enteros no puede almacenar NaN. Esta sustitución solo es apropiada cuando −999 está definido como código de valor faltante para esos datos.

El relleno cambia la distribución

Sustituir las temperaturas faltantes por cero hace que la media del ejemplo sea 14,75, aunque no se haya observado ninguna medición de temperatura cero. Rellenarlas con la media observada, 22,125, conserva esa media, pero reduce la dispersión aparente. Un valor de relleno es una estimación introducida, por lo que su efecto debe tenerse en cuenta en la decisión de análisis.

Para una tabla D de 2 dimensiones, np.nanmean(D, axis=0) resume los valores observados de cada columna. Cada columna puede tener un recuento distinto. Para eliminar las filas que contienen algún valor faltante:

complete = ~np.isnan(D).any(axis=1)
clean_rows = D[complete]

La reducción crea una decisión por fila; la negación conserva las filas sin entradas faltantes. Con D = np.array([[1., 2.], [np.nan, 4.], [5., np.nan], [7., 8.]]), esto conserva [[1. 2.] [7. 8.]].

Resume una condición o un grupo

Para las temperaturas t, t[t > 20].mean() calcula la media solo de los días por encima de 20 °C. En datos agrupados, utiliza una máscara con la etiqueta correspondiente: con group = np.array(['A', 'B', 'A', 'B', 'A']) y value = np.array([10, 20, 14, 26, 12]), value[group == 'A'].mean() es 12,0 y la media correspondiente de B es 23,0. Recorre np.unique(group) para repetir esto con cada grupo.

Antes de resumir un subconjunto filtrado, comprueba mask.any(). La media de una selección vacía es NaN con una advertencia, mientras que su suma es 0. Ese cero puede ser un total válido para un conjunto vacío, pero no demuestra que hubiera alguna medición presente.

Un generador de números aleatorios permite realizar muestreo, mezclado y simulaciones. Una semilla hace que el estado inicial sea repetible, por lo que puedes volver a ejecutar un análisis mientras investigas su lógica.

Crea un Generator y reutilízalo

rng = np.random.default_rng(42)

NumPy recomienda esta interfaz Generator para el código nuevo. Su generador de bits predeterminado es PCG64. Sin una semilla, default_rng() obtiene entropía nueva del sistema operativo. Las llamadas antiguas como np.random.seed y np.random.rand usan un estado global compartido; los objetos Generator permiten que un análisis gestione directamente su propio estado.

Los valores pseudoaleatorios proceden de un algoritmo determinista. El mismo estado inicial y la misma secuencia de llamadas reproducen la secuencia en el mismo entorno. Cada extracción hace avanzar el estado. Crear un Generator nuevo con la semilla 42 dentro de cada pasada de un bucle reinicia la secuencia y repite las mismas extracciones iniciales en lugar de continuarla. Registra la versión de NumPy y el código además de la semilla, porque no se garantiza la compatibilidad de la secuencia entre versiones ni en todos los entornos. Para contraseñas o tokens de seguridad, utiliza el módulo secrets de Python.

Elige una distribución y una forma de salida

size puede ser un número de elementos o una tupla de forma. Para normal, loc es la media de la distribución y scale es su desviación estándar. Por tanto, una varianza de 100 necesita scale=10. La media y la desviación estándar reales de una muestra pequeña no tienen por qué coincidir exactamente con los parámetros de la distribución.

Para las extracciones de enteros, el límite superior se excluye de forma predeterminada. Un dado necesita integers(1, 7), ya que integers(1, 6) no puede obtener 6. integers(1, 6, endpoint=True) incluye el límite superior y también modela un dado.

Toma muestras con o sin reemplazo

rng.choice(['heads', 'tails'], size=5) realiza cinco extracciones con reemplazo. Un valor puede aparecer varias veces. Para obtener posiciones distintas, utiliza replace=False; solicitar más posiciones de las que tiene la población genera ValueError. Las probabilidades pueden proporcionarse como p=[0.7, 0.3], en el mismo orden que los valores, y deben sumar 1.

El muestreo sin reemplazo impide seleccionar dos veces una posición de entrada. Si los propios datos de entrada contienen valores duplicados, todavía pueden aparecer valores iguales en la muestra.

Mezcla registros sin separar sus campos

rng.shuffle(a) reorganiza el arreglo existente y devuelve None. rng.permutation(a) devuelve una copia mezclada. rng.permutation(10) da los enteros del 0 al 9 en orden aleatorio, útiles como índices de filas.

Para un arreglo de 2 dimensiones, el eje predeterminado es 0: las filas completas se mueven juntas. Esto mantiene alineados los campos de cada observación. Para mezclar dos arreglos relacionados de forma coherente, genera una permutación de sus índices de registro compartidos y aplícala a ambos.

Una simulación vectorizada representa ensayos repetidos como arreglos, aplica la regla del suceso a esos arreglos y resume los resultados. La forma del arreglo debe mostrar qué contiene un ensayo.

Convierte un suceso en una proporción

rng = np.random.default_rng(42)
rolls = rng.integers(1, 7, size=100_000)
estimate = (rolls == 6).mean()

La máscara es verdadera una vez por cada 6 observado. Su media estima la probabilidad de ese suceso, cercana a 1/6, o aproximadamente 0,1667. rolls.mean() responde a una pregunta distinta: el valor medio de la cara del dado, cercano a 3,5. Una semilla fija repite una estimación; no hace que esa estimación sea exacta.

La vectorización evita el trabajo al nivel de Python para cada extracción, por lo que las simulaciones grandes suelen ser mucho más rápidas que con un bucle. La aceleración depende del cálculo, el tamaño del arreglo y la computadora, así que no es una propiedad fija del suceso.

Utiliza una fila por ensayo con varios valores

Para simular dos dados en cada ensayo:

dice = rng.integers(1, 7, size=(100_000, 2))
totals = dice.sum(axis=1)
p_seven = (totals == 7).mean()

La tabla tiene 100 000 filas de ensayos y dos columnas de dados. Reducir el eje 1 produce un total por ensayo. Seis de los 36 pares ordenados equiprobables suman 7, por lo que la probabilidad estimada debería estar cerca de 6/36. En cambio, reducir el eje 0 daría dos totales de todos los ensayos y perdería el suceso a nivel de ensayo.

Las simulaciones más grandes siguen variando

Para ensayos independientes, el error estándar de una proporción estimada es:

Aquí $p$ es la probabilidad del suceso y $n$ el número de ensayos. Para obtener un 6 en un dado con 100 000 ensayos, es aproximadamente 0,0012. Una aproximación normal sitúa aproximadamente el 95 % de las estimaciones a una distancia máxima de 0,0023 de 1/6. Multiplicar el número de ensayos por 100 reduce el error estándar por un factor de 10. Más extracciones no corrigen un suceso codificado incorrectamente.

Crea e inspecciona un paseo aleatorio

steps = rng.choice([-1, 1], size=1000) obtiene pasos a la izquierda o a la derecha. walk = steps.cumsum() da la posición después de cada paso. Su máximo y su mínimo localizan las posiciones extremas visitadas. Para encontrar el primer punto situado al menos a 10 unidades del inicio:

hit = np.abs(walk) >= 10
if hit.any():
    step_count = hit.argmax() + 1

argmax localiza la primera entrada verdadera, pero también devuelve 0 cuando todas las entradas son falsas. La comprobación con any() distingue una llegada real de la ausencia de una llegada. Suma 1 porque la posición 0 del arreglo es la posición después del paso 1.

Para muchos paseos, rng.choice([-1, 1], size=(5000, 1000)).cumsum(axis=1) acumula por separado a lo largo de cada fila. walks[:, -1] selecciona todas las posiciones finales; su media está cerca de 0 y su desviación estándar cerca de la raíz cuadrada de 1000, aproximadamente 31,6.

Utiliza permutaciones y comprobaciones exactas

Una división aleatoria de 100 registros puede usar idx = rng.permutation(100) y después data[idx[:80]] y data[idx[80:]]. Los dos segmentos disjuntos de una misma permutación asignan cada registro exactamente una vez. Para una simulación, compara un caso sencillo con una respuesta exacta, como una media del dado de 3,5, antes de confiar en resultados más complicados.