Hướng dẫn List Comprehension trong Python

Khi làm khoa học dữ liệu, bạn có thể muốn đọc các danh sách gồm nhiều danh sách con, lọc tên cột, loại bỏ nguyên âm khỏi một danh sách hoặc làm phẳng một ma trận. Bạn có thể dễ dàng dùng hàm lambda hoặc vòng lặp for; như bạn đã biết, có nhiều cách để làm việc này. Một cách khác là sử dụng list comprehension.

Hướng dẫn này sẽ đề cập đến chủ đề cuối cùng này:

• Trước tiên, bạn sẽ điểm lại ngắn gọn Python list là gì và chúng so sánh với các cấu trúc dữ liệu Python khác ra sao;
• Tiếp theo, bạn sẽ đi sâu vào Python list comprehension: bạn sẽ tìm hiểu thêm về nền tảng toán học đằng sau list trong Python, cách bạn có thể xây dựng list comprehension, cách viết lại chúng thành vòng lặp for hoặc hàm lambda, ... Bạn không chỉ đọc về điều này mà còn làm một số bài tập!
• Khi đã nắm vững các kiến thức cơ bản, cũng là lúc tinh chỉnh list comprehension bằng cách thêm điều kiện: bạn sẽ học cách đưa điều kiện vào list comprehension và cách xử lý nhiều điều kiện if và câu lệnh if-else.
• Cuối cùng, bạn sẽ tìm hiểu list comprehension lồng nhau để lặp nhiều lần trên các danh sách.

Nếu bạn cũng muốn tìm hiểu list comprehension cùng với iterator và generator? Hãy xem khóa học Python Data Science Toolbox của DataCamp!

Python Lists

Đến giờ, có lẽ bạn đã từng làm việc với các giá trị có nhiều kiểu dữ liệu. Bạn lưu từng giá trị vào một biến riêng: mỗi biến đại diện cho một giá trị đơn. Tuy nhiên, trong khoa học dữ liệu, bạn thường làm việc với rất nhiều điểm dữ liệu, khiến việc lưu từng giá trị vào biến riêng trở nên khó khăn. Thay vào đó, bạn lưu tất cả những giá trị này trong một Python list.

List là một trong bốn cấu trúc dữ liệu dựng sẵn trong Python. Các cấu trúc dữ liệu khác mà bạn có thể biết là tuple, dictionary và set. Một list trong Python khác với, chẳng hạn, int hoặc bool, ở chỗ nó là một kiểu dữ liệu tổng hợp: bạn có thể nhóm các giá trị lại với nhau trong list. Thực tế, các giá trị này không cần cùng kiểu: chúng có thể là sự kết hợp của boolean, String, integer, ...

Điểm quan trọng cần lưu ý là list là các tập hợp có thứ tự của các phần tử hoặc đối tượng. Điều này khiến list trong Python là "kiểu chuỗi" (sequence types), vì chúng hoạt động như một chuỗi. Điều đó có nghĩa là chúng có thể được lặp; Các ví dụ khác về sequence là String, tuple hoặc set.

Mẹo: nếu bạn muốn biết thêm, kiểm tra hoặc luyện tập kiến thức về Python list, bạn có thể xem qua các câu hỏi phổ biến nhất về Python list tại đây.

Về mặt thực hành: bạn tạo một list bằng hai dấu ngoặc vuông; Bên trong các ngoặc này, bạn dùng dấu phẩy để phân tách giá trị. Sau đó bạn có thể gán list cho một biến. Các giá trị trong Python list có thể thuộc bất kỳ kiểu dữ liệu nào, thậm chí là list!

Hãy xem ví dụ về một list sau:

Mẹo: hãy tự tạo list của bạn trong IPython shell nằm trong khối DataCamp Light phía trên!

Python List Comprehension

Với phần ôn tập về Python list còn mới, bạn có thể dễ dàng nhận ra rằng việc định nghĩa và tạo list trong Python có thể là một công việc tốn công: gõ từng giá trị riêng lẻ sẽ mất khá nhiều thời gian và bạn dễ mắc lỗi.

List comprehension trong Python được cấu trúc như sau:

list_variable = [x for x in iterable]

Nhưng làm sao bạn có được cách xây dựng và sử dụng những cấu trúc này theo kiểu công thức như vậy trong Python? Hãy đào sâu hơn một chút.

List Comprehension trong Python: Nền tảng Toán học

May mắn là Python có giải pháp cho bạn: nó cung cấp cách triển khai ký hiệu toán học để làm điều này: list comprehension.

Hãy nhớ trong toán học, các cách phổ biến để mô tả list (hoặc set, hoặc tuple, hoặc vector) là:

S = {x² : x in {0 ... 9}}
V = (1, 2, 4, 8, ..., 2¹²)
M = {x | x in S and x even}

Nói cách khác, bạn sẽ thấy rằng các định nghĩa trên thực ra cho bạn biết:

• Dãy S thực chất là một dãy chứa các giá trị từ 0 đến 9 (bao gồm) được nâng lên lũy thừa hai.
• Dãy V, ngược lại, chứa giá trị 2 được nâng lên một số mũ nhất định. Với phần tử đầu tiên trong dãy là 0, phần tử thứ hai là 1, và cứ thế cho đến 12.
• Cuối cùng, dãy M chứa các phần tử từ dãy S, nhưng chỉ lấy các số chẵn.

Nếu các định nghĩa trên khiến bạn đau đầu, hãy xem các list thực tế mà chúng sinh ra:

S = {0, 1, 4, 9, 16, 25, 36, 49, 64, 81}
V = {1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024, 2048, 4096}
M = {0, 4, 16, 36, 64}

Bạn có thể thấy rõ kết quả của mỗi list và các phép toán đã được mô tả trong đó!

Giờ khi bạn đã hiểu phần nào toán học đằng sau list, bạn có thể dịch hoặc triển khai ký hiệu toán học để xây dựng list trong Python bằng list comprehension! Hãy xem các dòng mã sau:

Tất cả những điều này trông rất giống các định nghĩa toán học mà bạn vừa thấy, đúng không?

Đừng lo nếu bạn hơi bối rối lúc này; Ngay cả khi bạn không phải là thiên tài toán học, các list comprehension khá dễ nếu bạn dành thời gian tìm hiểu. Hãy nhìn kỹ lại đoạn mã Python trong khối mã phía trên.

Bạn sẽ thấy rằng đoạn mã cho bạn biết rằng:

• List S được xây dựng với dấu ngoặc vuông như bạn đã đọc ở phần đầu. Trong ngoặc, bạn thấy có phần tử x được nâng lên lũy thừa 10. Bây giờ, bạn chỉ cần biết với bao nhiêu giá trị (và những giá trị nào!) bạn cần nâng lên lũy thừa 2. Điều này được xác định trong range(10). Xét tất cả, bạn suy ra rằng bạn sẽ nâng tất cả các số từ 0 đến 9 lên lũy thừa 2.
• List V chứa giá trị cơ số 2, được nâng lên một số mũ nhất định. Cũng như trước, bạn cần biết số mũ hay i chính xác được dùng là gì. Bạn thấy rằng i trong trường hợp này là một phần của range(13), nghĩa là bắt đầu từ 0 đến 12. Tất cả điều này có nghĩa list của bạn sẽ có 13 giá trị - những giá trị đó là 2 lũy thừa 0, 1, 2, ... cho đến 12.
• Cuối cùng, list M chứa các phần tử là một phần của S nếu -và chỉ nếu- chúng chia hết cho 2 không dư. Phần dư (modulo) phải bằng 0. Nói cách khác, list M được xây dựng từ các giá trị chẵn được lưu trong list S.

Giờ khi mọi thứ được viết ra, có vẻ hợp lý hơn nhiều, đúng không?

Tóm tắt và Luyện tập

Tóm lại, bạn thấy có vài thành phần lặp lại trong tất cả các dòng mã này:

• Dấu ngoặc vuông, đặc trưng của Python list;
• Từ khóa for, theo sau là một biến tượng trưng cho một phần tử list; Và
• Từ khóa in, theo sau là một chuỗi (có thể là một list!).

Và điều này tạo thành đoạn mã mà bạn đã thấy ở đầu phần này:

list_variable = [x for x in iterable]

Bây giờ đến lượt bạn bắt tay vào list comprehension trong Python! Hãy bám sát các list toán học mà bạn đã thấy trước đó:

List Comprehension như một Phương án thay thế cho...

List comprehension có thể thay thế hoàn toàn cho vòng lặp for, hàm lambda cũng như các hàm map(), filter() và reduce(). Hơn nữa, với một số người, list comprehension còn dễ hiểu và dễ dùng hơn trong thực tế! Bạn sẽ đọc thêm về điều này ở phần tiếp theo!

Tuy nhiên, nếu bạn muốn tìm hiểu thêm về hàm và hàm lambda trong Python, hãy xem Hướng dẫn Hàm trong Python của chúng tôi.

Vòng lặp For

Như bạn có thể đã biết, bạn dùng vòng lặp for để lặp lại một khối mã một số lần cố định. List comprehension thực sự là lựa chọn thay thế tốt cho vòng lặp for, vì chúng gọn hơn. Hãy xét ví dụ sau bắt đầu với biến numbers, được định nghĩa là một dải từ 0 đến 10 (không bao gồm 10).

Hãy nhớ rằng số bạn truyền vào hàm range() thực ra là số lượng số nguyên bạn muốn tạo, tất nhiên bắt đầu từ 0. Điều này có nghĩa range(10) sẽ trả về [0,1,2,3,4,5,6,7,8,9].

# Initialize `numbers`
numbers = range(10)

Nếu bây giờ bạn muốn thực hiện một phép toán trên mỗi phần tử trong numbers, bạn có thể làm với vòng lặp for như sau:

# Initialize `new_list`
new_list = []

# Add values to `new_list`
for n in numbers:
    if n%2==0:
        new_list.append(n**2)

# Print `new_list`
print(new_list)

[0, 4, 16, 36, 64]

Điều này ổn, nhưng hãy xét ví dụ list comprehension sau, nơi bạn làm điều tương tự với cú pháp gọn hơn:

# Create `new_list` 
new_list = [n**2 for n in numbers if n%2==0]

# Print `new_list`
print(new_list)

[0, 4, 16, 36, 64]

Hãy so sánh hiệu năng giữa list comprehension và vòng lặp for bằng một thử nghiệm nhỏ: bạn có thể thiết lập rất nhanh với thư viện timeit, dùng để đo thời gian chạy các đoạn mã Python nhỏ theo cách đơn giản. Trong trường hợp này, các đoạn mã nhỏ bạn sẽ thử là vòng lặp for, được đặt trong một hàm gọi là power_two() cho tiện, và list comprehension đúng như bạn đã viết ở trên.

Lưu ý rằng bạn cũng truyền vào số lần thực thi muốn xét. Ở đây, giá trị đó đặt là 10000 trong tham số number.

# Import `timeit`
import timeit

# Print the execution time
print(timeit.timeit('[n**2 for n in range(10) if n%2==0]', number=10000))

0.05234622399802902

# Define `power_two()` 
def power_two(numbers):
    for n in numbers:
        if n%2==0:
            new_list.append(n**2)
    return new_list

# Print the execution time 
print(timeit.timeit('power_two(numbers)', globals=globals(), number=10000))

0.07795589299712447

Lưu ý rằng trong đoạn mã cuối này, bạn cũng thêm tham số globals, khiến mã được thực thi trong không gian tên toàn cục hiện tại. Điều này cực kỳ hữu ích nếu bạn có một hàm do người dùng định nghĩa (UDF) như power_two() trong ví dụ trên. Ngoài ra, bạn cũng có thể truyền tham số setup chứa một câu lệnh import. Bạn có thể đọc thêm về điều đó tại đây.

Mẹo: xem hướng dẫn Loops in Python của DataCamp để biết thêm thông tin về vòng lặp trong Python.

Hàm Lambda với map(), filter() và reduce()

Hàm lambda còn được gọi là "hàm ẩn danh" hoặc "hàm không tên". Điều đó nghĩa là bạn chỉ dùng loại hàm này tại thời điểm chúng được tạo. Hàm lambda lấy tên từ từ khóa lambda trong Python, dùng để khai báo các hàm này thay vì từ khóa chuẩn def.

Bạn thường dùng các hàm này cùng với các hàm map(), filter() và reduce().

Cách thay thế map() kết hợp với hàm Lambda

Bạn có thể viết lại kết hợp map() và hàm lambda như ví dụ dưới đây:

# Initialize the `kilometer` list 
kilometer = [39.2, 36.5, 37.3, 37.8]

# Construct `feet` with `map()`
feet = map(lambda x: float(3280.8399)*x, kilometer)

# Print `feet` as a list 
print(list(feet))

[128608.92408000001, 119750.65635, 122375.32826999998, 124015.74822]

Bây giờ, bạn có thể dễ dàng thay thế tổ hợp hàm định nghĩa biến feet này bằng list comprehension, dựa trên các thành phần bạn đã đọc ở phần trước:

• Bắt đầu với dấu ngoặc vuông.
• Rồi thêm phần thân của hàm lambda vào trong ngoặc vuông: float(3280.8399)*x.
• Tiếp theo, thêm từ khóa for và nhớ lặp lại phần tử của chuỗi x, vốn bạn đã tham chiếu khi thêm thân hàm lambda.
• Đừng quên chỉ rõ x đến từ đâu: thêm từ khóa in, theo sau là chuỗi nơi bạn sẽ lấy x. Trong trường hợp này, bạn sẽ chuyển đổi các phần tử của list kilometer.

Nếu bạn làm tất cả những điều này, bạn sẽ được kết quả sau:

# Convert `kilometer` to `feet` 
feet = [float(3280.8399)*x for x in kilometer]

# Print `feet`
print(feet)

[128608.92408000001, 119750.65635, 122375.32826999998, 124015.74822]

filter() và Hàm Lambda sang List Comprehension

Giờ khi bạn đã thấy cách chuyển đổi dễ dàng hàm map() kết hợp với hàm lambda, bạn cũng có thể xử lý mã chứa hàm filter() của Python với hàm lambda và viết lại tương tự.

Xét ví dụ sau:

# Map the values of `feet` to integers 
feet = list(map(int, feet))

# Filter `feet` to only include uneven distances 
uneven = filter(lambda x: x%2, feet)

# Check the type of `uneven`
type(uneven)

# Print `uneven` as a list
print(list(uneven))

[122375, 124015]

Để viết lại các dòng mã trong ví dụ trên, bạn có thể dùng hai list comprehension, lưu vào cả biến feet và uneven.

Đầu tiên, bạn viết lại hàm map(), dùng để chuyển các phần tử của list feet thành số nguyên. Sau đó, bạn xử lý hàm filter(): bạn lấy thân của hàm lambda, dùng từ khóa for và in để kết nối logic giữa x và feet:

# Constructing `feet` 
feet = [int(x) for x in feet]

# Print `feet`
print(feet)

# Get all uneven distances
uneven = [x%2 for x in feet]

# Print `uneven`
print(uneven)

[128608, 119750, 122375, 124015]
[0, 0, 1, 1]

Hàm Reduce reduce() và Lambda trong Python

Cuối cùng, bạn cũng có thể viết lại các hàm lambda dùng với reduce() thành các dòng mã gọn hơn. Hãy xem ví dụ sau:

# Import `reduce` from `functools` 
from functools import reduce

# Reduce `feet` to `reduced_feet`
reduced_feet = reduce(lambda x,y: x+y, feet)

# Print `reduced_feet`
print(reduced_feet)

[128608, 119750, 122375, 124015]
494748

Lưu ý rằng trong Python 3, hàm reduce() đã được chuyển sang gói functools. Do đó bạn cần import module để sử dụng, như trong ví dụ trên.

Đoạn mã trên khá dài, phải không?

Hãy viết lại đoạn mã này!

Cẩn thận! Bạn cần lưu ý rằng bạn không thể dùng y. List comprehension chỉ hoạt động với một phần tử, như x mà bạn đã thấy xuyên suốt các ví dụ trong hướng dẫn này.

Bạn sẽ giải quyết thế nào?

Trong những trường hợp như vậy, các hàm tổng hợp như sum() có thể hữu ích:

# Construct `reduced_feet`
reduced_feet = sum([x for x in feet])

# Print `reduced_feet`
print(reduced_feet)

494748

Lưu ý rằng nếu suy nghĩ kỹ, việc dùng các hàm tổng hợp khi viết lại hàm reduce() kết hợp hàm lambda là hợp lý: nó rất giống những gì bạn làm trong SQL khi dùng hàm tổng hợp để giới hạn số bản ghi trả về sau khi chạy truy vấn. Ở đây, bạn dùng hàm sum() để tổng hợp các phần tử trong feet nhằm chỉ nhận về một giá trị cuối cùng!

Lưu ý rằng dù cách tiếp cận này có thể không tối ưu hiệu năng trong SQL, đây chắc chắn là cách nên làm khi bạn làm việc trong Python!

List Comprehension với Điều kiện

Giờ khi bạn đã hiểu những điều cơ bản về list comprehension trong Python, đã đến lúc điều chỉnh luồng điều khiển của comprehension với sự trợ giúp của điều kiện.

# Define `uneven`
uneven = [x/2 for x in feet if x%2==0]

# Print `uneven` 
print(uneven)

[64304.0, 59875.0]

Lưu ý rằng bạn có thể dễ dàng viết lại khối mã trên bằng một vòng lặp for trong Python!

# Initialize and empty list `uneven` 
uneven = []

# Add values to `uneven` 
for x in feet:
    if x % 2 == 0:
        x = x / 2
        uneven.append(x)

# Print `uneven` 
print(uneven)

[64304.0, 59875.0]

Nhiều Điều kiện If

Giờ khi bạn đã hiểu cách thêm điều kiện, hãy chuyển đổi vòng lặp for sau thành một list comprehension có điều kiện.

divided = []

for x in range(100):
    if x%2 == 0 :
        if x%6 == 0:
            divided.append(x)

Cẩn thận, bạn thấy vòng lặp for sau có hai điều kiện! Hãy suy nghĩ kỹ cách bạn sẽ giải quyết.

divided = [x for x in range(100) if x % 2 == 0 if x % 6 == 0]

print(divided)

[0, 6, 12, 18, 24, 30, 36, 42, 48, 54, 60, 66, 72, 78, 84, 90, 96]

Điều kiện If-Else

Tất nhiên, việc làm việc với các điều kiện liên quan đến nhiều nhánh phổ biến hơn nhiều. Đúng vậy, bạn thường thấy if kết hợp với elif và else. Vậy xử lý thế nào nếu bạn định viết lại mã của mình?

Hãy xem ví dụ sau về một điều kiện phức tạp hơn trong một vòng lặp for:

[x+1 if x >= 120000 else x+5 for x in feet]

[128609, 119755, 122376, 124016]

Bây giờ hãy xem khối mã sau, là phiên bản viết lại của đoạn trên:

for x in feet:  
    if x >= 120000:
        x + 1
    else: 
        x+5

Bạn thấy rằng đây cơ bản là cùng một đoạn mã, nhưng cấu trúc lại: phần for x in feet ở cuối nay khởi tạo vòng lặp for. Sau đó, bạn thêm điều kiện if x >= 120000 và dòng mã muốn thực thi nếu điều kiện này True: x + 1. Nếu điều kiện False, phần mã cuối trong list comprehension của bạn sẽ được thực thi: x+5.

List Comprehension Lồng nhau

Ngoài các điều kiện, bạn cũng có thể điều chỉnh list comprehension bằng cách lồng chúng bên trong các list comprehension khác. Điều này hữu ích khi bạn muốn làm việc với list của các list: việc tạo list của list, chuyển vị list của list hoặc làm phẳng list của list thành list thông thường, chẳng hạn, trở nên cực kỳ dễ với list comprehension lồng nhau.

Xem ví dụ sau:

list_of_list = [[1,2,3],[4,5,6],[7,8]]

# Flatten `list_of_list`
[y for x in list_of_list for y in x]

[1, 2, 3, 4, 5, 6, 7, 8]

Bạn gán một list của list khá đơn giản cho biến list_of_list. Ở dòng tiếp theo, bạn thực thi một list comprehension trả về một list bình thường. Thực chất là bạn lấy các phần tử list ( y ) của các list lồng nhau ( x ) trong list_of_list và trả về một list các phần tử y đó nằm trong x.

Bạn thấy rằng hầu hết các từ khóa và thành phần dùng trong ví dụ list comprehension lồng nhau tương tự như các ví dụ list comprehension đơn giản bạn đã dùng:

• Dấu ngoặc vuông
• Hai từ khóa for, theo sau là một biến tượng trưng cho một phần tử của list của list (x) và một phần tử của list lồng (y); Và
• Hai từ khóa in, theo sau là một list của list (list_of_list) và một phần tử list (x).

Hầu hết các thành phần chỉ dùng hai lần và bạn đi lên một cấp (hoặc xuống sâu hơn, tùy cách nhìn!).

Mất chút thời gian để quen, nhưng khá đơn giản, phải không?

Giờ hãy xét ví dụ khác, nơi bạn thấy rằng bạn cũng có thể dùng hai cặp ngoặc vuông để thay đổi logic của list comprehension lồng nhau:

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

[[row[i] for row in matrix] for i in range(3)]

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

Bây giờ luyện tập: viết lại khối mã trên thành một vòng lặp for lồng nhau. Nếu bạn cần gợi ý cách xử lý, hãy quay lại một trong các phần trước của hướng dẫn này.

transposed = []

for i in range(3):
     transposed_row = []
     for row in matrix:
            transposed_row.append(row[i])
     transposed.append(transposed_row)

Bạn cũng có thể dùng list comprehension lồng nhau khi cần tạo một list của list thực chất là một ma trận. Xem ví dụ sau:

matrix = [[0 for col in range(4)] for row in range(3)]

matrix

[[0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0]]

Mẹo: luyện kỹ năng vòng lặp trong Python và viết lại khối mã trên thành một vòng lặp for lồng nhau!

Bạn có thể tìm lời giải bên dưới.

for x in range(3):
    nested = []
    matrix.append(nested)
    for row in range(4):
        nested.append(0)

Nếu bạn muốn làm thêm, hãy thử chuyển vòng lặp for này sang vòng lặp while. Bạn có thể tìm lời giải bên dưới:

x = 0
matrix =[]

while x < 3:
    nested = []
    y = 0
    matrix.append(nested)
    x = x+1
    while y < 4:
        nested.append(0)
        y= y+1

Cuối cùng, bạn nên biết rằng bạn cũng có thể dùng các hàm như int() để chuyển các phần tử trong list feet thành số nguyên. Bằng cách bao [int(x) for x in feet] trong một list comprehension khác, bạn tạo một ma trận hay list của list từ list của bạn khá dễ dàng:

[[int(x) for x in feet] for x in feet]

[[128608, 119750, 122375, 124015],
 [128608, 119750, 122375, 124015],
 [128608, 119750, 122375, 124015],
 [128608, 119750, 122375, 124015]]

Làm chủ Python cho Khoa học Dữ liệu

Xin chúc mừng! Bạn đã đến cuối hướng dẫn này, nơi bạn đã tìm hiểu list comprehension, một cơ chế thường được dùng trong Python cho khoa học dữ liệu. Giờ khi bạn hiểu cách hoạt động của cơ chế này, bạn đã sẵn sàng chinh phục cả dictionary, set, ... comprehension!

Đừng quên bạn có thể luyện Python mỗi ngày với chế độ luyện tập hằng ngày của DataCamp! Bạn có thể tìm thấy nó ngay trên bảng điều khiển của bạn. Nếu bạn chưa biết chế độ luyện tập hằng ngày, hãy đọc thêm tại đây! Và khám phá toàn bộ danh mục khóa học Python của DataCamp tại đây.

Dù list comprehension có thể giúp mã của chúng ta súc tích hơn, điều quan trọng là đảm bảo mã cuối cùng dễ đọc nhất có thể, vì vậy nên tránh các dòng mã đơn quá dài để đảm bảo mã thân thiện với người dùng.