लम्बडा र फंक्शनल टूल्स map/filter/reduce के हुन्?

Question

Accepted Answer

**lambda** एक सानो, गुमनाम, सिङ्गल-एक्सप्रेसन फंक्शन हो। **`map`**, **`filter`**, र **`reduce`** फंक्शनल टूल्स हुन् जसले पुनरावृत्तियोग्य प्रत्येक तत्वमा फंक्शन लागू गर्छन्। सँगै, तिनीहरूले एक फंक्शनल शैली सक्षम गर्छन् — यद्यपि Python अक्सर समान कार्यको लागि comprehensions लाई प्राथमिकता दिन्छ।

## Lambda — inline अनामिक फंक्शन

```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 अन्य फंक्शनहरूका **inline तर्क** को रूपमा चमकदार हुन्छन्, विशेष गरी sort/filter keys को रूपमा:

```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` भन्दा comprehensions लाई प्राथमिकता दिन्छन्; `reduce` तपाईं builtins बाहिर सारिएको पनि छ। तर `key=` फंक्शनहरू को रूपमा lambdas अभी पनि idiomatic र सामान्य छन्।

## यो किन महत्वपूर्ण छ

यी फंक्शनल टूल्सले तपाईंलाई रूपान्तरण र फिल्टरहरू संक्षिप्तमा अभिव्यक्त गर्न अनुमति दिन्छ।

जबकि Python *फंक्शनली* लेख्न सकिन्छ, idiomatic विकल्प सामान्यतः पठनीयताको लागि `map`/`filter` भन्दा **comprehension** हो, र `reduce` भन्दा built-in (`sum`, `max`, `min`) हो।

लम्बडा वास्तवमा जहाँ चमकदार हुन्छन् त्यो सिङ्गल लाइन फंक्शनहरू हुन् जो `sort`/`max`/`min`/`filter` मा `key` को रूपमा पास हुन्छन्।

दुवेलाई बुझ्न — र comprehensions र built-ins को लागि Pythonic प्राथमिकता जान्न — तपाईंलाई स्वच्छ, idiomatic कोड लेख्न र वास्तविक परियोजनामा देखा पर्ने फंक्शनल-शैली कोड पढ्न मद्दत गर्छ।