लॅम्बडा आणि functional tools map/filter/reduce म्हणजे काय?

Question

Accepted Answer

**lambda** हा एक छोटा, अनामिक, सिंगल-एक्सप्रेशन फंक्शन आहे. **`map`**, **`filter`** आणि **`reduce`** हे functional tools आहेत जे इटरेबलच्या प्रत्येक घटकावर फंक्शन लागू करतात. एकत्रितपणे ते एक functional style सक्षम करतात — परंतु 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
```

लॅम्बडा इतर फंक्शनला **inline arguments** म्हणून चमकते, विशेषतः 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
```

## The Pythonic preference

```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=` फंक्शन म्हणून लॅम्बडा अजूनही idiomatic आणि सामान्य आहेत.

## हे महत्वाचे का आहे

हे functional tools तुम्हाला संक्षिप्तपणे transformations आणि filters व्यक्त करू देतात.

जरी Python *functionaly* लिहिले जाऊ शकते, परंतु idiomatic पर्याय सामान्यतः वाचनीयतेसाठी `map`/`filter` पेक्षा **comprehension** आहे, आणि `reduce` पेक्षा built-in (`sum`, `max`, `min`) आहे.

लॅम्बडा खरोखरून चमकते असे स्थान हे `sort`/`max`/`min`/`filter` ला `key` म्हणून पारित केलेले छोटे inline फंक्शन म्हणून आहे.

दोन्ही समजून घेणे — आणि comprehensions आणि built-ins साठी Pythonic प्राधान्य जाणून घेणे — तुम्हाला स्वच्छ, idiomatic कोड लिहायला आणि वास्तविक प्रकल्पांमध्ये दिसणारे functional-style कोड वाचायला मदत करते.