Lección 17 de 47 · Colecciones en acción y matrices✦ WebMCP implementado
Matrices con listas de listas (y sus límites)
10 min de lectura4 retos
Una matriz es una tabla de números con filas y columnas, como una hoja de cálculo. Es la estructura más usada en machine learning: casi todos los datos que se le dan a un modelo son una matriz. Aquí aprendes a construirla con listas de listas, a esquivar su trampa más famosa ([[0] * 3] * 3), a transponerla y a multiplicarla a mano, y ves dónde se queda corta para dar el salto a NumPy.
¿De dónde vienen los nombres?
matriz = del latín matrix (madre; lugar donde algo se origina). El matemático J. J. Sylvester la usó en 1850 para esto
En programación, una tabla de valores en filas y columnas. En PHP: un array de arrays.
fila y columna = las filas van en horizontal (como las filas de un cine) y las columnas en vertical (como las columnas de un edificio)
m[2][0] es la fila 2, columna 0: primero la fila, después la columna.
transponer = trans- (al otro lado) + poner
Darle la vuelta a una matriz: las filas pasan a ser columnas. La matriz «traspuesta» o «transpuesta».
muestra y característica = en inglés sample y feature
En machine learning, cada fila es una muestra (un caso: una tarea) y cada columna una característica (un dato de ese caso: sus horas, su prioridad).
En 4 ideas
1/4
Una matriz es una lista de listas: m[fila][columna]. Es el array de arrays de PHP, con la misma sintaxis de acceso $m[$i][$j].
Trampa: [[0] * 3] * 3 no crea 3 filas, crea una fila repetida 3 veces (la misma). Cambias una y cambian las tres. Se arregla con [[0] * 3 for _ in range(3)]. En PHP no pasa, porque los arrays se copian al asignarse.
zip(*m)transpone una matriz en una línea (el array_map(null, ...$m) de PHP). Las operaciones (sumar filas, multiplicar matrices) se hacen con comprensiones, sin triples bucles.
Las listas sirven para aprender, pero se quedan cortas: son lentas, no tienen forma fija y no saben operar (m * 2 no multiplica). Por eso en ciencia de datos se usa NumPy, la próxima lección.
1 · Qué es una matriz (y por qué importa en machine learning)
Piensa en una hoja de cálculo. Tienes filas (1, 2, 3…) y columnas (A, B, C…), y en cada casilla un número. Eso es una matriz. En la app de tareas: una fila por tarea y una columna por día de la semana, con las horas que le dedicas a cada una.
#
Tarea
Lunes
Martes
Miércoles
1
Comprar pan
1
0
0
2
Repasar Python
2
3
1
3
Hacer deporte
0
1
1
Y la pregunta: ¿por qué todo el machine learning (ML) se hace con matrices? Te lo explico con cromos de fútbol.
¿Por qué? · En PHP no existe
Explicado para un chaval de 12 años: ¿qué es una matriz en machine learning?
Imagina que tienes 100 cromos de jugadores. Cada cromo tiene datos: goles, pases y altura. Los anotas en una tabla: una fila por cromo y una columna por dato. Eso es una matriz de 100 filas y 3 columnas.
Ahora quieres que un ordenador aprenda a adivinar si un jugador es bueno. No le enseñas «reglas»: le das la tabla y las respuestas de los que ya conoces. El ordenador mira la tabla una y otra vez, haciendo cuentas con todas las filas a la vez, hasta encontrar qué combinación de goles, pases y altura suele dar un jugador bueno.
En el lenguaje de ML: cada fila es una muestra (un caso, un cromo) y cada columna una característica (feature: un dato de ese caso). Las cuentas del aprendizaje son, casi todas, sumas y multiplicaciones de matrices. Por eso un ordenador de ML es una máquina de multiplicar matrices enormes.
En nuestra app de tareas sería: una fila por tarea y columnas [horas estimadas, prioridad, nº de subtareas]. Con eso se podría entrenar un modelo que adivine cuánto tardarás en una tarea nueva.
2 · Una matriz es una lista de listas
En Python no hay un tipo «matriz» (lo trae NumPy, en la lección 17). Se hace con una lista cuyos elementos son listas: cada lista de dentro es una fila.
Pythonmain.py
# Filas = tareas, columnas = lunes, martes, miércoles.
horas = [
[1, 0, 0],
[2, 3, 1],
[0, 1, 1],
]
# Primero la fila, después la columna. En PHP: $horas[1][2]print(horas[1][2])
# Cuántas filas y cuántas columnas.
filas = len(horas)
columnas = len(horas[0])
print(filas, columnas)
# Una fila entera, y una columna (hay que construirla).print(horas[1])
print([fila[0] for fila in horas])
# Cambiar una casilla.
horas[0][1] = 5print(horas)
# Recorrer todas las casillas: aquí SÍ hacen falta dos for.for numero_fila, fila inenumerate(horas):
for numero_columna, valor inenumerate(fila):
if valor > 2:
print(f"fila {numero_fila}, columna {numero_columna}: {valor}")
3 · La trampa de [[0] * 3] * 3
Para crear una matriz de ceros, lo más tentador es multiplicar: «una fila de tres ceros» ([0] * 3) y «repítela tres veces» (* 3). Y parece que funciona. Mira qué pasa al cambiar una sola casilla:
Pythonmain.py
mal = [[0] * 3] * 3print(mal)
# Cambio UNA casilla: la fila 0, columna 1.
mal[0][1] = 7print(mal)
# ¿Por qué? Las tres "filas" son la MISMA lista.print(mal[0] is mal[1], mal[1] is mal[2])
print(id(mal[0]) == id(mal[2]))
¿Por qué? · En PHP no existe
¿Por qué [[0] * 3] * 3 se rompe? En PHP no existe
En Python, una lista guarda referencias (flechas) a los objetos, no los objetos mismos. [0] * 3 crea una fila nueva con tres flechas al 0 (un número no cambia, así que da igual compartirlo). Pero [fila] * 3 crea una lista con tres flechas a la misma fila: no la copia. Es como dar a tres amigos la llave del mismo armario: si uno lo desordena, lo ven los tres.
En PHP no existe esta trampa, porque un array se copia al asignarlo: array_fill(0, 3, array_fill(0, 3, 0)) da tres filas independientes. En Python las listas son objetos que se comparten, y esa es una decisión de diseño con ventajas (no copia datos grandes sin necesidad), pero obliga a saber esto. Lo verás a fondo en el módulo 04.
El arreglo: construir cada fila por separado, con una comprensión. La _ es solo el nombre de una variable que no vas a usar.
Pythonmain.py
bien = [[0] * 3for _ inrange(3)]
bien[0][1] = 7print(bien)
print(bien[0] is bien[1])
# El mismo patrón para cualquier tamaño y valor.defcrea_matriz(filas, columnas, valor=0):
return [[valor] * columnas for _ inrange(filas)]
print(crea_matriz(2, 4, -1))
Las cuentas típicas con una matriz: sumar cada fila, sumar cada columna y sacar el total. Con lo que ya sabes de sum y las comprensiones no hace falta ningún doble bucle.
Pythonmain.py
horas = [
[1, 0, 0],
[2, 3, 1],
[0, 1, 1],
]
# Horas por tarea (suma de cada fila). En PHP: array_map("array_sum", $horas)
por_tarea = [sum(fila) for fila in horas]
print(por_tarea)
# Horas por día (suma de cada columna): zip(*horas) da las columnas.
por_dia = [sum(columna) for columna inzip(*horas)]
print(por_dia)
# Total de todo.
total = sum(sum(fila) for fila in horas)
print(total)
# La tarea con más horas (índice de la fila) y su día más cargado.
mas_cargada = max(range(len(horas)), key=lambda i: por_tarea[i])
print(mas_cargada, horas[mas_cargada])
# Aplicar algo a cada casilla: una comprensión dentro de otra.
dobles = [[2 * valor for valor in fila] for fila in horas]
print(dobles)
Fíjate en la comprensión [[… for valor in fila] for fila in horas]: la de dentro construye cada fila y la de fuera junta las filas. No es lo mismo que la comprensión con dos for de la lección 15 (que aplana): aquí los for van en corchetes distintos y el resultado sigue siendo una matriz.
5 · Transponer con zip(*m)
Transponer es girar la tabla: lo que eran filas pasan a ser columnas. Una matriz de 3 filas × 2 columnas se vuelve de 2 filas × 3 columnas. Es una operación constante en ML (para alinear las dimensiones antes de multiplicar).
Pythonmain.py
m = [
[1, 2],
[3, 4],
[5, 6],
]
# En PHP: array_map(null, ...$m)
traspuesta = list(zip(*m))
print(traspuesta)
# zip da TUPLAS. Para volver a listas de listas:
traspuesta = [list(columna) for columna inzip(*m)]
print(traspuesta)
# Transponer dos veces devuelve la original.print([list(f) for f inzip(*traspuesta)] == m)
¿Por qué? · En PHP no existe
¿Cómo funciona zip(*m)? No es magia
Son dos piezas que ya conoces. *m reparte las filas de m como argumentos sueltos: es lo mismo que escribir zip([1, 2], [3, 4], [5, 6]). Y zip junta «el primero de cada lista», luego «el segundo de cada lista»: es decir, las columnas.
En PHP se hace con array_map(null, ...$m), que tiene un fallo conocido: si la matriz tiene una sola fila, array_map con null no transpone, devuelve la fila tal cual. El zip(*m) de Python funciona siempre.
import json
m = [[1, 2], [3, 4], [5, 6]]
traspuesta = [list(columna) for columna inzip(*m)]
print(json.dumps(traspuesta))
6 · Multiplicar matrices a mano
Multiplicar matrices es la operación central del machine learning. La regla del juego: cada casilla del resultado es la fila de la primera por la columna de la segunda: multiplicas casilla a casilla y sumas. (A esa cuenta se le llama producto escalar.)
Para poder multiplicar A × B, las columnas de A tienen que ser igual a las filas de B: una de 2 × 3 con una de 3 × 4 da una de 2 × 4. Si no coinciden, no se puede.
La casilla [i][j] del resultado = suma de A[i][k] * B[k][j] para todos los k.
Con un ejemplo de la app: tienes las horas estimadas y la prioridad de 3 tareas, y quieres saber la «puntuación» de cada una con dos fórmulas distintas (dos pesos cada una). Cada fórmula es una columna de la segunda matriz.
Pythonmain.py
# 3 tareas x 2 características (horas, prioridad).
caracteristicas = [
[1, 3],
[4, 2],
[2, 1],
]
# 2 características x 2 fórmulas (pesos).
pesos = [
[10, 1],
[5, 2],
]
defproducto_con_bucles(a, b):
# Tres bucles: el caso clásico (aquí el triple for es el algoritmo).
filas, medio, columnas = len(a), len(b), len(b[0])
resultado = [[0] * columnas for _ inrange(filas)]
for i inrange(filas):
for j inrange(columnas):
for k inrange(medio):
resultado[i][j] += a[i][k] * b[k][j]
return resultado
defproducto(a, b):
# La misma cuenta con zip y sum: cada casilla es "fila de a por columna de b".
columnas_de_b = list(zip(*b))
return [
[sum(x * y for x, y inzip(fila, columna)) for columna in columnas_de_b]
for fila in a
]
print(producto_con_bucles(caracteristicas, pesos))
print(producto(caracteristicas, pesos))
print(producto(caracteristicas, pesos) == producto_con_bucles(caracteristicas, pesos))
¿Por qué? · En PHP no existe
¿Por qué tres bucles aquí sí está bien?
Porque el producto de matrices de verdad necesita cada combinación de i, j y k (n × m × p operaciones). No es una búsqueda disfrazada: es el cálculo en sí. Pero es muy lento en Python: una matriz de 1.000 × 1.000 por otra igual son mil millones de multiplicaciones, que en bucles de Python son minutos. Por eso NumPy existe (siguiente lección).
7 · Un clásico de ML: normalizar columnas
Antes de dar una matriz a un modelo se normaliza: se pone cada columna en la misma escala. Si una columna son horas (1-8) y otra son euros (1000-5000), la de los euros «pesa» más solo por ser un número grande, y el modelo se confunde. La forma más simple, min-max: cada valor pasa a ser un número entre 0 y 1 (0 = el más pequeño de su columna, 1 = el mayor).
Pythonmain.py
# Columnas: horas estimadas y prioridad (1 a 5).
caracteristicas = [
[1, 5],
[4, 1],
[2, 3],
]
defnormaliza(m):
# Se trabaja por columnas: se transpone, se normaliza cada una, se vuelve a transponer.
columnas = []
for columna inzip(*m):
menor, mayor = min(columna), max(columna)
rango = mayor - menor
columnas.append([0.0if rango == 0else (v - menor) / rango for v in columna])
return [list(fila) for fila inzip(*columnas)]
for fila innormaliza(caracteristicas):
print([round(v, 2) for v in fila])
8 · Los límites de las listas de listas
Todo lo de arriba funciona, pero ves el patrón: mucha ceremonia (zip, comprensiones dentro de comprensiones, _ y range) y ninguna ayuda. Una lista de listas no sabe que es una matriz. Mira lo que no hace:
Pythonmain.py
m = [[1, 2], [3, 4]]
# "Multiplicar por 2" REPITE la lista, no multiplica los números.print(m * 2)
# Sumar un número, tampoco.try:
m + 1exceptTypeErroras error:
print("TypeError:", error)
# Extraer una columna entera con corchetes, tampoco.try:
m[:, 0]
exceptTypeErroras error:
print("TypeError:", error)
# Y nada impide una "matriz" con filas de distinto largo.
rota = [[1, 2, 3], [4, 5], [6]]
print(len(rota), [len(f) for f in rota])
#
Lo que necesitas
Lista de listas
NumPy (lección 17)
1
Multiplicar cada casilla por 2
[[2 * v for v in f] for f in m]
m * 2
2
Una columna
[f[0] for f in m]
m[:, 0]
3
Transponer
[list(c) for c in zip(*m)]
m.T
4
Multiplicar dos matrices
Triple bucle o zip+sum
a @ b
5
Suma por columnas
[sum(c) for c in zip(*m)]
m.sum(axis=0)
6
Forma y tipo fijos
No: cada fila puede ser distinta
Sí: shape y dtype
7
Velocidad con millones de números
Lenta (objetos de Python)
Muy rápida (bloque de memoria en C)
La pregunta que te vas a hacer
Vale, pero… ¿y en PHP hay algo parecido a una matriz de verdad?
PHP no trae matrices numéricas: solo arrays anidados, con las mismas limitaciones. Hay bibliotecas en Composer, pero el ecosistema de ciencia de datos (NumPy, pandas, scikit-learn, PyTorch) está en Python, y por eso es el lenguaje del machine learning.
Crea la matriz semana de 2 tareas × 3 días llena de ceros (sin la trampa del *), apunta 5 horas en la fila 0, columna 1, e imprímela. Salida: [[0, 5, 0], [0, 0, 0]]. Es el array_fill anidado de PHP.
Al pulsar Comprobar, unos tests ocultos prueban tu código en tu navegador, con Python 3.14.
Pythonmain.py · editable
Pista. Cada fila tiene que ser una lista distinta: construye las filas con [[0] * 3 for _ in range(2)].
Reto 2 de 4 · ✓ Resuelto
La función crea_matriz
Escribe crea_matriz(filas, columnas, valor=0): devuelve una matriz (lista de listas) de filas × columnas llena de valor, con todas las filas independientes (cambiar una casilla no puede alterar otra fila).
Al pulsar Comprobar, unos tests ocultos prueban tu código en tu navegador, con Python 3.14.
Pythonmain.py · editable
Pista. El * filas de fuera es lo que repite la misma lista. Cámbialo por una comprensión for _ in range(filas).
Reto 3 de 4 · ✓ Resuelto
Traspón la matriz
Escribe transpuesta(m): devuelve la matriz transpuesta como lista de listas (no tuplas). Una matriz vacía [] devuelve []. Es el array_map(null, ...$m) de PHP.
Al pulsar Comprobar, unos tests ocultos prueban tu código en tu navegador, con Python 3.14.
Pythonmain.py · editable
Pista.zip(*m) da las columnas, pero como tuplas: conviértelas con list(columna) en una comprensión.
Reto 4 de 4 · ✓ Resuelto
Multiplica dos matrices
Escribe producto(a, b): devuelve el producto de las matrices a y b (listas de listas). Si las columnas de a no son iguales a las filas de b, lanza ValueError. Ejemplo: producto([[1, 2], [3, 4]], [[5], [6]]) es [[17], [39]].
Al pulsar Comprobar, unos tests ocultos prueban tu código en tu navegador, con Python 3.14.
Pythonmain.py · editable
Pista. Comprueba primero len(a[0]) != len(b) y lanza el error. Después, cada casilla es sum(x * y for x, y in zip(fila_de_a, columna_de_b)); las columnas de b salen con zip(*b).
Resumen
Lo que te llevas de esta lección
Una matriz es una lista de listas: m[fila][columna] (en PHP, $m[$i][$j]). En ML, fila = muestra, columna = característica.
[[0] * 3] * 3 es una trampa: repite la misma fila. Usa [[0] * 3 for _ in range(3)] (en PHP, array_fill copia solo y no tiene este fallo).
zip(*m) transpone (en PHP, array_map(null, ...$m)); sum(fila) suma una fila y [sum(c) for c in zip(*m)], cada columna.
Producto de matrices: columnas de A = filas de B; cada casilla es fila × columna. A mano es un triple bucle: lento (en PHP, tres foreach).
Las listas no saben operar, ni tienen forma fija, ni son rápidas: para eso, NumPy.
Para recordarlo: «Filas = Muestras, Columnas = Características»
FFila una muestra (un caso)
CColumna una característica (un dato)
PPor [[0]*3]*3 repite la MISMA fila
Y para la trampa: «para repetir algo que cambia, comprensión; para repetir un número, *».