Lambdas మరియు functional tools map/filter/reduce ఏమిటి?

Question

Accepted Answer

**lambda** అనేది చిన్న, నామరహితమైన, ఒకే-ఎక్సప్రెషన్ ఫంక్షన్. **`map`**, **`filter`** మరియు **`reduce`** iterable నిండా ఒక ఫంక్షన్‌ను వర్తింపజేసే functional tools. కలిసి అవి functional style ను ప్రారంభిస్తాయి — అయితే Python ఉదాహరణకు comprehensions కోసం తరచుగా ఇష్టపడుతుంది.

## 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 ఇతర ఫంక్షన్‌లకు **inline arguments** గా సిరాస్‌ను చేస్తాయి, ప్రత్యేకించి 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 — 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 యొక్క సృష్టికర్త) మరియు సమాజం సాధారణంగా readability కోసం `map`/`filter` కంటే comprehensions ను ఇష్టపడుతుంది; `reduce` builtins నుండి కూడా బయటకు తరలించబడింది. కానీ lambdas `key=` ఫంక్షన్‌లుగా idiom మరియు సాధారణ స్థితిలో ఉంటాయి.

## ఇది ఎందుకు ముఖ్యమైనది

ఈ functional tools సంక్షిప్తంగా రూపాంతరాలు మరియు ఫిల్టర్‌లను చెప్పటానికి మిమ్మల్ని అనుమతిస్తాయి.

Python functional శైలిలో *వ్రాయబడినప్పటికీ, idiom ఎంపిక సాధారణంగా readability కోసం `map`/`filter` కంటే **comprehension** మరియు `reduce` కంటే built-in (`sum`, `max`, `min`).

Lambdas నిజంగా సూకుతారు చిన్న inline ఫంక్షన్‌లుగా `sort`/`max`/`min`/`filter` కు `key` గా పంపిన చోట.

దీనిని అర్థం చేసుకోవడం — మరియు comprehensions మరియు built-ins కోసం Pythonic ఆధారపడటం తెలుసుకోవడం — మీకు స్వచ్ఛమైన, idiom కోడ్ రాయడానికి సహాయపడుతుంది మరియు నిజమైన ప్రకటనలలో కనిపించే functional-style కోడ్ చదువుకుంటుంది.