लैम्ब्डा और कार्यात्मक उपकरण map/filter/reduce क्या हैं?

Question

Accepted Answer

एक **lambda** एक छोटा, अनाम, एकल-अभिव्यक्ति फ़ंक्शन है। **`map`**, **`filter`**, और **`reduce`** कार्यात्मक उपकरण हैं जो एक iterable में एक फ़ंक्शन लागू करते हैं। एक साथ वे एक कार्यात्मक शैली सक्षम करते हैं — हालांकि 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 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 — iterable को एक मान में मोड़ो

```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` को तो builtins से बाहर कर दिया गया। लेकिन `key=` फ़ंक्शन के रूप में lambdas प्रशंसनीय और सामान्य रहते हैं।

## यह क्यों मायने रखता है

ये कार्यात्मक उपकरण आपको रूपांतरण और फ़िल्टर को संक्षेप में व्यक्त करने देते हैं।

जबकि Python को कार्यात्मक रूप से लिखा जा *सकता* है, प्रशंसनीय विकल्प आमतौर पर पठनीयता के लिए `map`/`filter` पर **समझ**, और `reduce` पर built-in (`sum`, `max`, `min`) होता है।

जहां lambdas वास्तव में चमकते हैं वह छोटे इनलाइन फ़ंक्शन हैं जो `sort`/`max`/`min`/`filter` के लिए `key` के रूप में पारित किए जाते हैं।

दोनों को समझना — और कमप्रिहेंशन और built-ins के लिए Pythonic वरीयता जानना — आपको स्वच्छ, प्रशंसनीय कोड लिखने और कार्यात्मक-शैली कोड पढ़ने में मदद करता है जो वास्तविक प्रोजेक्ट में दिखाई देता है।