Lambda và các công cụ hàm map/filter/reduce là gì?

Question

Accepted Answer

Một **lambda** là một hàm nhỏ, vô danh, một-biểu-thức. **`map`**, **`filter`** và **`reduce`** là các công cụ hàm áp dụng một hàm lên một iterable. Cùng nhau chúng cho phép một phong cách functional — dù Python thường ưa chuộng comprehension cho cùng các tác vụ.

## Lambda — hàm vô danh nội tuyến

```python
# một lambda là một hàm một dòng không có tên
square = lambda x: x ** 2
square(5)                      # 25

# hàm có tên tương đương:
def square(x): return x ** 2
```

Lambda tỏa sáng khi làm **đối số nội tuyến** cho các hàm khác, đặc biệt là làm key cho sort/filter:

```python
people.sort(key=lambda p: p.age)            # sắp xếp theo một thuộc tính
sorted(words, key=lambda w: len(w))          # sắp xếp theo độ dài
max(items, key=lambda x: x.score)            # tìm max theo một tiêu chí
```

## map — áp dụng một hàm lên mọi phần tử

```python
nums = [1, 2, 3, 4]
list(map(lambda x: x ** 2, nums))   # [1, 4, 9, 16]
# lựa chọn thay thế Pythonic hơn — một comprehension:
[x ** 2 for x in nums]               # [1, 4, 9, 16]
```

## filter — giữ lại các phần tử vượt qua một kiểm tra

```python
list(filter(lambda x: x % 2 == 0, nums))   # [2, 4]
# tương đương comprehension:
[x for x in nums if x % 2 == 0]             # [2, 4]
```

## reduce — gập iterable thành một giá trị duy nhất

```python
from functools import reduce
reduce(lambda acc, x: acc + x, nums, 0)     # 10 (tổng)
# nhưng các hàm dựng sẵn rõ ràng hơn khi chúng tồn tại:
sum(nums)                                    # 10
```

## Sự ưu tiên kiểu Pythonic

```text
Đối với map/filter, COMPREHENSION thường dễ đọc hơn và đúng phong cách hơn:
  map(f, xs)            →  [f(x) for x in xs]
  filter(pred, xs)      →  [x for x in xs if pred(x)]
Lambda tốt nhất cho các key nội tuyến ngắn (sort/max/filter), KHÔNG dùng cho logic phức tạp.
```

Guido (người tạo ra Python) và cộng đồng nói chung ưa chuộng comprehension hơn `map`/`filter` về khả năng đọc; `reduce` thậm chí đã bị chuyển ra khỏi nhóm hàm dựng sẵn. Nhưng lambda làm hàm `key=` vẫn đúng phong cách và phổ biến.

## Tại sao điều này quan trọng

Các công cụ functional này cho phép bạn diễn đạt các phép biến đổi và lọc một cách súc tích.

Dù Python *có thể* viết theo phong cách functional, lựa chọn đúng phong cách thường là **comprehension** thay vì `map`/`filter` về khả năng đọc, và một hàm dựng sẵn (`sum`, `max`, `min`) thay vì `reduce`.

Nơi lambda thực sự tỏa sáng là làm các hàm nhỏ nội tuyến truyền vào `sort`/`max`/`min`/`filter` làm một `key`.

Hiểu cả hai — và biết sự ưu tiên Pythonic cho comprehension và hàm dựng sẵn — giúp bạn viết code sạch, đúng phong cách và đọc được code phong cách functional xuất hiện trong các dự án thực tế.