Lambda trong Python: hàm ẩn danh, key khi sắp xếp, map/filter

Một hàm chẳng cần đặt tên

Phần lớn hàm (function) trong Python được định nghĩa bằng def, có tên và nằm trong một tệp để có thể dùng lại. lambda là một lựa chọn nhỏ gọn hơn và không có tên, hữu ích trong vài trường hợp mà việc định nghĩa cả một hàm đầy đủ thì rườm rà hơn mức cần thiết.

Đây là hai dạng đặt cạnh nhau:

def double(x):
    return x * 2

double_lambda = lambda x: x * 2

print(double(5))
print(double_lambda(5))

Hai hàm, làm đúng cùng một việc. Bản lambda nằm gọn trên một dòng vì đó chính là vai trò của nó: một hàm dùng xong là bỏ, cho một tình huống dùng xong là bỏ.

Cú pháp

lambda <params>: <expression>

• <params> là danh sách tham số giống hệt danh sách mà def dùng, hỗ trợ giá trị mặc định, *args và **kwargs.
• <expression> là một biểu thức duy nhất, giá trị của nó trở thành giá trị trả về.

Ví dụ:

add = lambda a, b: a + b
print(add(3, 4))

square = lambda n: n * n
print(square(8))

greet = lambda name="world": f"Hello, {name}"
print(greet())
print(greet("Rosa"))

Không có từ khóa return. Giá trị của biểu thức được trả về một cách ngầm định.

Giới hạn duy nhất

Lambda chỉ chứa được một biểu thức. Bạn không thể đặt câu lệnh vào bên trong:

# These don't work:
# bad = lambda x: x = x + 1         # can't assign
# worse = lambda x:                 # can't have if/elif/else as statements
#     if x > 0:
#         return x
#     else:
#         return -x

Nhưng bạn có thể dùng biểu thức ba ngôi:

signed = lambda x: x if x > 0 else -x
print(signed(-5))
print(signed(5))

Nếu cần nhiều hơn một biểu thức, đó là dấu hiệu để chuyển sang def.

Những chỗ lambda thực sự đáng dùng

Một lambda được gán cho biến gần như lúc nào cũng kém hơn một def có tên:

# Don't do this.
double = lambda x: x * 2

Cách này rõ ràng kém hơn def double(x): return x * 2: dễ đọc như nhau, nhưng bản lambda lại khiến trình gỡ lỗi hiện cái tên vô ích <lambda> trong stack trace.

Lambda chỉ thực sự tỏa sáng ở đúng một chỗ: làm đối số viết ngay tại chỗ cho các hàm bậc cao (higher-order function).

Key tùy chỉnh khi sắp xếp

Trường hợp kinh điển:

users = [
    {"name": "Ada", "age": 36},
    {"name": "Boris", "age": 28},
    {"name": "Ciara", "age": 44},
]

by_age = sorted(users, key=lambda u: u["age"])
print(by_age)

Đối số key của sorted cần một hàm nhận vào một phần tử và trả về giá trị dùng để sắp xếp. Một lambda một dòng là vừa khít, còn viết cả một def đầy đủ thì quá nặng nề cho việc nhỏ như vậy.

Bạn có thể sắp xếp theo nhiều trường bằng một tuple:

records = [("Ada", 2), ("Boris", 1), ("Ada", 1), ("Boris", 3)]

by_name_then_version = sorted(records, key=lambda r: (r[0], r[1]))
print(by_name_then_version)

min, max, filter, map

Câu chuyện tương tự: tất cả đều nhận một đối số hàm tùy chọn:

prices = [{"item": "apple", "cost": 0.50}, {"item": "bread", "cost": 2.00}]

cheapest = min(prices, key=lambda p: p["cost"])
print(cheapest)

# map: apply a function to each item
numbers = [1, 2, 3, 4]
doubled = list(map(lambda n: n * 2, numbers))
print(doubled)

# filter: keep items where the function returns true
evens = list(filter(lambda n: n % 2 == 0, numbers))
print(evens)

Với map và filter, list comprehension thường còn rõ ràng hơn:

numbers = [1, 2, 3, 4]

doubled = [n * 2 for n in numbers]
evens = [n for n in numbers if n % 2 == 0]
print(doubled, evens)

Vì lý do này, phần lớn lập trình viên Python chọn comprehension thay vì map/filter. lambda vẫn rất hợp với sorted, min và max, vì ở đó không có cách viết tắt nào bằng comprehension.

Lambda và operator

Khi lambda của bạn chỉ làm việc "lấy một khóa" hay "lấy một thuộc tính", module operator của Python có những lựa chọn nhanh hơn và rõ ràng hơn:

from operator import itemgetter, attrgetter

users = [{"name": "Ada", "age": 36}, {"name": "Boris", "age": 28}]

# These two are equivalent:
a = sorted(users, key=lambda u: u["name"])
b = sorted(users, key=itemgetter("name"))

print(a)
print(b)

Lợi ích không lớn, nhưng trong code vốn đã import operator, cách này đọc mang tính khai báo hơn một chút.

Khi nào quay lại dùng def

Nếu có bất kỳ điều nào dưới đây đúng, hãy viết def:

1. Logic không gói gọn được trong một biểu thức.
2. Bạn muốn đặt tên cho hàm vì cái tên giúp code dễ đọc hơn.
3. Bạn sẽ dùng cùng logic đó ở nhiều chỗ.
4. Hàm cần một docstring (lambda không có docstring được).

Nhớ rằng: Python không chấm điểm theo số dòng. Một hàm có tên dài ba dòng gần như luôn dễ đọc hơn một lambda một dòng khi logic không còn đơn giản.

Tiếp theo: decorator

Lambda đưa hàm đi khắp nơi như một giá trị. Decorator đẩy ý tưởng đó đi xa thêm một bước: chúng cho phép bạn bọc bất kỳ hàm nào bằng hành vi dùng lại được, như ghi log, đo thời gian, cache hay xác thực, chỉ với một dấu @ ở dòng phía trên. Đó là nội dung của trang tiếp theo.