Was sind Lambdas und die funktionalen Tools map/filter/reduce?

Question

Accepted Answer

Ein **Lambda** ist eine kleine, anonyme Funktion mit einem einzelnen Ausdruck. **`map`**, **`filter`** und **`reduce`** sind funktionale Tools, die eine Funktion auf ein Iterable anwenden. Zusammen ermöglichen sie einen funktionalen Stil — Python bevorzugt aber oft Comprehensions für dieselben Aufgaben.

## Lambda — inline anonyme Funktionen

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

Lambdas glänzen als **inline-Argumente** für andere Funktionen, besonders als sort/filter-Schlüssel:

```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 — wende eine Funktion auf jedes Element an

```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 — behalte Elemente, die einen Test bestehen

```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 — falte das Iterable auf einen Wert zusammen

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

## Die Pythonic-Präferenz

```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 (Pythons Schöpfer) und die Community bevorzugen generell Comprehensions gegenüber `map`/`filter` für bessere Lesbarkeit; `reduce` wurde sogar aus den Built-ins entfernt. Aber Lambdas als `key=`-Funktionen bleiben idiomatisch und häufig.

## Warum es wichtig ist

Diese funktionalen Tools ermöglichen es dir, Transformationen und Filter prägnant auszudrücken.

Obwohl Python *funktional* geschrieben werden kann, ist die idiomatische Wahl normalerweise eine **Comprehension** statt `map`/`filter` für bessere Lesbarkeit und eine Built-in-Funktion (`sum`, `max`, `min`) statt `reduce`.

Wo Lambdas wirklich glänzen, ist als kleine inline-Funktionen, die an `sort`/`max`/`min`/`filter` als `key` übergeben werden.

Wenn du beide verstehst — und die Pythonic-Präferenz für Comprehensions und Built-ins kennst — hilft dir das, sauberen, idiomatischen Code zu schreiben und den funktionalen Code zu lesen, der in echten Projekten vorkommt.