Que sont les lambdas et les outils fonctionnels map/filter/reduce ?

Question

Accepted Answer

Une **lambda** est une petite fonction anonyme à une seule expression. **`map`**, **`filter`** et **`reduce`** sont des outils fonctionnels qui appliquent une fonction à un itérable. Ensemble, ils permettent un style fonctionnel — bien que Python préfère souvent les compréhensions pour les mêmes tâches.

## Lambda — fonctions anonymes en ligne

```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
```

Les lambdas brillent comme **arguments en ligne** pour d'autres fonctions, en particulier comme clés de tri/filtre :

```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 — appliquer une fonction à chaque élément

```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 — conserver les éléments qui passent un test

```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 — replier l'itérable en une seule valeur

```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 préférence Pythonic

```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 (le créateur de Python) et la communauté préfèrent généralement les compréhensions à `map`/`filter` pour la lisibilité ; `reduce` a même été retirée des fonctions intégrées. Mais les lambdas comme fonctions `key=` restent idiomatiques et courantes.

## Pourquoi c'est important

Ces outils fonctionnels vous permettent d'exprimer des transformations et des filtres de manière concise.

Bien que Python *puisse* être écrit de manière fonctionnelle, le choix idiomatique est généralement une **compréhension** plutôt que `map`/`filter` pour la lisibilité, et une fonction intégrée (`sum`, `max`, `min`) plutôt que `reduce`.

Le vrai avantage des lambdas est d'être de petites fonctions en ligne passées à `sort`/`max`/`min`/`filter` comme `key`.

Comprendre les deux — et connaître la préférence Pythonic pour les compréhensions et les fonctions intégrées — vous aide à écrire un code propre et idiomatique et à lire le code fonctionnel qui apparaît dans les vrais projets.