lambda এবং functional tools map/filter/reduce কী?

Question

Accepted Answer

একটি **lambda** একটি ছোট, anonymous, একক-expression function। **`map`**, **`filter`**, এবং **`reduce`** হল functional tools যা একটি iterable জুড়ে একটি function প্রয়োগ করে। একসাথে তারা একটি functional style সক্ষম করে — যদিও Python প্রায়ই একই কাজের জন্য comprehensions পছন্দ করে।

## Lambda — inline anonymous functions

```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** হিসেবে অন্যান্য functions এ উজ্জ্বল হয়, বিশেষত 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 — প্রতিটি element এ একটি function প্রয়োগ করুন

```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 — একটি test পাস করা elements রাখুন

```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 কে একটি মূল্যে fold করুন

```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 এর creator) এবং সম্প্রদায় সাধারণত পাঠযোগ্যতার জন্য `map`/`filter` এর উপর comprehensions পছন্দ করে; `reduce` এমনকি builtins এর বাইরে সরানো হয়েছিল। কিন্তু lambdas যেমন `key=` functions তৈরি idiomatic এবং সাধারণ থাকে।

## এটি কেন গুরুত্বপূর্ণ

এই functional tools আপনাকে transformations এবং filters সংক্ষিপ্তভাবে প্রকাশ করতে দেয়।

যখন Python *functionally* লেখা যেতে পারে, idiomatic পছন্দ সাধারণত পাঠযোগ্যতার জন্য `map`/`filter` এর উপর একটি **comprehension**, এবং `reduce` এর উপর একটি built-in (`sum`, `max`, `min`)।

যেখানে lambdas সত্যিই উজ্জ্বল হয় তা হল ছোট inline functions হিসেবে `sort`/`max`/`min`/`filter` এ `key` হিসেবে পাস করা।

Doing উভয় বুঝুন — এবং comprehensions এবং built-ins এর জন্য Pythonic পছন্দ জানুন — আপনাকে পরিষ্কার, idiomatic কোড লিখতে এবং functional-style কোড পড়তে সাহায্য করে যা প্রকৃত প্রকল্পে প্রদর্শিত হয়।