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 17 de 47 · Colecciones en acción y matrices ✦ WebMCP implementado

Matrices con listas de listas (y sus límites)

10 min de lectura 4 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].

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.

#TareaLunesMartesMiércoles
1Comprar pan100
2Repasar Python231
3Hacer deporte011

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] = 5
print(horas)

# Recorrer todas las casillas: aquí SÍ hacen falta dos for.
for numero_fila, fila in enumerate(horas):
    for numero_columna, valor in enumerate(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] * 3
print(mal)

# Cambio UNA casilla: la fila 0, columna 1.
mal[0][1] = 7
print(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] * 3 for _ in range(3)]
bien[0][1] = 7
print(bien)
print(bien[0] is bien[1])

# El mismo patrón para cualquier tamaño y valor.
def crea_matriz(filas, columnas, valor=0):
    return [[valor] * columnas for _ in range(filas)]


print(crea_matriz(2, 4, -1))
PHP 8.5index.php
<?php
declare(strict_types=1);

$m = array_fill(0, 3, array_fill(0, 3, 0));
$m[0][1] = 7;

echo json_encode($m) . PHP_EOL;
Pythonmain.py
import json

m = [[0] * 3 for _ in range(3)]
m[0][1] = 7

print(json.dumps(m))

4 · Recorrer y resumir: filas, columnas y total

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 in zip(*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 in zip(*m)]
print(traspuesta)

# Transponer dos veces devuelve la original.
print([list(f) for f in zip(*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.

PHP 8.5index.php
<?php
declare(strict_types=1);

$m = [[1, 2], [3, 4], [5, 6]];
$traspuesta = array_map(null, ...$m);

echo json_encode($traspuesta) . PHP_EOL;
Pythonmain.py
import json

m = [[1, 2], [3, 4], [5, 6]]
traspuesta = [list(columna) for columna in zip(*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],
]


def producto_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 _ in range(filas)]
    for i in range(filas):
        for j in range(columnas):
            for k in range(medio):
                resultado[i][j] += a[i][k] * b[k][j]
    return resultado


def producto(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 in zip(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],
]


def normaliza(m):
    # Se trabaja por columnas: se transpone, se normaliza cada una, se vuelve a transponer.
    columnas = []
    for columna in zip(*m):
        menor, mayor = min(columna), max(columna)
        rango = mayor - menor
        columnas.append([0.0 if rango == 0 else (v - menor) / rango for v in columna])
    return [list(fila) for fila in zip(*columnas)]


for fila in normaliza(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 + 1
except TypeError as error:
    print("TypeError:", error)

# Extraer una columna entera con corchetes, tampoco.
try:
    m[:, 0]
except TypeError as 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 necesitasLista de listasNumPy (lección 17)
1Multiplicar cada casilla por 2[[2 * v for v in f] for f in m]m * 2
2Una columna[f[0] for f in m]m[:, 0]
3Transponer[list(c) for c in zip(*m)]m.T
4Multiplicar dos matricesTriple bucle o zip+suma @ b
5Suma por columnas[sum(c) for c in zip(*m)]m.sum(axis=0)
6Forma y tipo fijosNo: cada fila puede ser distintaSí: shape y dtype
7Velocidad con millones de númerosLenta (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.

Hora de practicar

Retos · 0/4 resueltos

Reto 1 de 4

Una semana en blanco

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

Resumen

Lo que te llevas de esta lección

  1. Una matriz es una lista de listas: m[fila][columna] (en PHP, $m[$i][$j]). En ML, fila = muestra, columna = característica.
  2. [[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).
  3. zip(*m) transpone (en PHP, array_map(null, ...$m)); sum(fila) suma una fila y [sum(c) for c in zip(*m)], cada columna.
  4. 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).
  5. 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, *».