Lambdas na zana za utendaji map/filter/reduce ni nini?

Question

Accepted Answer

**lambda** ni chaguo la kukokotea kidogo, kisicho na jina, lenye usemi mmoja. **`map`**, **`filter`** na **`reduce`** ni zana za utendaji inayotumia chaguo la kukokotea kwa kila kipengele katika kitu kinachoweza kutengenezwa. Pamoja, hurahisisha mtindo wa utendaji — ingawa Python mara nyingi inapendelea comprehensions kwa kazi sawa.

## Lambda — vitendaji vya anonimous vilivyojumuishwa

```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 huangazia kama **hoja za inline** kwa vitendaji vingine, hasa kama funguo za sort/filter:

```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 — tumia chaguo la kukokotea kwa kila kipengele

```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 — weka kipengele kinachokubali mtihani

```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 — kunja kitu kinachoweza kutengenezwa kuwa thamani moja

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

## Pendekezo la 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 (muumba wa Python) na jamii hata hivyo wanapendelea comprehensions zaidi ya `map`/`filter` kwa ajili ya urahisi; `reduce` ilisogezwa nje ya kitendaji kilichojumuishwa. Lakini lambdas kama vitendaji vya `key=` vinabaki kuwa vya kawaida na vya kawaida.

## Kwa nini ni muhimu

Zana hizi za utendaji zinalikuruhusu kuonyesha mabadilisho na kuchuja kwa ufupi.

Ingawa Python *inaweza* kuandikwa kwa utendaji, chaguo linaloidhini ni kawaida **comprehension** zaidi ya `map`/`filter` kwa ajili ya urahisi, na kitendaji kilichojumuishwa (`sum`, `max`, `min`) zaidi ya `reduce`.

Makinimali ambapo lambdas huangazia ni kama vitendaji vidogo vya inline vinavyopitiwa kwa `sort`/`max`/`min`/`filter` kama `key`.

Kufahamu zote mbili — na kujua pendekezo la Pythonic kwa ajili ya comprehensions na vitendaji vilivyojumuishwa — hukusaidia kuandika nambari safi, vya kawaida, na kusoma nambari ya utendaji inayokapita katika miradi halisi.