¿Qué son las lambdas y las herramientas funcionales map/filter/reduce?

Question

Accepted Answer

Una **lambda** es una pequeña función anónima de una sola expresión. **`map`**, **`filter`** y **`reduce`** son herramientas funcionales que aplican una función a lo largo de un iterable. Juntas habilitan un estilo funcional — aunque Python a menudo prefiere las comprehensions para las mismas tareas.

## Lambda — funciones anónimas en línea

```python
# a lambda is a one-line function with no name
square = lambda x: x ** 2
square(5)                      # 25

# equivalent named function:
def square(x): return x ** 2
```

Las lambdas brillan como **argumentos en línea** de otras funciones, especialmente como claves de ordenamiento/filtrado:

```python
people.sort(key=lambda p: p.age)            # sort by an attribute
sorted(words, key=lambda w: len(w))          # sort by length
max(items, key=lambda x: x.score)            # find max by a criterion
```

## map — aplicar una función a cada elemento

```python
nums = [1, 2, 3, 4]
list(map(lambda x: x ** 2, nums))   # [1, 4, 9, 16]
# more Pythonic alternative — a comprehension:
[x ** 2 for x in nums]               # [1, 4, 9, 16]
```

## filter — conservar los elementos que pasan una prueba

```python
list(filter(lambda x: x % 2 == 0, nums))   # [2, 4]
# comprehension equivalent:
[x for x in nums if x % 2 == 0]             # [2, 4]
```

## reduce — plegar el iterable en un solo valor

```python
from functools import reduce
reduce(lambda acc, x: acc + x, nums, 0)     # 10 (sum)
# but built-ins are clearer when they exist:
sum(nums)                                    # 10
```

## La preferencia pythónica

```text
For map/filter, COMPREHENSIONS are usually more readable and idiomatic:
  map(f, xs)            →  [f(x) for x in xs]
  filter(pred, xs)      →  [x for x in xs if pred(x)]
Lambdas are best for short inline keys (sort/max/filter), NOT complex logic.
```

Guido (el creador de Python) y la comunidad en general prefieren las comprehensions sobre `map`/`filter` por legibilidad; `reduce` incluso fue sacado de los builtins. Pero las lambdas como funciones `key=` siguen siendo idiomáticas y comunes.

## Por qué es importante

Estas herramientas funcionales te permiten expresar transformaciones y filtros de forma concisa.

Aunque Python *puede* escribirse de forma funcional, la elección idiomática suele ser una **comprehension** en lugar de `map`/`filter` por legibilidad, y un built-in (`sum`, `max`, `min`) en lugar de `reduce`.

Donde las lambdas realmente brillan es como pequeñas funciones en línea pasadas a `sort`/`max`/`min`/`filter` como `key`.

Entender ambas — y conocer la preferencia pythónica por las comprehensions y los built-ins — te ayuda a escribir código limpio e idiomático y a leer el código de estilo funcional que sí aparece en proyectos reales.