Mis apuntes · Aprende Python desde PHP

Se guardan solos en este navegador mientras escribes. Puedes usar Markdown. Al descargarlos, la primera línea es tu enlace personal al curso.

Lección 18 de 47 · Colecciones en acción y matrices ✦ WebMCP implementado

NumPy: la matriz de verdad

10 min de lectura 4 retos

NumPy es la biblioteca que convierte a Python en el lenguaje de la ciencia de datos y del machine learning. Su pieza central es el array: una tabla de números de un solo tipo, guardada de forma compacta, sobre la que haces cuentas de golpe (sin bucles) y a una velocidad parecida a la de C. Es la «matriz de verdad».

¿De dónde vienen los nombres?

NumPy = Numerical Python (Python numérico)
La biblioteca de cálculo numérico. Casi todo el ecosistema de datos (pandas, scikit-learn, PyTorch) está construido sobre sus ideas.
np = alias convencional de numpy: import numpy as np
Todo el mundo escribe np.; verlo en el código de otros te dice «esto es NumPy». Como use App\Tareas as T; en PHP.
ndarray = n-dimensional array (array de n dimensiones)
El tipo del array de NumPy: puede ser una fila de números, una tabla (matriz), un cubo…
shape = inglés shape (forma)
Una tupla con el tamaño de cada dimensión: (3, 4) son 3 filas y 4 columnas.
dtype = data type (tipo de dato)
El tipo de todos los números del array (int64, float64…). En un array de NumPy son siempre iguales.
axis = inglés axis (eje)
La dirección en la que se hace una operación: axis=0 recorre las filas (hacia abajo) y axis=1 las columnas (hacia la derecha).
arange y linspace = array range y linear space (espacio lineal)
arange es el range de Python pero devuelve un array; linspace(0, 1, 5) da 5 números equiespaciados entre 0 y 1.
broadcasting = inglés broadcast (emitir, como una radio)
Estirar automáticamente un array pequeño para que encaje con uno grande, como una emisora que llega a todas las casas.
@ = el operador de producto de matrices, añadido en Python 3.5
Escribe a @ b para multiplicar matrices. El * hace otra cosa (casilla a casilla).
En 4 ideas
1/4

Un array de NumPy guarda números de un solo tipo (dtype) en un bloque de memoria seguido, y conoce su forma (shape). Una lista de Python guarda flechas a objetos sueltos. En PHP no hay nada igual: son arrays de arrays.

1 · Por qué NumPy

Las listas de la lección anterior sirven, pero se quedan cortas. Una lista de Python guarda cada número como un objeto aparte (con su cabecera, su tipo, su contador) y la lista guarda flechas a esos objetos, repartidos por la memoria. Recorrerla es saltar de un lado a otro. Un array de NumPy guarda los números en fila, uno detrás de otro, todos del mismo tipo, como los huevos en una huevera.

  • Rápido: las operaciones se ejecutan en C, sobre ese bloque seguido de memoria, sin pasar por el intérprete de Python en cada número.
  • Compacto: un millón de enteros ocupa unos 8 MB, frente a bastante más con una lista de int de Python.
  • Expresivo: a * 2 en vez de un bucle. El código se parece a la fórmula de matemáticas.
  • La lengua común: pandas (tablas), scikit-learn (ML clásico), PyTorch y TensorFlow (redes neuronales) hablan en arrays con las mismas ideas de NumPy.

No viene con Python: es una biblioteca externa (en tu ordenador se instala con pip install numpy, lección 36). En los ejemplos de este curso ya viene cargada en el navegador; solo hay que importarla.

Pythonmain.py
import numpy as np

print(np.__version__)

# Un array a partir de una lista. En PHP: no existe, es un array normal.
# El dtype se indica a mano: si no, el entero por defecto depende del sistema.
horas = np.array([2, 5, 1, 4], dtype=np.int64)
print(horas)
print(type(horas))
print(horas.dtype, horas.shape, horas.ndim, horas.size)

2 · Crear arrays: shape, dtype y los atajos

Un array tiene cuatro datos que vas a consultar constantemente:

#AtributoQué esEjemplo de una matriz de 3 filas x 4 columnas
1shapeEl tamaño de cada dimensión(3, 4)
2ndimCuántas dimensiones2
3sizeCuántos números hay en total12
4dtypeEl tipo de cada númeroint64 (entero) o float64 (decimal)
Pythonmain.py
import numpy as np

# Horas de 3 tareas durante 3 días. Una lista de listas -> una matriz.
horas = np.array([
    [1, 0, 0],
    [2, 3, 1],
    [0, 1, 1],
], dtype=np.int64)
print(horas)
print(horas.shape, horas.ndim, horas.size, horas.dtype)

# Atajos para crear sin escribir los datos.
print(np.zeros((2, 3)))
print(np.ones((2, 2), dtype=int))
print(np.full((2, 2), 7))
print(np.arange(0, 10, 2))
print(np.linspace(0, 1, 5))
print(np.eye(3))

# Números aleatorios reproducibles: la semilla (42) fija la secuencia.
rng = np.random.default_rng(42)
print(rng.integers(1, 6, size=(2, 3)))

¿Por qué? · En PHP no existe

¿Por qué todos los números de un array tienen el mismo dtype?

Porque esa es la razón de que sea rápido. Si sabe que son todos float64, NumPy sabe que el número 1.000 está exactamente 8.000 bytes después del primero y puede saltar directo, sin mirar «¿de qué tipo es este?» en cada casilla, como hace la lista.

Si mezclas tipos, NumPy elige uno que sirva para todos: con np.array([1, 2.5]) los enteros se vuelven decimales, y con np.array([1, "a"]) todo se vuelve texto ('1', 'a'). Una lista de Python admite cualquier mezcla; el array, no: la comodidad es el precio de la velocidad.

Pythonmain.py
import numpy as np

mezcla = np.array([1, 2.5, 3])
print(mezcla, mezcla.dtype)

# Convertir de tipo: astype crea un array NUEVO. Al pasar a int se TRUNCA.
print(mezcla.astype(int))

# Elegir el tipo al crear.
print(np.array([1, 2, 3], dtype=np.float64))

3 · Operaciones vectorizadas: adiós al bucle

Esta es la gran idea de NumPy. Si a es un array, a * 2 lo multiplica entero, casilla a casilla, y devuelve otro array. No escribes el bucle: lo hace NumPy por dentro, en C. A eso se le llama vectorizar.

Pythonmain.py
import numpy as np

horas = np.array([2, 5, 1, 4])
extra = np.array([1, 1, 2, 0])

# En PHP: array_map(fn($h) => $h * 2, $horas)
print(horas * 2)
print(horas + extra)
print(horas * extra)
print(horas ** 2)
print(np.sqrt(horas))

# Comparar da un array de True/False.
print(horas > 3)

# Funciones que resumen todo el array.
print(horas.sum(), horas.mean(), horas.max(), horas.min(), horas.std())
print(horas.argmax(), horas.argsort())
PHP 8.5index.php
<?php
declare(strict_types=1);

$horas = [2, 5, 1, 4];

$dobles = array_map(fn(int $h): int => $h * 2, $horas);
$total = array_sum($dobles);
$media = $total / count($dobles);

echo implode(", ", $dobles) . PHP_EOL;
echo "Total $total, media " . round($media, 2) . PHP_EOL;
Pythonmain.py
import numpy as np

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

dobles = horas * 2
total = dobles.sum()
media = dobles.mean()

print(dobles)
print(f"Total {total}, media {media:.2f}")

¿Cuánto más rápido? Mídelo tú: la misma cuenta (multiplicar por 2 y sumar 500.000 números) con una lista y un bucle, y con NumPy.

Pythonmain.py
import time

import numpy as np

n = 500_000
lista = list(range(n))
array = np.arange(n, dtype=np.int64)

inicio = time.perf_counter()
total_lista = sum([x * 2 for x in lista])
t_lista = time.perf_counter() - inicio

inicio = time.perf_counter()
total_numpy = (array * 2).sum()
t_numpy = time.perf_counter() - inicio

print("Mismo resultado:", total_lista == total_numpy)
print(f"Lista: {t_lista * 1000:.1f} ms, NumPy: {t_numpy * 1000:.1f} ms")
print(f"NumPy fue unas {t_lista / max(t_numpy, 1e-9):.0f} veces más rápido")

¿Por qué? · En PHP no existe

¿Por qué a * 2 no necesita un bucle?

El bucle existe, pero no está en Python: NumPy lo ejecuta en C, donde un bucle de 500.000 pasos es casi instantáneo. En tu código Python hay una sola operación (a * 2), y no 500.000 pasos del intérprete, cada uno con su comprobación de tipos.

Es la regla de oro: si escribes un for sobre un array de NumPy, casi seguro lo estás haciendo mal. Piensa en la operación sobre el array entero.

4 · Indexado y slicing: m[fila, columna]

Con listas de listas, m[1][2] son dos pasos y sacar una columna exige una comprensión. Con NumPy se escribe entre los mismos corchetes, separando con comas las dimensiones: m[fila, columna], y cada una admite los slices de la lección 12 (inicio:fin:paso).

Pythonmain.py
import numpy as np

horas = np.array([
    [1, 0, 0],
    [2, 3, 1],
    [0, 1, 1],
])

print(horas[1, 2])
print(horas[1])
# Una columna entera: ":" significa "todas las filas".
print(horas[:, 0])
print(horas[1:, :2])
print(horas[-1, -1])

# Cambiar una casilla, una fila entera o una columna entera.
horas[0, 1] = 9
horas[2] = 0
horas[:, 2] = [5, 5, 5]
print(horas)

Además hay una forma potentísima de filtrar: la máscara. Una comparación da un array de True/False y, si lo usas como índice, te quedas con las casillas que valen True.

Pythonmain.py
import numpy as np

horas = np.array([
    [1, 0, 4],
    [2, 3, 1],
    [0, 1, 6],
])

# En PHP: array_filter(...) sobre cada fila y aplanar.
mascara = horas >= 3
print(mascara)
print(horas[mascara])

# Se puede escribir directo, y también asignar con la máscara.
print(horas[horas > 2])
horas[horas > 2] = 2
print(horas)

# Filas que cumplen algo sobre una columna.
tareas = np.array([[1, 5], [4, 2], [3, 7]])
print(tareas[tareas[:, 1] > 4])

¿Por qué? · En PHP no existe

¿Por qué un slice de NumPy NO es una copia, como en las listas?

En una lista, lista[1:3] crea una lista nueva. En NumPy, m[1:3] es una vista: otra forma de mirar el mismo bloque de memoria, sin copiar nada. Es lo que hace posible trabajar con arrays gigantes (copiar una matriz de 1 GB cada vez que cortas sería inviable).

La consecuencia es la trampa del módulo 04: si cambias la vista, cambias el original. Si quieres una copia independiente, pídela con .copy().

Pythonmain.py
import numpy as np

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

vista = m[0]
vista[0] = 99
print(m)

copia = m[1].copy()
copia[0] = -1
print(m)

5 · Cambiar la forma: reshape y transponer

Los mismos números se pueden reorganizar en otra forma, mientras el total encaje. Es como pasar de una barra de chocolate de 12 onzas a una de 3 filas × 4 columnas: ni más ni menos chocolate, solo distinto reparto.

Pythonmain.py
import numpy as np

a = np.arange(12)
print(a)

m = a.reshape(3, 4)
print(m)
print(m.shape)

# -1 significa "calcula tú este tamaño".
print(a.reshape(2, -1).shape)
print(a.reshape(-1, 6).shape)

# Transponer: .T (no copia: es otra vista).
print(m.T)
print(m.T.shape)

# Aplanar a una dimensión.
print(m.ravel())

# Si los números no encajan, falla.
try:
    a.reshape(5, 3)
except ValueError as error:
    print("ValueError:", error)

6 · axis: sumar por filas o por columnas

sum, mean, max, min, std… admiten un parámetro axis: en qué dirección resumir. Es lo que más cuesta al principio, así que va una regla para no olvidarla: el eje que pones es el que desaparece.

Pythonmain.py
import numpy as np

# 3 tareas (filas) x 3 días (columnas)
horas = np.array([
    [1, 0, 0],
    [2, 3, 1],
    [0, 1, 1],
])

print(horas.sum())
print(horas.sum(axis=0), horas.sum(axis=0).shape)
print(horas.sum(axis=1), horas.sum(axis=1).shape)
print(horas.mean(axis=0))
print(horas.max(axis=1))
print(horas.argmax(axis=1))
#Quiero…CódigoResultado con 3 tareas x 3 díasCon listas (lección 16)
1El totalhoras.sum()un númerosum(sum(f) for f in m)
2Una cifra por día (desaparecen las filas)horas.sum(axis=0)shape (3,)[sum(c) for c in zip(*m)]
3Una cifra por tarea (desaparecen las columnas)horas.sum(axis=1)shape (3,)[sum(f) for f in m]

¿Por qué? · En PHP no existe

¿Por qué axis=0 suma hacia abajo (por columnas)?

Porque axis=0 es el eje de las filas: el primero de shape, (filas, columnas). Sumar a lo largo de ese eje es recorrer las filas (de arriba abajo) y colapsarlas en una sola: queda una cifra por cada columna. Con axis=1 colapsas las columnas y queda una cifra por cada fila.

Truco para no liarse: mira el shape del resultado. Con (3, 3) y axis=0 el resultado es (3,): se ha ido la primera dimensión, la de las filas.

7 · Broadcasting: operar arrays de distinta forma

¿Qué pasa si restas a una matriz de 3 × 2 un array de 2 números? En una lista sería un error. NumPy estira el pequeño: lo repite en cada fila, sin copiarlo, como una emisora que llega a todas las casas. Así «restar a cada columna su media» es una línea.

Pythonmain.py
import numpy as np

# 3 tareas x 2 características: horas y prioridad.
x = np.array([
    [1.0, 5.0],
    [4.0, 1.0],
    [2.0, 3.0],
])

medias = x.mean(axis=0)
print(medias, medias.shape)

# (3, 2) - (2,): el vector de medias se aplica a cada fila.
centrada = x - medias
print(centrada)

# Un número también se "estira" a todo el array.
print(x * 10)

# Normalizar (z-score): restar la media y dividir por la desviación de CADA columna.
z = (x - x.mean(axis=0)) / x.std(axis=0)
print(z.round(2))
print(z.mean(axis=0).round(6), z.std(axis=0))

La regla para saber si dos formas encajan: se comparan de derecha a izquierda, dimensión a dimensión, y encajan si son iguales o si una de las dos es 1 (o falta). Si no, error:

#Forma AForma B¿Encaja?Resultado
1(3, 2)(2,)Sí(3, 2)
2(3, 2)(3, 1)Sí (la columna se estira)(3, 2)
3(3, 2)(3,)No (2 frente a 3)ValueError
4(3, 2)() (un número)Sí(3, 2)
Pythonmain.py
import numpy as np

x = np.ones((3, 2))

# Columna de 3 valores: forma (3, 1) -> se estira a lo ancho.
por_tarea = np.array([[10], [20], [30]])
print(x * por_tarea)

# Un vector de 3 con una matriz (3, 2) NO encaja.
try:
    x - np.array([1.0, 2.0, 3.0])
except ValueError as error:
    print("ValueError:", error)

¿Por qué? · En PHP no existe

¿Por qué existe el broadcasting? En PHP no hay nada parecido

Porque en ML casi todo es «aplica esta cosa pequeña a todas las filas»: restar las medias, multiplicar por unos pesos, sumar un sesgo. Sin broadcasting tendrías que repetir el array pequeño a mano hasta igualar el grande (gastando memoria) o escribir el bucle. En PHP sería un array_map dentro de otro array_map.

La contrapartida: es una fuente de errores silenciosos. Si las formas encajan «de rebote» (una matriz cuadrada con un vector, sin que tú lo pensaras), NumPy no se queja y el resultado sale mal. Por eso conviene mirar siempre .shape.

8 · Producto de matrices con @

Atención al primer tropiezo: en NumPy el * multiplica casilla a casilla. El producto de matrices (el de la lección anterior, fila × columna) es el operador @. Y confundirlos no da error, da otro resultado.

Pythonmain.py
import numpy as np

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

# * : casilla con casilla.
print(a * b)
# @ : producto de matrices (fila de a por columna de b).
print(a @ b)
print(np.dot(a, b))

# Matriz por vector: el caso más frecuente en ML.
v = np.array([10, 1])
print(a @ v)

# Las formas tienen que encajar: (n, m) @ (m, p) -> (n, p)
try:
    a @ np.ones((3, 3))
except ValueError as error:
    print("ValueError:", error)

Ahora lo de la lección anterior (3 tareas × 2 características, con 2 fórmulas de pesos) en una línea, y comparado con el triple bucle de listas:

Pythonmain.py
import numpy as np

caracteristicas = np.array([
    [1, 3],
    [4, 2],
    [2, 1],
])
pesos = np.array([
    [10, 1],
    [5, 2],
])

print(caracteristicas @ pesos)

# El mismo cálculo, con listas y tres bucles (lección 16).
a = caracteristicas.tolist()
b = pesos.tolist()
resultado = [[0] * 2 for _ in range(3)]
for i in range(3):
    for j in range(2):
        for k in range(2):
            resultado[i][j] += a[i][k] * b[k][j]
print(resultado == (caracteristicas @ pesos).tolist())

¿Por qué? · En PHP no existe

¿Por qué la multiplicación de matrices es la operación del machine learning?

Porque un modelo simple es una suma ponderada: cada característica tiene un peso (cuánto importa) y la predicción es la suma de característica × peso. Para una tarea eso es una fila por un vector. Para todas las tareas a la vez, es la matriz entera por el vector de pesos: X @ pesos. Una línea.

Las redes neuronales (lo que hay detrás de ChatGPT) son muchas de estas multiplicaciones una detrás de otra, con matrices de millones de números. Por eso los chips de ML (GPU) son, en el fondo, máquinas de multiplicar matrices.

9 · Todo junto: un mini modelo de tareas

Juntamos lo aprendido en un ejemplo de ML de juguete. Cada fila es una tarea y las columnas son [horas que creías, prioridad, nº de subtareas]. Con unos pesos sacamos cuánto tardará de verdad, y con la media de los errores, si el modelo acierta.

Pythonmain.py
import numpy as np

# 4 muestras (tareas) x 3 características.
x = np.array([
    [1.0, 1, 0],
    [2.0, 3, 2],
    [4.0, 2, 3],
    [3.0, 5, 1],
])
# Lo que tardaron de verdad (una cifra por tarea).
reales = np.array([1.5, 4.0, 6.0, 5.5])

# 1. Normalizar cada columna (media 0, desviación 1).
x_norm = (x - x.mean(axis=0)) / x.std(axis=0)

# 2. Unos pesos inventados: cuánto pesa cada característica.
pesos = np.array([1.2, 0.8, 0.5])

# 3. Predicción para TODAS las tareas a la vez: matriz @ vector.
prediccion = x_norm @ pesos + reales.mean()
print(prediccion.round(2))

# 4. Error medio absoluto.
error = np.abs(prediccion - reales).mean()
print(f"Error medio: {error:.2f} horas")
print(x.shape, x_norm.shape, pesos.shape, prediccion.shape)

La pregunta que te vas a hacer

Vale, pero… ¿cómo lo instalo en mi ordenador y qué aprendo después?

Con pip install numpy dentro de un entorno virtual (lo verás en la lección 36). Después, el camino habitual: pandas para tablas con nombres de columna y scikit-learn para entrenar modelos sin escribir las cuentas tú.

Hora de practicar

Retos · 0/4 resueltos

Reto 1 de 4

Forma y total

Con el array horas (2 tareas × 3 días), imprime su forma y el total de horas en la misma línea: (2, 3) 12. Usa shape y sum().

Al pulsar Comprobar, unos tests ocultos prueban tu código en tu navegador, con Python 3.14.

Pythonmain.py · editable

Resumen

Lo que te llevas de esta lección

  1. Un ndarray guarda números del mismo dtype en un bloque seguido y conoce su shape (en PHP, un array de arrays sin tipo ni forma).
  2. Vectoriza: a * 2, a + b, a > 3 actúan sobre todo el array sin for (en PHP, array_map y bucles). Un for sobre un array de NumPy casi siempre está mal.
  3. Indexa con m[fila, columna], m[:, 0] (una columna) y máscaras m[m > 3]; un slice es una vista, no una copia (usa .copy()).
  4. axis: el eje que pones es el que desaparece. sum(axis=0) una cifra por columna; sum(axis=1), una por fila.
  5. @ es el producto de matrices y * el de casilla a casilla. Broadcasting estira lo pequeño a lo grande si las formas encajan (se comparan de derecha a izquierda).

Para recordarlo: «Forma, Tipo, Eje, Arroba»

FForma
shape: mírala antes de operar
TTipo
dtype: uno solo para todos los números
EEje
axis: el que pones es el que desaparece
AArroba
@ multiplica matrices, * casilla a casilla

Para el ML: filas = muestras, columnas = características, X @ pesos = predicción. Y si dudas de una operación, imprime .shape.