List Comprehension trong Python

Python Tutorial | 20/07/2025 by Hoc Python

Chào mừng bạn đến với chủ đề List Comprehension trong Python! Nếu bạn đã quen với việc tạo các List mới bằng vòng lặp for truyền thống, thì List Comprehension sẽ là một "cú hích" lớn giúp code của bạn trở nên ngắn gọn, mạnh mẽ và hiệu quả hơn. Đây là một trong những tính năng được yêu thích nhất của Python, cho phép bạn tạo List mới từ các iterable khác một cách rất "Pythonic". Hãy cùng khám phá cú pháp và sức mạnh của nó nhé!

List Comprehension là gì?

List Comprehension là một cú pháp ngắn gọn và mạnh mẽ trong Python, cho phép bạn tạo một List mới dựa trên một List hoặc một iterable (đối tượng có thể lặp, ví dụ như tuple, chuỗi, set, range) khác. Nó là một cách "Pythonic" để xây dựng List mà không cần sử dụng vòng lặp for truyền thống và phương thức append() một cách tường minh.

Về cơ bản, bạn có thể coi List Comprehension như một cách để viết một vòng lặp for đơn giản tạo List trên một dòng code duy nhất.

Tại sao nên dùng List Comprehension?

List Comprehension không chỉ là một tính năng "ngầu" của Python, mà còn mang lại nhiều lợi ích thực tế:

Ngắn gọn và súc tích: Đây là lợi ích rõ ràng nhất. List Comprehension cho phép bạn viết ít code hơn để đạt được cùng một kết quả so với việc sử dụng vòng lặp for truyền thống. Điều này giúp giảm "độ dài" của code và làm cho nó trông "sạch" hơn.
Dễ đọc và dễ hiểu (khi đã quen): Ban đầu có thể hơi lạ, nhưng khi đã quen với cú pháp, List Comprehension thực sự rất dễ đọc. Nó thể hiện rõ ràng mục đích của việc tạo List: "tạo một List mới chứa [biểu thức] cho mỗi [phần tử] trong [iterable]".
Hiệu quả cao hơn: Trong nhiều trường hợp, List Comprehension chạy nhanh hơn so với vòng lặp for truyền thống có sử dụng append(). Điều này là do Python có thể tối ưu hóa List Comprehension ở cấp độ nội bộ, thường là bằng cách phân bổ bộ nhớ hiệu quả hơn ngay từ đầu.

So sánh nhanh với vòng lặp `for` truyền thống

Để thấy rõ sự khác biệt và lợi ích của List Comprehension, hãy xem một ví dụ đơn giản: tạo một List chứa bình phương của các số từ 0 đến 4.

Cách 1: Sử dụng vòng lặp for truyền thống

# Khởi tạo một List rỗng
binh_phuong_truyen_thong = []

# Duyệt qua các số và thêm bình phương vào List
for i in range(5):
    binh_phuong_truyen_thong.append(i * i)

print(f"List bình phương (for truyền thống): {binh_phuong_truyen_thong}")
# Output: List bình phương (for truyền thống): [0, 1, 4, 9, 16]

Cách 2: Sử dụng List Comprehension

# Tạo List bình phương bằng List Comprehension
binh_phuong_comprehension = [i * i for i in range(5)]

print(f"List bình phương (List Comprehension): {binh_phuong_comprehension}")
# Output: List bình phương (List Comprehension): [0, 1, 4, 9, 16]

Nhận xét:

Bạn có thể thấy rõ ràng List Comprehension ([i * i for i in range(5)]) ngắn gọn và trực tiếp hơn rất nhiều so với phương pháp truyền thống.
Nó đọc gần như một câu tiếng Anh: "Tạo một list mới chứa i * i cho mỗi i trong range(5)."

Sự khác biệt về cú pháp này làm cho List Comprehension trở thành một công cụ mạnh mẽ và là phong cách lập trình được ưa chuộng trong cộng đồng Python.

Cú pháp cơ bản của List Comprehension trong Python

List Comprehension có một cú pháp rất đặc trưng, giúp bạn tạo ra một List mới một cách rõ ràng và ngắn gọn.

Cú pháp chung

new_list = [bieu_thuc for phan_tu in iterable]

Hãy cùng giải thích từng thành phần của cú pháp này:

new_list: Đây là tên của List mới sẽ được tạo ra sau khi thực hiện List Comprehension.

[] (dấu ngoặc vuông): Toàn bộ List Comprehension được đặt bên trong cặp dấu ngoặc vuông, điều này báo hiệu rằng kết quả sẽ là một List.

bieu_thuc (expression):

Đây là phần quan trọng nhất, nó định nghĩa giá trị mà mỗi phần tử mới trong new_list sẽ có.
bieu_thuc có thể là một biến, một phép toán, một lời gọi hàm, hoặc bất kỳ biểu thức Python hợp lệ nào.
Nó thường sử dụng biến phan_tu được định nghĩa trong vòng lặp for để tính toán giá trị.

for phan_tu in iterable:

Đây là phần giống như một vòng lặp for truyền thống.
phan_tu: Là một biến tạm thời (tương tự như biến lặp trong vòng lặp for thông thường) sẽ nhận giá trị của từng mục từ iterable trong mỗi lần lặp.
in: Từ khóa in để duyệt qua iterable.
iterable: Đây là một đối tượng mà bạn có thể duyệt qua từng phần tử của nó, ví dụ như một List, Tuple, Chuỗi (string), Set, hoặc range(). List Comprehension sẽ duyệt qua từng phần tử trong iterable này.

Ví dụ minh họa cơ bản

Để hiểu rõ hơn, hãy xem xét các ví dụ đơn giản sau:

Tạo List bình phương các số

Chúng ta muốn tạo một List mới chứa bình phương của các số từ 0 đến 4.

iterable: range(5) (tạo ra các số 0, 1, 2, 3, 4)
phan_tu: num (biến sẽ nhận các giá trị 0, 1, 2, 3, 4)
bieu_thuc: num * num (tính bình phương của num)

# Ví dụ 1: Tạo List bình phương các số từ 0 đến 4
squares = [num * num for num in range(5)]
print(f"List bình phương: {squares}")
# Output: List bình phương: [0, 1, 4, 9, 16]

Tạo List chứa các chữ cái từ một chuỗi

Chúng ta muốn tạo một List mới, mỗi phần tử là một chữ cái riêng lẻ từ chuỗi "Python".

iterable: "Python" (chuỗi này có thể duyệt qua từng ký tự)
phan_tu: char (biến sẽ nhận các ký tự 'P', 'y', 't', 'h', 'o', 'n')
bieu_thuc: char (chúng ta chỉ muốn lấy chính ký tự đó)

# Ví dụ 2: Tạo List chứa các chữ cái từ một chuỗi
word = "Python"
letters = [char for char in word]
print(f"List các chữ cái: {letters}")
# Output: List các chữ cái: ['P', 'y', 't', 'h', 'o', 'n']

Những ví dụ này cho thấy List Comprehension làm cho việc tạo List mới trở nên cực kỳ ngắn gọn và hiệu quả so với việc sử dụng vòng lặp for và append() truyền thống.

List Comprehension với Điều kiện (`if`) trong Python

List Comprehension trở nên mạnh mẽ hơn nữa khi bạn kết hợp nó với một điều kiện lọc sử dụng từ khóa if. Điều này cho phép bạn chỉ chọn những phần tử từ iterable gốc mà thỏa mãn một điều kiện nhất định để đưa vào List mới.

Khi nào dùng điều kiện?

Bạn sử dụng điều kiện if trong List Comprehension khi bạn muốn lọc (filter) các phần tử từ iterable nguồn. Tức là, chỉ những phần tử nào đáp ứng điều kiện mới được xử lý bởi bieu_thuc và đưa vào new_list. Các phần tử không thỏa mãn điều kiện sẽ bị bỏ qua hoàn toàn.

Cú pháp

new_list = [bieu_thuc for phan_tu in iterable if dieu_kien]

Giải thích vị trí và vai trò của if dieu_kien:

if dieu_kien: Đây là phần điều kiện lọc.

Nó được đặt sau phần for của List Comprehension.
dieu_kien là một biểu thức Boolean (trả về True hoặc False).
Trong mỗi lần lặp, Python sẽ kiểm tra dieu_kien cho phan_tu hiện tại.
Nếu dieu_kien là True, phan_tu đó sẽ được đưa vào bieu_thuc và kết quả được thêm vào new_list.
Nếu dieu_kien là False, phan_tu đó sẽ bị bỏ qua, không được đưa vào new_list.

Ví dụ minh họa:

Tạo List chỉ chứa các số chẵn

Chúng ta muốn tạo một List mới từ các số từ 1 đến 10, nhưng chỉ lấy những số chẵn.

iterable: range(1, 11) (các số từ 1 đến 10)
phan_tu: num
bieu_thuc: num (chỉ lấy chính số đó)
dieu_kien: num % 2 == 0 (số chia hết cho 2)

# Tạo List chỉ chứa các số chẵn từ 1 đến 10
numbers = range(1, 11)
even_numbers = [num for num in numbers if num % 2 == 0]
print(f"Các số chẵn: {even_numbers}")
# Output: Các số chẵn: [2, 4, 6, 8, 10]

So sánh với for truyền thống:

# Cách truyền thống
even_numbers_traditional = []
for num in range(1, 11):
    if num % 2 == 0:
        even_numbers_traditional.append(num)
print(f"Các số chẵn (truyền thống): {even_numbers_traditional}")

Bạn có thể thấy List Comprehension ([num for num in numbers if num % 2 == 0]) gọn gàng và dễ đọc hơn rất nhiều cho mục đích lọc này.

Tạo List chỉ chứa các chuỗi có độ dài nhất định

Chúng ta có một List các từ và muốn tạo một List mới chỉ chứa những từ có độ dài lớn hơn 5 ký tự.

iterable: words (List các chuỗi)
phan_tu: word
bieu_thuc: word.upper() (chuyển từ sang chữ hoa trước khi thêm vào List mới)
dieu_kien: len(word) > 5 (độ dài chuỗi lớn hơn 5)

# List các từ
all_words = ["apple", "banana", "cat", "dog", "elephant", "frog"]

# Tạo List chỉ chứa các từ có độ dài > 5 ký tự (và chuyển thành chữ hoa)
long_words_uppercase = [word.upper() for word in all_words if len(word) > 5]
print(f"Các từ dài hơn 5 ký tự (viết hoa): {long_words_uppercase}")
# Output: Các từ dài hơn 5 ký tự (viết hoa): ['BANANA', 'ELEPHANT']

Bằng cách sử dụng điều kiện if, List Comprehension trở thành một công cụ cực kỳ linh hoạt để tạo List mới dựa trên các tiêu chí lọc phức tạp.

List Comprehension với Điều kiện `if-else` trong Python

List Comprehension còn có một dạng nâng cao hơn, cho phép bạn áp dụng các biểu thức khác nhau cho từng phần tử dựa trên một điều kiện. Đây là lúc bạn sử dụng cấu trúc if-else bên trong List Comprehension.

Khi nào dùng `if-else`?

Bạn dùng cấu trúc if-else trong List Comprehension khi bạn muốn biến đổi các phần tử theo một cách khác nhau tùy thuộc vào việc chúng có thỏa mãn một điều kiện hay không. Thay vì chỉ lọc bỏ các phần tử như if đơn lẻ, if-else đảm bảo rằng mọi phần tử từ iterable gốc đều được xử lý và đưa vào new_list, nhưng giá trị của chúng sẽ khác nhau dựa trên điều kiện.

Cú pháp:

new_list = [bieu_thuc_true if dieu_kien else bieu_thuc_false for phan_tu in iterable]

Giải thích vị trí và vai trò của if-else:

bieu_thuc_true if dieu_kien else bieu_thuc_false: Đây là phần cốt lõi của if-else trong List Comprehension.

Nó được đặt trước phần for của List Comprehension (đây là điểm khác biệt quan trọng so với if đơn lẻ).
dieu_kien: Biểu thức Boolean (trả về True hoặc False) được kiểm tra cho phan_tu hiện tại.
bieu_thuc_true: Nếu dieu_kien là True, thì bieu_thuc_true sẽ được sử dụng để tạo giá trị cho phần tử mới.
bieu_thuc_false: Nếu dieu_kien là False, thì bieu_thuc_false sẽ được sử dụng để tạo giá trị cho phần tử mới.

for phan_tu in iterable: Phần này tương tự như trong các dạng List Comprehension khác, duyệt qua từng phan_tu trong iterable nguồn.

Mỗi phan_tu từ iterable sẽ trải qua kiểm tra dieu_kien, và dựa vào kết quả, một trong hai bieu_thuc (bieu_thuc_true hoặc bieu_thuc_false) sẽ được thực thi để tạo ra phần tử tương ứng trong new_list.

Ví dụ minh họa

Tạo List: nếu số chẵn thì giữ nguyên, nếu số lẻ thì nhân đôi

Chúng ta muốn duyệt qua các số từ 1 đến 5. Nếu số đó là chẵn, hãy giữ nguyên nó. Nếu số đó là lẻ, hãy nhân đôi nó.

iterable: range(1, 6) (các số 1, 2, 3, 4, 5)
phan_tu: num
dieu_kien: num % 2 == 0 (kiểm tra số chẵn)
bieu_thuc_true: num (giữ nguyên nếu chẵn)
bieu_thuc_false: num * 2 (nhân đôi nếu lẻ)

# Tạo List: nếu số chẵn thì giữ nguyên, nếu số lẻ thì nhân đôi
numbers = [1, 2, 3, 4, 5]
transformed_numbers = [num if num % 2 == 0 else num * 2 for num in numbers]
print(f"List sau khi biến đổi: {transformed_numbers}")
# Output: List sau khi biến đổi: [2, 2, 6, 4, 10]
# Giải thích:
# 1 (lẻ) -> 1 * 2 = 2
# 2 (chẵn) -> 2
# 3 (lẻ) -> 3 * 2 = 6
# 4 (chẵn) -> 4
# 5 (lẻ) -> 5 * 2 = 10

Chuyển đổi chuỗi: nếu bắt đầu bằng 'A' thì viết hoa, ngược lại thì viết thường

Chúng ta có một List các tên và muốn tạo một List mới. Nếu tên bắt đầu bằng chữ 'A', hãy viết hoa toàn bộ tên đó. Ngược lại, hãy viết thường toàn bộ tên đó.

iterable: names (List các chuỗi)
phan_tu: name
dieu_kien: name.startswith('A') (kiểm tra tên bắt đầu bằng 'A')
bieu_thuc_true: name.upper() (viết hoa nếu đúng)
bieu_thuc_false: name.lower() (viết thường nếu sai)

# List các tên
names = ["Alice", "bob", "Charlie", "Anna", "david"]

# Chuyển đổi chuỗi dựa trên điều kiện bắt đầu bằng 'A'
transformed_names = [name.upper() if name.startswith('A') else name.lower() for name in names]
print(f"List tên sau khi chuyển đổi: {transformed_names}")
# Output: List tên sau khi chuyển đổi: ['ALICE', 'bob', 'charlie', 'ANNA', 'david']

Cấu trúc if-else trong List Comprehension là một công cụ mạnh mẽ để thực hiện các phép biến đổi có điều kiện trên các phần tử, giúp mã nguồn của bạn trở nên gọn gàng và dễ bảo trì hơn đáng kể.

Kết bài

Chúng ta đã cùng nhau tìm hiểu List Comprehension trong Python, một tính năng mạnh mẽ và rất được ưa chuộng để tạo List mới một cách ngắn gọn, hiệu quả và dễ đọc.

Tóm tắt các hình thức của List Comprehension:

Cơ bản: [bieu_thuc for phan_tu in iterable]