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

lambda, map, filter, sum, min, max y zip

10 min de lectura 4 retos

Una lambda es una función diminuta sin nombre que escribes en una línea, justo donde la necesitas. Con ella y unas cuantas funciones (sorted, map, filter, reduce, sum, min, max, any, all, zip, enumerate) haces en una línea lo que en PHP eran un usort o un foreach. Y aprendes cuándo es mejor una comprensión, que será casi siempre.

¿De dónde vienen los nombres?

lambda = la letra griega λ (lambda) del cálculo lambda, un sistema matemático de funciones de los años 30
Python tomó la palabra de los lenguajes funcionales (como Lisp). Significa «una función anónima». En PHP: fn($x) => ….
key = inglés key (clave, llave)
En sorted(..., key=f) es la función que dice por qué ordenar: «ordena por este valor». No tiene que ver con las claves de un diccionario.
map = inglés map (mapa) en el sentido matemático de «transformar cada elemento»
Aplica una función a cada elemento. Es el array_map de PHP.
filter = inglés filter (filtro)
Se queda con los elementos que cumplen una condición. Es el array_filter de PHP.
reduce = inglés reduce (reducir)
Va juntando todos los elementos en uno solo. Es el array_reduce de PHP. Vive en el módulo functools (functional tools, herramientas funcionales).
zip = inglés zip (cremallera)
Junta dos listas como los dientes de una cremallera: el primero con el primero, el segundo con el segundo…
enumerate = inglés enumerate (enumerar, numerar)
Te da cada elemento con su número: el foreach ($a as $i => $v) de PHP.
En 4 ideas
1/4

lambda x: x * 2 es una función sin nombre de una sola expresión. Es el fn($x) => $x * 2 de PHP, con otra sintaxis y la misma limitación: no hay bloques de varias líneas.

1 · lambda: una función sin nombre

Una función normal tiene nombre porque la vas a llamar muchas veces. A veces necesitas una funcioncilla una sola vez, para pasársela a otra función. Ponerle nombre es como bautizar a un vaso de usar y tirar. La lambda es esa función sin bautizar.

Pythonmain.py
# Una función normal.
def doble(n):
    return n * 2


# La misma, como lambda: "lambda <parámetros>: <expresión>"
# En PHP: $doble = fn(int $n): int => $n * 2;
doble_lambda = lambda n: n * 2
print(doble(4), doble_lambda(4))

# Con varios parámetros y con valor por defecto.
suma = lambda a, b=10: a + b
print(suma(1, 2), suma(1))

# Lo normal: usarla en el sitio, sin guardarla en ninguna variable.
print((lambda titulo: titulo.upper())("comprar pan"))

¿Por qué? · En PHP no existe

¿Por qué una lambda solo puede tener UNA expresión?

Porque en Python los bloques se marcan con indentación y los saltos de línea, y eso no cabe dentro de una expresión, que es lo que va en medio de otra línea (sorted(lista, key=…)). No hay fn($x) { … return …; } con llaves. Si tu función necesita más de una línea, escribe una def con su nombre.

Eso es bueno: obliga a que lo que va en una lambda sea pequeño. Una lambda que no cabe en una línea ya era una función disfrazada.

2 · sorted y key: ordenar por lo que quieras

Ordenar números es fácil. Ordenar tareas (diccionarios) no: ¿por qué campo? Con key le pasas una función que, dada una tarea, devuelve el valor por el que ordenar.

Pythonmain.py
tareas = [
    {"titulo": "Llamar al banco", "prioridad": 2, "horas": 1},
    {"titulo": "Comprar pan", "prioridad": 3, "horas": 1},
    {"titulo": "Repasar Python", "prioridad": 3, "horas": 4},
    {"titulo": "Hacer deporte", "prioridad": 1, "horas": 2},
]

# En PHP: usort($tareas, fn($a, $b) => $a["horas"] <=> $b["horas"]);
por_horas = sorted(tareas, key=lambda t: t["horas"])
print([t["titulo"] for t in por_horas])

# Al revés: reverse=True.
print([t["titulo"] for t in sorted(tareas, key=lambda t: t["horas"], reverse=True)])

# Por varios criterios: devuelve una TUPLA.
# Primero prioridad (la mayor primero: negativa) y, si empatan, el título.
orden = sorted(tareas, key=lambda t: (-t["prioridad"], t["titulo"]))
print([t["titulo"] for t in orden])

# min y max también aceptan key.
print(max(tareas, key=lambda t: t["horas"])["titulo"])
print(min(tareas, key=lambda t: t["prioridad"])["titulo"])

# Ordenar textos sin distinguir mayúsculas.
print(sorted(["pan", "Leche", "agua"], key=str.lower))

¿Por qué? · En PHP no existe

¿Por qué key y no una función de comparación como usort?

En PHP, usort te pide una función que compare dos elementos ($a <=> $b) y se llama muchas veces por elemento. Con key, Python llama a tu función una vez por elemento, guarda el resultado y ordena con eso. Es más rápido y más fácil de escribir: solo dices por qué ordenar, no cómo comparar.

Y para ordenar por varios criterios basta devolver una tupla: Python las compara de izquierda a derecha, como ordenas un diccionario de papel: por la primera letra y, si empatan, por la segunda.

3 · map, filter y reduce

Las tres funciones del mundo funcional. Piensa en una cadena de montaje: map cambia cada pieza, filter tira las que no sirven y reduce junta todas en una caja.

Pythonmain.py
from functools import reduce

horas = [2, 5, 1, 4]

# En PHP: array_map(fn($h) => $h * 2, $horas)
dobles = map(lambda h: h * 2, horas)
print(dobles)
print(list(dobles))

# En PHP: array_values(array_filter($horas, fn($h) => $h >= 3))
largas = filter(lambda h: h >= 3, horas)
print(list(largas))

# En PHP: array_reduce($horas, fn($acc, $h) => $acc + $h, 0)
total = reduce(lambda acc, h: acc + h, horas, 0)
print(total)

# reduce sirve para juntar cosas de cualquier tipo: aquí, diccionarios.
partes = [{"a": 1}, {"b": 2}, {"c": 3}]
print(reduce(lambda acc, d: acc | d, partes, {}))

# map con una función que ya existe: no hace falta lambda.
print(list(map(str.upper, ["pan", "leche"])))
print(list(map(int, ["1", "2", "3"])))

¿Por qué? · En PHP no existe

¿Por qué map y filter devuelven algo raro en vez de una lista?

Devuelven un iterador perezoso: no calculan nada hasta que alguien se lo pide (con list(...), un for o sum). Es como una cinta transportadora que solo se mueve cuando alguien coge una pieza. Así puedes encadenar map y filter sobre un millón de elementos sin crear listas intermedias en memoria.

El precio es que un iterador se gasta: lo recorres una vez y se acaba. Si haces m = map(...), list(m) y otra vez list(m), la segunda lista sale vacía. En PHP, array_map y array_filter devuelven siempre un array completo, sin sorpresas.

Pythonmain.py
m = map(lambda h: h * 2, [1, 2, 3])
print(list(m))
print(list(m))

# Si necesitas recorrerlo dos veces, hazlo lista.
m = list(map(lambda h: h * 2, [1, 2, 3]))
print(m, m)

4 · Cuándo es mejor una comprensión

La comprensión [… for … in … if …] (módulo 02) hace lo mismo que map y filter juntos, sin lambda y se lee de izquierda a derecha, como una frase. Compara:

Pythonmain.py
horas = [2, 5, 1, 4]

# Con map y filter: dentro hacia fuera, con dos lambdas.
con_map = list(map(lambda h: h * 2, filter(lambda h: h >= 3, horas)))

# Con comprensión: "el doble de cada h de horas, si h >= 3".
con_comprension = [h * 2 for h in horas if h >= 3]

print(con_map, con_comprension)

# Y con diccionarios y conjuntos también.
tareas = ["pan", "leche", "huevos"]
print({t: len(t) for t in tareas})
print({len(t) for t in tareas})
#SituaciónMejorPor qué
1Transformar o filtrar con una expresión (h * 2, h >= 3)ComprensiónSin lambda, se lee como una frase
2Ya tienes una función con nombre (str.upper, int, len)map(funcion, datos)Es más corto que la comprensión
3Ordenar por un camposorted(..., key=lambda …)No hay comprensión que ordene
4Juntar todo en un solo valorsum, max, any… y si no, reduceLas funciones con nombre dicen lo que hacen
5Hay que construir un diccionario o un setComprensión de dict o setmap y filter solo dan iteradores
PHP 8.5index.php
<?php
declare(strict_types=1);

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

$resumen = $horas
    |> array_sum(...)
    |> (fn(int $total): string => "Total: $total horas");

$dobles = array_map(fn(int $h): int => $h * 2, array_filter($horas, fn(int $h): bool => $h >= 3));

echo $resumen . PHP_EOL;
echo implode(", ", $dobles) . PHP_EOL;
Pythonmain.py
horas = [2, 5, 1, 4]

resumen = f"Total: {sum(horas)} horas"
dobles = [h * 2 for h in horas if h >= 3]

print(resumen)
print(", ".join(str(h) for h in dobles))

5 · sum, min, max, any y all

Cinco funciones que resumen una colección en un solo valor. Las usarás todos los días, y funcionan con listas, tuplas, sets, rangos y... generadores.

Pythonmain.py
horas = [2, 5, 1, 4]
tareas = [
    {"titulo": "Comprar pan", "hecha": True, "horas": 1},
    {"titulo": "Llamar al banco", "hecha": False, "horas": 2},
    {"titulo": "Repasar Python", "hecha": True, "horas": 4},
]

# En PHP: array_sum($horas), min($horas), max($horas)
print(sum(horas), min(horas), max(horas))

# Con una expresión generadora (comprensión sin corchetes): no crea lista.
print(sum(t["horas"] for t in tareas))

# En PHP 8.4: array_any($tareas, fn($t) => $t["hecha"])
print(any(t["hecha"] for t in tareas))
print(all(t["hecha"] for t in tareas))

# Cuántas cumplen algo: sumar Trues (True vale 1).
print(sum(t["hecha"] for t in tareas))

# default: qué devolver si no hay elementos (si no, ValueError).
print(max([], default=0))
print(min((t["horas"] for t in tareas if t["horas"] > 10), default=None))

# Con varios argumentos sueltos, sin lista.
print(max(3, 9, 4), min("pan", "leche"))

¿Por qué? · En PHP no existe

¿Por qué all([]) es True y any([]) es False?

Es lógica pura. all pregunta «¿alguien incumple?»: si no hay nadie, nadie incumple, así que True. any pregunta «¿alguien cumple?»: si no hay nadie, False.

Es la trampa típica de all(t["hecha"] for t in tareas) con una lista de tareas vacía: dice «todas están hechas». Si no tiene sentido sin tareas, compruébalo antes (if tareas and all(...)).

6 · zip y enumerate: recorrer de dos en dos y con número

enumerate te da el número y el elemento a la vez; zip recorre dos listas en paralelo. Con ellos casi nunca necesitas for i in range(len(lista)), que es lo que haría alguien que viene de PHP con for ($i = 0; $i < count($a); $i++).

Pythonmain.py
titulos = ["Comprar pan", "Llamar al banco", "Repasar Python"]
horas = [1, 2, 4]

# En PHP: foreach ($titulos as $i => $t) { echo $i + 1 . ". $t"; }
for numero, titulo in enumerate(titulos, start=1):
    print(f"{numero}. {titulo}")

# En PHP: foreach ($titulos as $i => $t) { echo "$t: {$horas[$i]} h"; }
for titulo, h in zip(titulos, horas):
    print(f"{titulo}: {h} h")

# En PHP: array_combine($titulos, $horas)
print(dict(zip(titulos, horas)))

# Las dos a la vez.
for numero, (titulo, h) in enumerate(zip(titulos, horas), start=1):
    print(numero, titulo, h)

# zip se detiene en la lista MÁS CORTA, sin avisar.
print(list(zip([1, 2, 3], ["a", "b"])))

# strict=True (Python 3.10+): avisa si no miden lo mismo.
try:
    list(zip([1, 2, 3], ["a", "b"], strict=True))
except ValueError as error:
    print("ValueError:", error)

# "Deszipear": zip(*parejas) separa las parejas en dos grupos.
parejas = [("pan", 1), ("leche", 2)]
nombres, cantidades = zip(*parejas)
print(nombres, cantidades)
PHP 8.5index.php
<?php
declare(strict_types=1);

$titulos = ["Comprar pan", "Llamar al banco"];
$horas = [1, 2];

foreach ($titulos as $i => $titulo) {
    echo ($i + 1) . ". $titulo ({$horas[$i]} h)" . PHP_EOL;
}
print_r(array_combine($titulos, $horas));
Pythonmain.py
titulos = ["Comprar pan", "Llamar al banco"]
horas = [1, 2]

for i, (titulo, h) in enumerate(zip(titulos, horas), start=1):
    print(f"{i}. {titulo} ({h} h)")
print(dict(zip(titulos, horas)))

¿Por qué? · En PHP no existe

¿Por qué zip se para en la lista más corta sin avisar?

Es su diseño original: zip termina cuando se acaba la más corta, lo que permite juntar una lista con una secuencia infinita (como itertools.count(), que cuenta 0, 1, 2… para siempre). Pero cuando las dos listas deberían medir lo mismo, el resultado es un error silencioso: pierdes datos sin enterarte.

Por eso Python 3.10 añadió strict=True: si las longitudes no coinciden, lanza ValueError. Úsalo siempre que las dos listas deban medir lo mismo, que es lo habitual. Con array_combine, PHP sí lanza una excepción si las longitudes difieren.

Hora de practicar

Retos · 0/4 resueltos

Reto 1 de 4

Las tareas más cortas primero

Ordena las tareas por horas de menor a mayor con sorted y key=lambda e imprime solo los títulos, en una lista. Salida esperada: ['Comprar pan', 'Hacer deporte', 'Repasar Python']. Es el usort 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. lambda = función anónima de una expresión; úsala en key=, no la guardes en variables (en PHP, fn($x) => …).
  2. sorted(l, key=…), min y max con key: dices por qué ordenar, no cómo comparar (en PHP, usort con <=>). Varios criterios = una tupla.
  3. map/filter son perezosos y se gastan (hay que hacer list); functools.reduce hay que importarla. Casi siempre, una comprensión se lee mejor (en PHP, array_map, array_filter, array_reduce).
  4. sum, min, max, any, all: un valor a partir de una colección; all([]) es True (en PHP, array_sum, min, max, array_any, array_all).
  5. enumerate da el número y zip(…, strict=True) recorre en paralelo sin perder datos (en PHP, foreach ($a as $i => $v) y array_combine).

Para recordarlo: «Key dice por qué; la comprensión, qué; zip, a la vez»

KKey
sorted(x, key=lambda …) dice por qué ordenar
CComprensión
[… for … if …] mejor que map(lambda …)
ZZip
recorre en paralelo; con strict=True

Si te ves escribiendo lambda dentro de un map o un filter: cámbialo por una comprensión. La lambda se queda para key=.