List comprehension trong Python: cú pháp, lọc, dict comprehension

Một dòng, một ý

Bạn đã viết kiểu code này nhiều lần: bắt đầu với một list rỗng, lặp qua thứ gì đó, có thể lọc bớt, rồi append vào kết quả.

numbers = [1, 2, 3, 4, 5]

doubled = []
for n in numbers:
    doubled.append(n * 2)

print(doubled)

List comprehension nói đúng điều đó trên một dòng:

numbers = [1, 2, 3, 4, 5]

doubled = [n * 2 for n in numbers]
print(doubled)

Đọc từ trái sang phải: "một list mới gồm n * 2, với mỗi n trong numbers." Cấu trúc là [expression for item in iterable].

Đây không phải mẹo riêng của Python. Nó được gọi là comprehension vì bạn mô tả những gì có trong list mới theo kiểu khai báo, thay vì viết ra từng bước cách tạo nó.

Thêm điều kiện lọc

Đặt một mệnh đề if sau phần vòng lặp để lọc:

numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

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

squares_of_odds = [n * n for n in numbers if n % 2 == 1]
print(squares_of_odds)

Đọc ví dụ thứ hai như sau: "n * n với mỗi n trong numbers, nhưng chỉ khi n là số lẻ."

Vòng lặp tương đương:

numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

squares_of_odds = []
for n in numbers:
    if n % 2 == 1:
        squares_of_odds.append(n * n)

print(squares_of_odds)

Cả hai đều ổn. Comprehension ngắn hơn, và khi đã đọc quen vài cái, bạn sẽ thấy nó còn dễ nhìn hơn vì ý định nằm gọn ngay trên một dòng.

Vừa biến đổi vừa lọc

Bạn có thể đưa giá trị qua một hàm và lọc cùng lúc:

words = ["python", "is", "great", "fun"]

long_upper = [w.upper() for w in words if len(w) > 3]
print(long_upper)

Với mỗi từ dài hơn 3 chữ cái, lấy bản viết hoa của nó.

Vòng lặp lồng nhau trong comprehension

Hai vòng for tạo ra các cặp theo kiểu tích Descartes:

suits = ["♠", "♥", "♦", "♣"]
ranks = ["J", "Q", "K", "A"]

deck = [rank + suit for suit in suits for rank in ranks]
print(deck)

Thứ tự giống hệt như khi bạn lồng các vòng lặp: for đầu tiên là vòng ngoài, for thứ hai là vòng trong. Nó đọc từ trái sang phải giống vòng lặp thụt lề tương đương.

Hai cấp gần như là giới hạn, quá mức đó thì vòng lặp thường dễ đọc hơn. Nếu đã tới ba cấp, hãy quay lại dùng vòng lặp.

Dictionary và set comprehension

Cùng một ý tưởng, chỉ khác dấu ngoặc:

numbers = [1, 2, 3, 4, 5]

# Dict comprehension - produces a dict
squares = {n: n * n for n in numbers}
print(squares)

# Set comprehension - produces a set
unique_squares = {n * n for n in [1, -1, 2, -2, 3]}
print(unique_squares)

Thoạt nhìn set comprehension trông giống hệt dict comprehension. Điểm khác là key: value so với chỉ một biểu thức. Ngoặc nhọn có : là dict; ngoặc nhọn không có : là set.

Generator expression

Gần như là anh em sinh đôi của list comprehension, nhưng dùng ngoặc tròn thay cho ngoặc vuông, và quan trọng nhất là nó không tạo ra list:

numbers = [1, 2, 3, 4, 5]

total = sum(n * n for n in numbers)
print(total)

any_negative = any(n < 0 for n in numbers)
print(any_negative)

Để ý rằng ta truyền generator thẳng vào sum() và any(), không cần thêm cặp ngoặc nào. Generator expression là công cụ phù hợp khi bên gọi chỉ cần lặp qua một lần. Với tập dữ liệu lớn, nó tiết kiệm bộ nhớ hơn hẳn một list đầy đủ.

Khi nào nên dùng vòng lặp thường

Comprehension rất hấp dẫn. Về mặt kỹ thuật, bạn có thể nhồi rất nhiều thứ vào một dòng. Nhưng đừng làm thế.

Hãy dùng vòng lặp thường khi:

• Phép biến đổi có nhiều hơn một bước. Nếu cần biến trung gian, hãy viết ra đầy đủ.
• Có xử lý lỗi hoặc rẽ nhánh phức tạp.
• Người đọc phải dừng lại nhiều hơn một lần mới hiểu được dòng code.

Một quy tắc dễ áp dụng: nếu đọc một hơi mà hiểu ngay comprehension làm gì thì giữ lại. Nếu bị vấp, viết lại thành vòng lặp.

Có những comprehension trông thông minh nhưng lại gây khó:

# Clever but exhausting:
data = [(x, y) for x in range(5) for y in range(5) if (x + y) % 2 == 0 and x != y]

# Clearer as a loop:
data = []
for x in range(5):
    for y in range(5):
        if (x + y) % 2 == 0 and x != y:
            data.append((x, y))

print(data)

Cùng một kết quả. Bản vòng lặp dài năm dòng thay vì một, nhưng "dài hơn" không có nghĩa là "tệ hơn".

Vài mẫu bạn sẽ dùng đi dùng lại

users = [
    {"name": "Ada", "active": True},
    {"name": "Boris", "active": False},
    {"name": "Ciara", "active": True},
]

# Grab one attribute from each element.
names = [u["name"] for u in users]
print(names)

# Filter and project in one go.
active_names = [u["name"] for u in users if u["active"]]
print(active_names)

# Build a lookup dict keyed by a field.
by_name = {u["name"]: u for u in users}
print(by_name["Ada"])

# Count how many pass a test.
active_count = sum(1 for u in users if u["active"])
print(active_count)

Mấy mẫu này bao quát được một lượng đáng kể công việc xử lý dữ liệu hằng ngày.

Tiếp theo

Bạn đã thấy các kiểu tập hợp chính và comprehension, thứ gắn kết chúng lại với nhau. Chương tiếp theo: hàm (function), cách đóng gói hành vi thành những đơn vị có tên và dùng lại được.