NumPy: arrays numéricos

El problema: sumar dos listas no suma nada

Con lo que sabes hasta Listas, multiplicar todos los precios por 1.19 se escribe así:

precios = [1000, 2500, 3200, 890]
con_iva = []
for p in precios:
    con_iva.append(p * 1.19)

Un bucle entero para una idea de una sola línea. Y si intentas el atajo obvio, Python hace algo distinto de lo que esperabas:

precios = [1000, 2500]
otros = [500, 700]
print(precios + otros)
print(precios * 2)

[1000, 2500, 500, 700]
[1000, 2500, 1000, 2500]

+ concatena las listas y * las repite: para una lista, esos operadores significan otra cosa. No hay forma de sumar elemento a elemento sin escribir el bucle a mano.

NumPy (de Numerical Python) existe para resolver eso. Aporta un tipo nuevo, el ndarray, donde +, * y compañía sí operan sobre todos los elementos a la vez — y de paso lo hacen entre 10 y 100 veces más rápido que el bucle, porque por debajo el trabajo lo hace código compilado en C, no el intérprete de Python.

Instalarlo e importarlo

NumPy no viene con Python: hay que instalarlo una vez desde la terminal.

pip install numpy

Y en cada archivo que lo use:

import numpy as np

as np le pone un alias corto. Esto es una convención universal: prácticamente todo el código NumPy del mundo escribe np, y desviarse solo hace tu código más difícil de leer para los demás.

Crear arrays

La forma más directa es convertir una lista:

import numpy as np

precios = np.array([1000, 2500, 3200, 890])
print(precios)
print(type(precios))

[1000 2500 3200  890]
<class 'numpy.ndarray'>

Fíjate en la salida: sin comas. Es la pista visual más rápida para saber si lo que estás mirando en la consola es un array de NumPy o una lista de Python.

Y hay funciones para generar arrays sin escribir los valores:

Un array no es una lista

Las diferencias que importan en la práctica:

Ese “un solo tipo” tiene consecuencias visibles:

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

b = np.array([1, 2, 3.5])
print(b.dtype)

int64
float64

dtype (“data type”) es el tipo de todos los elementos. En el segundo caso NumPy promovió los enteros a decimales para que un solo tipo alcanzara para todos.

Vectorización: operar sin bucles

Aquí está la razón de ser de la librería:

precios = np.array([1000, 2500, 3200, 890])
con_iva = precios * 1.19
print(con_iva)

[1190.  2975.  3808.  1059.1]

A esto se lo llama vectorización: la operación se aplica a todo el array de una sola vez, sin for a la vista. Funciona con todos los operadores y también entre dos arrays del mismo tamaño:

cantidades = np.array([2, 1, 3, 5])
precios = np.array([1000, 2500, 3200, 890])

print(precios + 100)            # a cada uno
print(precios * cantidades)     # uno contra uno
print(precios > 2000)           # comparación, da booleanos

[1100 2600 3300  990]
[2000 2500 9600 4450]
[False  True  True False]

Esa última línea es la puerta a algo muy usado: filtrar por condición.

caros = precios[precios > 2000]
print(caros)

[2500 3200]

precios > 2000 produce un array de True/False, y usarlo como índice devuelve solo las posiciones donde había True. Se llama máscara booleana, y reemplaza a la comprensión de lista [p for p in precios if p > 2000] de forma más corta y mucho más rápida.

Funciones y estadísticas

NumPy trae las operaciones matemáticas típicas, aplicables a un array entero:

notas = np.array([8.5, 6.0, 9.5, 4.0, 7.0])

print(notas.sum())
print(notas.mean())
print(notas.max(), notas.min())
print(notas.std())
print(np.sqrt(notas))

35.0
7.0
9.5 4.0
1.9078784028338913
[2.91547595 2.44948974 3.08220700 2.         2.64575131]

Arrays de dos dimensiones

Un array puede tener más de una dimensión: una tabla, una imagen, una matriz.

notas = np.array([
    [8, 6, 9, 7],
    [5, 7, 6, 8],
    [9, 9, 8, 10],
])

print(notas.shape)
print(notas.ndim)

(3, 4)
2

shape (“forma”) es la propiedad que más vas a consultar: (3, 4) significa 3 filas y 4 columnas. ndim es la cantidad de dimensiones.

Para indexar se usan dos índices separados por coma, no dos pares de corchetes:

print(notas[0, 2])      # fila 0, columna 2
print(notas[1])         # la fila 1 entera
print(notas[:, 0])      # la columna 0 entera
print(notas[0:2, 1:3])  # un recorte de filas y columnas

9
[5 7 6 8]
[8 5 9]
[[6 9]
 [7 6]]

: solo significa “todas las posiciones de esta dimensión”, igual que en el rebanado de listas.

Y las estadísticas aceptan un axis para decir en qué dirección calcular:

print(notas.mean())          # promedio de todo
print(notas.mean(axis=0))    # promedio por columna (por materia)
print(notas.mean(axis=1))    # promedio por fila (por alumno)

7.666666666666667
[7.33333333 7.33333333 7.66666667 8.33333333]
[7.5  6.5  9.  ]

Broadcasting: cuando las formas no coinciden

Ya usaste esto sin nombrarlo: precios * 1.19 combina un array de 4 elementos con un solo número. NumPy “estira” el valor suelto para que alcance a todos. Esa regla, generalizada, se llama broadcasting (“difusión”), y también funciona entre arrays de distinta forma:

notas = np.array([
    [8, 6, 9, 7],
    [5, 7, 6, 8],
    [9, 9, 8, 10],
])
bonus = np.array([1, 0, 0, 2])

print(notas + bonus)

[[ 9  6  9  9]
 [ 6  7  6 10]
 [10  9  8 12]]

bonus tiene 4 elementos y notas es 3×4: NumPy repite la fila bonus para cada una de las tres filas. La condición es que las dimensiones coincidan o una de ellas sea 1; si no, el error es explícito:

ValueError: operands could not be broadcast together with shapes (3,4) (3,)

Pon a prueba

import numpy as np

a = np.array([1, 2, 3])
b = np.array([10, 20, 30])
print(a + b)

import numpy as np

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

print(datos.shape)
print(datos[1, 0])
print(datos[:, 1])
print(datos.sum(axis=0))
print(datos[datos > 3])

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

import numpy as np

temperaturas = np.([22, 28, 19, 31, 25])

fahrenheit = temperaturas * 9 / 5 + 32

promedio = temperaturas.()

calurosos = temperaturas[temperaturas  25]

print(fahrenheit, promedio, calurosos)

Siguiente paso

Ahora que puedes calcular sobre miles de números sin escribir un solo bucle, el paso natural es verlos: convertir esos arrays en gráficos de líneas, barras o dispersión — ver Matplotlib: graficar con pyplot.