લેમ્બડા અને કાર્યાત્મક સાધનો map/filter/reduce શું છે?

Question

Accepted Answer

**lambda** એક નાનું, અનામી, એક-અભિવ્યક્તિ કાર્ય છે. **`map`**, **`filter`**, અને **`reduce`** કાર્યાત્મક સાધનો છે જે ફંક્શનને પુનરાવર્તિત કરતા લાગુ કરે છે. એક સાથે તેઓ એક કાર્યાત્મક શૈલી સક્ષમ કરે છે — તેમ છતાં Python ઘણી વાર સમાન કાર્યો માટે સમજણને પ્રાધાન્ય આપે છે.

## Lambda — ઇનલાઇન અનામી કાર્યો

```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 અન્ય કાર્યોમાં **ઇનલાઇન દલીલો** તરીકે શાનદાર છે, ખાસ કરીને 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 — દરેક તત્વ માટે એક કાર્ય લાગુ કરો

```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 — પરીક્ષણ પસાર કરતા તત્વોને રાખો

```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 — પુનરાવર્તિત કોને એક મૂલ્યમાં ફોલ્ડ કરો

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

## 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 (Python નું નિર્માતા) અને સમુદાય સામાન્ય રીતે વાચનીયતા માટે `map`/`filter` પર સમજણને પ્રાધાન્ય આપે છે; `reduce` તો બિલ્ટઇનમાંથી પણ બહાર કાઢવામાં આવ્યું. પરંતુ `key=` કાર્યો તરીકે lambdas રહે તે સમજણીય અને સામાન્ય છે.

## શા માટે તેનું મહત્વ છે

યે કાર્યાત્મક સાધનો તમને રૂપાંતર અને ફિલ્ટર સંક્ષિપ્તપણે વ્યક્ત કરવાની સુવિધા આપે છે.

જ્યારે Python કાર્યાત્મક રીતે લખી શકાય છે, પરંતુ આવક પસંદગી સામાન્ય રીતે વાચનીયતા માટે `map`/`filter` ને બદલે **comprehension**, અને `reduce` ને બદલે બિલ્ટઇન (`sum`, `max`, `min`) છે.

જ્યાં lambdas ખરેખર ચમકે છે તે નાના ઇનલાઈન કાર્યો છે જે `sort`/`max`/`min`/`filter` કર્તું `key` તરીકે પસાર કરવામાં આવે છે.

બંને સમજવું — અને કમ્પ્રીહેન્શન્સ અને બિલ્ટઇનો માટે Pythonic પસંદગી જાણવી — તમને સ્વચ્છ, સમજણીય કોડ લખવા અને વાસ્તવિક પ્રોજેક્ટમાં દેખાય તેવા કાર્યાત્મક-શૈલીના કોડને વાંચવામાં મદદ કરે છે.