Kích thước List trong Python: 8 phương pháp để tìm độ dài của List

List trong Python là một cấu trúc dữ liệu nền tảng, thiết yếu để lưu trữ và thao tác với các tập hợp phần tử. Tính linh hoạt và dễ dùng khiến chúng không thể thiếu trong nhiều tác vụ lập trình, từ phân tích dữ liệu đến phát triển web. Do được dùng rộng rãi, nhu cầu thường gặp là xác định kích thước của một list. Mặc dù hàm len() khá quen thuộc, cú pháp và thư viện phong phú của Python còn cung cấp nhiều cách khác nhau để làm điều này, mỗi cách có sắc thái và ứng dụng riêng. Bài viết này đi sâu vào tám phương pháp như vậy, cung cấp góc nhìn về cách hoạt động và hiệu quả của chúng.

Vì sao List trong Python quan trọng?

List trong Python là mảng động có thể chứa nhiều kiểu dữ liệu, cung cấp công cụ linh hoạt để lưu trữ và thao tác dữ liệu. Chúng hỗ trợ các thao tác như lặp, cắt (slicing), và các thao tác toàn diện với những phương thức dựng sẵn như append(), remove(), sort(), v.v. Bạn có thể đọc thêm về các thao tác với list trong hướng dẫn này.

Cách định nghĩa một List trong Python

Trong phạm vi hướng dẫn này, chúng ta sẽ dùng một list đơn giản để minh họa từng phương pháp. Xét list my_list, được định nghĩa như sau:

# Define a sample list to be used throughout the tutorial
my_list = ["I", "Love", "Learning", "Python"]Được hỗ trợ bởi

List này, tuy đơn giản, là ứng viên hoàn hảo để minh họa các kỹ thuật khác nhau nhằm xác định độ dài của nó.

8 cách tìm kích thước List trong Python

1. Tìm kích thước List bằng hàm len()

Hàm len() là cách trực diện nhất để xác định kích thước của một list. Nó không chỉ ngắn gọn mà còn rất hiệu quả, nên thường là phương pháp ưu tiên trong hầu hết trường hợp.

# Use len() to find the size of the list
length = len(my_list)
print(length)  # Output: 4Được hỗ trợ bởi

2. Tìm kích thước List bằng vòng lặp for

Được gọi là phương pháp ngây thơ (naive), cách này khởi tạo một biến đếm và tăng nó cho mỗi phần tử gặp phải khi duyệt list bằng vòng lặp for. Bạn có thể tìm hiểu thêm về vòng lặp for và các loại vòng lặp trong hướng dẫn này.

# Naive method using a for loop to count the list's size
counter = 0
for item in my_list:
    counter += 1
print(counter)  # Output: 4Được hỗ trợ bởi

3. Tìm kích thước List bằng List Comprehension

List comprehension trong Python cung cấp cú pháp gọn để thực hiện thao tác trên list. Ở đây, ta dùng nó cùng với hàm sum() để đếm phần tử.

# Using list comprehension to count the list's size
length = sum([1 for item in my_list])
print(length)  # Output: 4Được hỗ trợ bởi

4. Tìm kích thước List bằng reduce()

Hàm reduce() nâng cao hơn nhưng rất mạnh. Nó áp dụng một hàm hai đối số một cách tích lũy cho các phần tử của list, từ trái sang phải, để rút gọn list thành một giá trị. Với mục đích của chúng ta, ta sẽ dùng nó để đếm số phần tử trong list.

Để dễ hiểu, ta chia thành hai phần:

1. Định nghĩa một hàm đơn giản: Trước tiên, định nghĩa một hàm đơn giản nhận hai đối số: số đếm hiện tại (count_so_far) và một phần tử trong list (đặt tên là _ để chỉ rằng ta không dùng giá trị này).
2. Dùng reduce(): Sau đó, dùng reduce() để áp dụng hàm này cho mọi phần tử trong list, qua đó đếm chúng.

# Import the reduce function from the functools module
from functools import reduce

# Define a simple function to use with reduce
def update_count(count_so_far, _):
    """Increases the count by 1. The second parameter is not used."""
    return count_so_far + 1

# Use reduce to count the items in the list
# We start counting from 0, which is why we have '0' at the end
list_length = reduce(update_count, my_list, 0)

# Print out the result
print(list_length)  # Output will be 4Được hỗ trợ bởi

5. Tìm kích thước List bằng iter() và next()

Đếm phần tử trong list bằng iter() và next() đòi hỏi bạn quen với iterator. Iterator là một đối tượng trong Python cho phép ta đi qua các phần tử của list từng cái một. Hàm iter() biến list thành iterator, còn next() chuyển sang phần tử kế tiếp trong iterator.

Diễn giải từng bước:

1. Tạo iterator: Bắt đầu bằng cách biến list thành iterator với hàm iter(). Việc này giúp ta đi qua list từng phần tử.
2. Đếm bằng vòng lặp: Thiết lập một vòng lặp chạy cho đến khi không còn phần tử nào. Bên trong vòng lặp, dùng next() để chuyển sang phần tử tiếp theo. Mỗi lần chuyển thành công, tăng biến đếm thêm 1.
3. Xử lý khi hết list: Cuối cùng ta sẽ đến cuối list. Khi đó, next() sẽ phát sinh lỗi StopIteration, báo hiệu không còn phần tử nào. Ta bắt lỗi này bằng khối try/except và dừng đếm.

Dưới đây là mã đơn giản kèm chú thích để bạn theo dõi từng bước:

# Step 1: Turn the list into an iterator
list_iterator = iter(my_list)

# Initialize a counter to keep track of the number of items
count = 0

# Step 2: Loop through the list using the iterator
while True:
    try:
        # Use next() to get the next item from the iterator
        next(list_iterator)
        
        # If next() was successful, increase the count
        count += 1
    except StopIteration:
        # Step 3: If we reach the end of the list, break out of the loop
        break

# Print out the total count of items in the list
print(count)  # Output will be 4Được hỗ trợ bởi

6. Tìm kích thước List bằng enumerate()

Hàm enumerate() trong Python thêm một bộ đếm vào một iterable và trả về dưới dạng một đối tượng enumerate. Hàm này thường dùng trong vòng lặp để lấy cả chỉ mục và giá trị của từng phần tử trong list. Dù enumerate() không thường được dùng để tìm kích thước list, ta có thể dùng nó để minh họa Python linh hoạt đến mức nào.

# Step 1: Enumerate the list and convert it to a list of tuples (index, element)
enumerated_list = list(enumerate(my_list))

# Step 2: Extract the last tuple (which contains the last index and the last element)
last_tuple = enumerated_list[-1]

# Step 3: The size of the list is the last index plus 1 (because of zero-based indexing)
list_size = last_tuple[0] + 1

# Print out the size of the list
print(list_size)  # Output will be 4Được hỗ trợ bởi

7. Tìm kích thước List bằng NumPy

NumPy là một thư viện mạnh mẽ trong Python, được dùng rộng rãi trong tính toán khoa học. Nó hỗ trợ mảng và ma trận lớn, đa chiều, cùng bộ hàm toán học để thao tác trên các mảng này. Với những ai làm việc với dữ liệu số, NumPy là công cụ không thể thiếu, cung cấp khả năng lưu trữ và thao tác hiệu quả trên tập dữ liệu lớn. Để tìm kích thước của list trong Python bằng NumPy, ta có thể dùng thuộc tính .size như dưới đây.

# Import the NumPy library
import numpy as np

# Step 1: Convert the list into a NumPy array
my_array = np.array(my_list)

# Step 2: Use the 'size' attribute of the NumPy array to find its size
array_size = my_array.size

# Print out the size of the array (which is the same as the length of the list)
print(array_size)  # Output will be 4Được hỗ trợ bởi

8. Tìm kích thước List bằng map() và sum()

Tương tự list comprehension, phương pháp này dùng map() để áp dụng một hàm trả về 1 cho mỗi phần tử, sau đó dùng sum() để cộng dồn các giá trị này nhằm đếm phần tử. Cách này cần bạn quen với hàm lambda trong Python. Để cập nhật nhanh, hãy xem hướng dẫn Python lambda này.

# Using map() and sum() to count the list's size
length = sum(map(lambda x: 1, my_list))
print(length)  # Output: 4Được hỗ trợ bởi

So sánh hiệu năng của các phương pháp tìm kích thước List trong Python

Biết cả tám phương pháp là một chuyện, còn dùng phương pháp tốt nhất lại là chuyện khác. Để so sánh hiệu năng của tám phương pháp đã bàn, chúng ta sẽ dùng mô-đun timeit của Python, cung cấp cách đơn giản để đo thời gian chạy các đoạn mã nhỏ. Điều này sẽ cho ta cái nhìn rõ ràng về tốc độ thực thi của từng phương pháp. Lưu ý thời gian chạy có thể khác nhau tùy máy của bạn hoặc môi trường thực thi.

Thiết lập thử nghiệm

Để thuận tiện, ta định nghĩa list và các hàm cho mỗi phương pháp. Không sao nếu bạn chưa quen với hàm; về cơ bản, ta chỉ hệ thống hóa các phương pháp khác nhau để dễ so sánh.

import timeit
from functools import reduce
import numpy as np

# Define the list
my_list = ["I", "Love", "Learning", "Python"] * 100  # Increased size for better statistical signifcance

# Method 1: Using len()
def method_len():
    return len(my_list)

# Method 2: Looping through the list
def method_loop():
    counter = 0
    for _ in my_list:
        counter += 1
    return counter

# Method 3: Using a list comprehension
def method_list_comprehension():
    return sum([1 for _ in my_list])

# Method 4: Using reduce()
def method_reduce():
    return reduce(lambda acc, _: acc + 1, my_list, 0)

# Method 5: Using iter() and next()
def method_iter_next():
    iterator = iter(my_list)
    counter = 0
    while True:
        try:
            next(iterator)
            counter += 1
        except StopIteration:
            break
    return counter

# Method 6: Using enumerate()
def method_enumerate():
    return max(enumerate(my_list, 1))[0]

# Method 7: Using numpy
def method_numpy():
    np_array = np.array(my_list)
    return np_array.size

# Method 8: Using map() and sum()
def method_map_sum():
    return sum(map(lambda _: 1, my_list))Được hỗ trợ bởi

Đo thời gian cho từng phương pháp

Tiếp theo, ta dùng timeit.timeit() để đo thời gian của từng hàm theo thứ tự đã chỉ định:

# List to hold method names and their execution times
timing_results = []

methods = [method_len, method_loop, method_list_comprehension, method_reduce, 
           method_iter_next, method_enumerate, method_numpy, method_map_sum]

# Time each method
for method in methods:
 # Execute the operation 100000 times for better statistical significance  
    time_taken = timeit.timeit(method, number=100000)
    timing_results.append((method.__name__, time_taken))

# Sort results by time taken for better readability
timing_results.sort(key=lambda x: x[1])

# Print the timing results
for method_name, time_taken in timing_results:
    print(f"{method_name}: {time_taken:.5f} seconds")Được hỗ trợ bởi

Khi chạy trong DataLab, chúng tôi thu được kết quả sau:

Kết luận

Tổng kết lại, việc khám phá các phương pháp khác nhau để tìm kích thước của list trong Python không chỉ cho thấy sức mạnh và tính linh hoạt của Python, mà còn nhấn mạnh tầm quan trọng của việc hiểu hiệu quả và tính phù hợp của từng cách tiếp cận.

Với người mới bắt đầu, điều cốt yếu là khởi đầu bằng những phương pháp đơn giản và hiệu quả nhất, chẳng hạn dùng hàm dựng sẵn len(), vốn được tối ưu cho hiệu năng và khả năng đọc. Để tìm hiểu thêm về cách làm việc với list, hãy xem các tài nguyên sau:

• Python Fundamentals skill track
• Introduction to Python course
• Python Cheat Sheet for Beginners