Menene lambdas da kayan aiki na aikin map/filter/reduce?

Question

Accepted Answer

**lambda** shine ƙarami, ba tare da suna ba, aiki mai jujjuya guda. **`map`**, **`filter`**, da **`reduce`** sune kayan aiki na aikin da suke amfani da aiki a cikin mai cin gida. Tare suna ba da salon aikin — duk da haka Python galibi yana son ƙwarewar gida don ayyuka iri daya.

## Lambda — ayyuka marasa suna na jujjuya

```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 suna kyau a matsayin **jujjuya gardama** ga sauran ayyuka, musamman a matsayin sort/filter maɓuɓɓuka:

```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 — aiki a aikin kowane abun yan tawa

```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 — ri abubuwanda suke cewa jaki

```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 — danna mai cin gida zuwa ƙima guda

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

## Zaɓin 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 (mai aiki na Python) da jama'a galibi suna son ƙwarewar gida fiye da `map`/`filter` don sawon karanta; `reduce` an buga shi jiya daga abubuwan daxili. Amma lambdas azaman ayyukan `key=` suna kasance na al'ada da kowa sanyi.

## Me yake kauri

Wannan kayan aiki na aikin suna ba ka iya bayyana juyyo da tainidin gida sanyi.

Wadda aka iya rubuta Python a aikin gaske, zaɓin al'ada galibi shi ne **kwarewar gida** fiye da `map`/`filter` don sawon karanta, da abubuwan daxili (`sum`, `max`, `min`) fiye da `reduce`.

Waji lambdas suke brilla shi ne azaman ƙananan ayyuka na jujjuya da aka tura ga `sort`/`max`/`min`/`filter` azaman `key`.

Sanin duka — da sanin zaɓin Pythonic don ƙwarewar gida da abubuwan daxili — yana taimaka maka rubuta cleaner, idiomatic code da karanta koda na salon aikin wanda ke bayyana a ayyukan gaske.