ਲੈਂਬਡਾ ਅਤੇ ਫੰਕਸ਼ਨਲ ਟੂਲਸ map/filter/reduce ਕੀ ਹਨ?

Question

Accepted Answer

ਇੱਕ **lambda** ਇੱਕ ਛੋਟਾ, ਅਗਿਆਤ, ਸਿੰਗਲ-ਐਕਸਪ੍ਰੈਸ਼ਨ ਫੰਕਸ਼ਨ ਹੈ। **`map`**, **`filter`** ਅਤੇ **`reduce`** ਫੰਕਸ਼ਨਲ ਟੂਲਸ ਹਨ ਜੋ ਇੱਕ ਫੰਕਸ਼ਨ ਨੂੰ iterable ਦੇ ਹਰੇਕ ਤੱਤ ਉੱਤੇ ਲਾਗੂ ਕਰਦੇ ਹਨ। ਇਕੱਠੇ ਉਹ ਇੱਕ ਫੰਕਸ਼ਨਲ ਸਟਾਈਲ ਨੂੰ ਸਮਰੱਥ ਬਣਾਉਂਦੇ ਹਨ — ਭਾਵੇਂ 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 ਕੀਅਜ਼ ਦੇ ਤੌਰ ਤੇ:

```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=` ਫੰਕਸ਼ਨਾਂ ਵਜੋਂ ਅਜੇ ਵੀ idiomatisch ਅਤੇ ਆਮ ਹਨ।

## ਇਹ ਕਿਉਂ ਮਹੱਤਵਪੂਰਨ ਹੈ

ਇਹ ਫੰਕਸ਼ਨਲ ਟੂਲਸ ਤੁਹਾਨੂੰ ਪਰਿਵਰਤਨ ਅਤੇ ਫਿਲਟਰ ਸੰਖੇਪ ਵਿੱਚ ਪ੍ਰਗਟ ਕਰਨ ਦੀ ਆਗਿਆ ਦਿੰਦੇ ਹਨ।

ਭਾਵੇਂ Python *ਨੂੰ* ਫੰਕਸ਼ਨਲੀ ਲਿਖਿਆ ਜਾ ਸਕਦਾ ਹੈ, idiomatrick ਚੋਣ ਆਮ ਤੌਰ ਤੇ readability ਲਈ `map`/`filter` ਤੋਂ ਬਾਅਦ ਇੱਕ **comprehension** ਅਤੇ `reduce` ਦੀ ਜਗ੍ਹਾ ਇੱਕ built-in (`sum`, `max`, `min`) ਹੈ।

Jere lambdas ਸਚਮੁੱਚ ਚਮਕਦੇ ਹਨ ਉਹ ਛੋਟੇ inline ਫੰਕਸ਼ਨ ਹੁੰਦੇ ਹਨ ਜੋ `sort`/`max`/`min`/`filter` ਨੂੰ ਇੱਕ `key` ਦੇ ਤੌਰ ਤੇ ਭੇਜੇ ਜਾਂਦੇ ਹਨ।

ਦੋਵੇਂ ਸਮਝਣਾ — ਅਤੇ comprehensions ਅਤੇ built-ins ਲਈ Pythonic ਪਸੰਦ ਜਾਣਨਾ — ਤੁਹਾਨੂੰ ਸਾਫ਼, idiomatrick ਕੋਡ ਲਿਖਣ ਅਤੇ ਫੰਕਸ਼ਨਲ-ਸਟਾਈਲ ਕੋਡ ਪੜ੍ਹਨ ਵਿੱਚ ਮਦਦ ਕਰਦਾ ਹੈ ਜੋ ਅਸਲ ਪ੍ਰੋਜੈਕਟਾਂ ਵਿੱਚ ਦਿਖਾਈ ਦਿੰਦਾ ਹੈ।