Cách dùng vòng lặp với List trong Python

Python Tutorial | 20/07/2025 by Hoc Python

Chào mừng bạn đến với chủ đề Cách dùng vòng lặp với List trong Python! List là một cấu trúc dữ liệu cơ bản để lưu trữ các tập hợp có thứ tự. Để xử lý hoặc tương tác với từng phần tử trong List, vòng lặp (loop) là công cụ không thể thiếu. Bài viết này sẽ giúp bạn hiểu rõ các phương pháp phổ biến để duyệt qua List bằng vòng lặp, từ đó khai thác tối đa sức mạnh của chúng trong lập trình Python.

Vòng lặp là gì?

Trong lập trình, một vòng lặp (loop) là một cấu trúc điều khiển cho phép một khối mã lệnh được thực thi lặp đi lặp lại nhiều lần.. Thay vì phải viết cùng một đoạn mã nhiều lần, vòng lặp giúp chúng ta tự động hóa các tác vụ lặp, làm cho chương trình ngắn gọn, dễ đọc và hiệu quả hơn.

Hãy tưởng tượng bạn có một danh sách dài các việc cần làm. Thay vì phải viết từng dòng lệnh cho mỗi việc, bạn dùng vòng lặp để nói: "Với mỗi việc trong danh sách này, hãy thực hiện hành động X".

Tại sao cần dùng vòng lặp với List?

List là một cấu trúc dữ liệu được thiết kế để lưu trữ một tập hợp các phần tử. Khi làm việc với List, chúng ta thường cần xử lý từng phần tử một hoặc một nhóm phần tử theo một cách nhất quán. Đây chính là lúc vòng lặp phát huy vai trò quan trọng của nó:

Xử lý từng phần tử riêng lẻ: Bạn có thể muốn hiển thị từng phần tử, kiểm tra một điều kiện cho mỗi phần tử, hoặc thực hiện một phép toán trên từng mục. Vòng lặp giúp bạn tự động hóa việc này mà không cần truy cập từng chỉ số thủ công.

Ví dụ: Hiển thị tất cả các phần tử

# List các tên học sinh
danh_sach_hoc_sinh = ["An", "Bình", "Mai", "Long"]

print("Danh sách học sinh:")
for ten in danh_sach_hoc_sinh:
    print(ten)
# Output:
# Danh sách học sinh:
# An
# Bình
# Mai
# Long

Thực hiện tính toán tổng hợp hoặc phân tích dữ liệu: Vòng lặp là công cụ hoàn hảo để tính tổng, tìm giá trị lớn nhất/nhỏ nhất, đếm số lượng phần tử thỏa mãn điều kiện, hoặc thực hiện các phép thống kê trên toàn bộ List.

Ví dụ: Tính tổng điểm

diem_thi = [7, 8.5, 9, 6, 7.5]
tong_diem = 0

for diem in diem_thi:
    tong_diem += diem # Cộng dồn điểm của từng học sinh

print(f"Tổng điểm của các học sinh là: {tong_diem}")
# Output: Tổng điểm của các học sinh là: 38.0

Ví dụ: Đếm số học sinh giỏi (điểm >= 8)

diem_thi = [7, 8.5, 9, 6, 7.5]
so_hoc_sinh_gioi = 0

for diem in diem_thi:
    if diem >= 8:
        so_hoc_sinh_gioi += 1 # Tăng biến đếm nếu điểm thỏa mãn

print(f"Số học sinh giỏi là: {so_hoc_sinh_gioi}")
# Output: Số học sinh giỏi là: 2

Lọc dữ liệu: Bạn có thể dùng vòng lặp để tạo một List mới chỉ chứa các phần tử thỏa mãn một điều kiện nhất định từ List gốc.

Ví dụ: Lọc ra các số chẵn

cac_so = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
so_chan = [] # List rỗng để chứa các số chẵn

for so in cac_so:
    if so % 2 == 0: # Kiểm tra nếu số là chẵn
        so_chan.append(so) # Thêm vào List so_chan

print(f"Các số chẵn trong List là: {so_chan}")
# Output: Các số chẵn trong List là: [2, 4, 6, 8, 10]

Thay đổi các phần tử trong List: Mặc dù có cách dùng indexing trực tiếp để thay đổi, vòng lặp giúp bạn thay đổi hàng loạt phần tử một cách có điều kiện hoặc theo một quy tắc nhất quán.

Ví dụ: Tăng điểm của tất cả học sinh lên 1 (nếu điểm < 10) (Cách này cần sử dụng vòng lặp với chỉ số, sẽ được học chi tiết hơn trong phần for với range(len())).

diem_hoc_sinh = [7, 8, 9, 7.5]

# Vòng lặp với chỉ số để thay đổi trực tiếp phần tử
for i in range(len(diem_hoc_sinh)):
    if diem_hoc_sinh[i] < 10:
        diem_hoc_sinh[i] += 1 # Tăng điểm lên 1

print(f"Điểm học sinh sau khi cộng thêm: {diem_hoc_sinh}")
# Output: Điểm học sinh sau khi cộng thêm: [8, 9, 10, 8.5]

Vòng lặp là một công cụ không thể thiếu khi bạn cần thao tác hoặc phân tích dữ liệu trong List. Nó giúp mã nguồn của bạn trở nên hiệu quả, dễ quản lý và mạnh mẽ hơn rất nhiều.

Các loại vòng lặp phổ biến với List trong Python

Để làm việc hiệu quả với các phần tử trong List, Python cung cấp nhiều loại vòng lặp khác nhau. Mỗi loại có ưu điểm riêng và phù hợp với các tình huống sử dụng cụ thể.

Vòng lặp for (Cách phổ biến và Pythonic nhất)

Khái niệm: Vòng lặp for trong Python cung cấp cách trực quan và "Pythonic" nhất để duyệt qua từng phần tử của một List (hoặc bất kỳ iterable nào khác) một cách tuần tự. Nó tự động xử lý việc chuyển từ phần tử này sang phần tử tiếp theo cho đến khi duyệt hết List.

Cú pháp:

for phan_tu in ten_list:
    # Khối lệnh xử lý phan_tu
    # Các lệnh ở đây sẽ được thực thi một lần cho mỗi phần tử trong List

phan_tu: Là một biến tạm thời sẽ nhận giá trị của từng phần tử trong List trong mỗi lần lặp.

ten_list: Là List mà bạn muốn duyệt qua.

Ví dụ minh họa:

Hiển thị tất cả các phần tử:

# Danh sách các thành phố
cities = ["Hà Nội", "Đà Nẵng", "TP. Hồ Chí Minh", "Huế"]
print("Các thành phố ở Việt Nam:")
for city in cities:
    print(city)
# Output:
# Các thành phố ở Việt Nam:
# Hà Nội
# Đà Nẵng
# TP. Hồ Chí Minh
# Huế

Tính tổng/đếm số lượng phần tử thỏa mãn điều kiện:

# Danh sách điểm số của học sinh
scores = [7, 8.5, 9, 6, 7.5, 9.5]
total_score = 0
excellent_students = 0 # Số học sinh giỏi (điểm >= 9)

for score in scores:
    total_score += score # Cộng dồn điểm
    if score >= 9:
        excellent_students += 1 # Đếm học sinh giỏi

print(f"Tổng điểm của tất cả học sinh: {total_score}") # Output: Tổng điểm của tất cả học sinh: 47.5
print(f"Số học sinh giỏi: {excellent_students}") # Output: Số học sinh giỏi: 2

Lợi ích: Đơn giản, dễ đọc, và hiệu quả cho hầu hết các trường hợp bạn chỉ cần truy cập giá trị của các phần tử. Nó giúp mã nguồn trở nên gọn gàng và ít lỗi hơn.

Vòng lặp for với range() và len() (Duyệt theo chỉ số)

Khái niệm: Thay vì duyệt trực tiếp qua các phần tử, bạn có thể duyệt qua List bằng cách sử dụng các chỉ số (index) của chúng. Phương pháp này kết hợp hàm len() (trả về độ dài của List) và hàm range() (tạo ra một chuỗi các số nguyên từ 0 đến độ dài List - 1).

Khi nào sử dụng?:

Khi bạn cần truy cập cả phần tử VÀ chỉ số của nó cùng lúc.
Khi bạn cần thay đổi trực tiếp các phần tử trong List (vì bạn cần chỉ số để gán lại giá trị). Vòng lặp for phan_tu in ten_list không cho phép bạn thay đổi List gốc theo cách này.

Cú pháp:

for chi_so in range(len(ten_list)):
    phan_tu = ten_list[chi_so] # Lấy phần tử từ chỉ số
    # Khối lệnh xử lý phan_tu và/hoặc ten_list[chi_so]

Ví dụ minh họa:

Hiển thị phần tử kèm chỉ số:

# Danh sách sản phẩm
products = ["Laptop", "Mouse", "Keyboard", "Monitor"]
print("Sản phẩm và vị trí của chúng:")
for i in range(len(products)):
    print(f"Sản phẩm ở vị trí {i}: {products[i]}")
# Output:
# Sản phẩm và vị trí của chúng:
# Sản phẩm ở vị trí 0: Laptop
# Sản phẩm ở vị trí 1: Mouse
# Sản phẩm ở vị trí 2: Keyboard
# Sản phẩm ở vị trí 3: Monitor

Thay đổi giá trị của các phần tử trong List (update items):

# Danh sách điểm ban đầu
grades = [7, 6, 8, 5]
print(f"Điểm ban đầu: {grades}") # Output: Điểm ban đầu: [7, 6, 8, 5]

# Tăng điểm cho tất cả học sinh thêm 1 điểm
for i in range(len(grades)):
    grades[i] += 1 # Thay đổi trực tiếp phần tử tại chỉ số i

print(f"Điểm sau khi tăng: {grades}") # Output: Điểm sau khi tăng: [8, 7, 9, 6]

Vòng lặp `while` (Ít phổ biến hơn với List nhưng vẫn hữu ích)

Khái niệm: Vòng lặp while thực thi một khối lệnh miễn là một điều kiện nhất định còn đúng. Khi sử dụng với List, bạn thường cần tự quản lý một biến chỉ số (counter) để duyệt qua các phần tử.

Khi nào sử dụng?: Vòng lặp while ít được dùng để duyệt toàn bộ List một cách đơn giản vì vòng for thanh lịch hơn. Tuy nhiên, while rất hữu ích khi:

Bạn cần duyệt List cho đến khi tìm thấy một điều kiện cụ thể và muốn dừng lại ngay lập tức.
Bạn cần kiểm soát chi tiết hơn luồng lặp, ví dụ như thay đổi chỉ số lặp theo một logic phức tạp hơn việc tăng từng bước một.
Bạn có thể cần xóa phần tử trong quá trình lặp, vì việc xóa có thể ảnh hưởng đến chỉ số của các phần tử còn lại, và while cho phép bạn điều chỉnh chỉ số linh hoạt hơn.

Cú pháp:

chi_so = 0 # Khởi tạo biến chỉ số
while chi_so < len(ten_list): # Điều kiện lặp: chỉ số còn trong phạm vi List
    phan_tu = ten_list[chi_so]
    # Khối lệnh xử lý phan_tu
    chi_so += 1 # RẤT QUAN TRỌNG: Tăng chỉ số để tránh vòng lặp vô hạn

Ví dụ minh họa:

Duyệt cho đến khi tìm thấy một điều kiện nào đó:

# Danh sách các số
numbers = [10, 25, 30, 45, 50, 60]
index = 0
found_large_number = False

print("Đang tìm số lớn hơn 40:")
while index < len(numbers):
    current_number = numbers[index]
    if current_number > 40:
        print(f"Tìm thấy số lớn hơn 40 tại vị trí {index}: {current_number}")
        found_large_number = True
        break # Dừng vòng lặp ngay lập tức khi tìm thấy
    index += 1

if not found_large_number:
    print("Không tìm thấy số nào lớn hơn 40 trong List.")
# Output:
# Đang tìm số lớn hơn 40:
# Tìm thấy số lớn hơn 40 tại vị trí 3: 45

Xóa phần tử trong khi lặp (cần cẩn trọng):

# Ví dụ xóa các số chẵn (cẩn thận khi thay đổi List trong vòng lặp)
numbers = [1, 2, 3, 4, 5, 6]
print(f"List ban đầu: {numbers}") # Output: List ban đầu: [1, 2, 3, 4, 5, 6]

i = 0
while i < len(numbers):
    if numbers[i] % 2 == 0:
        numbers.pop(i) # Xóa phần tử chẵn, không tăng i vì các phần tử sau đã dịch chuyển
    else:
        i += 1 # Chỉ tăng i nếu không xóa

print(f"List sau khi xóa số chẵn: {numbers}") # Output: List sau khi xóa số chẵn: [1, 3, 5]

Các kỹ thuật và hàm hỗ trợ vòng lặp với List trong Python

Ngoài các loại vòng lặp cơ bản, Python cung cấp một số hàm tiện ích giúp việc duyệt List trở nên hiệu quả và gọn gàng hơn, đặc biệt là khi bạn cần truy cập cả chỉ số và giá trị của phần tử.

`enumerate()` (Kết hợp phần tử và chỉ số)

Khái niệm: Hàm enumerate() là một hàm tích hợp sẵn trong Python, được thiết kế đặc biệt để giúp bạn duyệt qua một iterable (như List) đồng thời truy cập cả chỉ số (index) và giá trị của phần tử trong mỗi lần lặp. Nó trả về các cặp (chỉ_số, phần_tử).

Cú pháp:

for chi_so, phan_tu in enumerate(ten_list):
    # Khối lệnh xử lý chi_so và phan_tu
    # Các lệnh ở đây sẽ được thực thi một lần cho mỗi cặp (chỉ_số, phần_tử)

chi_so: Biến này sẽ nhận giá trị chỉ số của phần tử hiện tại.

phan_tu: Biến này sẽ nhận giá trị của phần tử hiện tại.

ten_list: List mà bạn muốn duyệt qua.

Ví dụ minh họa: In chỉ số và phần tử cùng lúc.

# Danh sách các mùa trong năm
seasons = ["Xuân", "Hạ", "Thu", "Đông"]
print("Các mùa và chỉ số của chúng:")
for index, season in enumerate(seasons):
    print(f"Chỉ số {index}: {season}")
# Output:
# Các mùa và chỉ số của chúng:
# Chỉ số 0: Xuân
# Chỉ số 1: Hạ
# Chỉ số 2: Thu
# Chỉ số 3: Đông

Ví dụ khác: Tìm vị trí của một phần tử cụ thể

# Danh sách các nhiệm vụ
tasks = ["Đọc sách", "Viết báo cáo", "Tập thể dục", "Đi chợ"]
task_to_find = "Tập thể dục"

print(f"Tìm vị trí của '{task_to_find}':")
for i, task in enumerate(tasks):
    if task == task_to_find:
        print(f"'{task_to_find}' nằm ở chỉ số: {i}")
        break # Dừng vòng lặp sau khi tìm thấy
# Output: 'Tập thể dục' nằm ở chỉ số: 2

Lợi ích:

Gọn gàng và dễ đọc: enumerate() giúp mã nguồn của bạn trở nên sạch sẽ và dễ hiểu hơn nhiều so với việc sử dụng for i in range(len(list)): và sau đó truy cập list[i] khi bạn chỉ cần đọc cả chỉ số và giá trị.
Hiệu quả: Đây là một cách hiệu quả để thực hiện các tác vụ cần truy cập cả vị trí và giá trị của phần tử.
Tính Pythonic: Sử dụng enumerate() là một cách được khuyến nghị và mang tính "Pythonic" cao cho trường hợp này.

Kết bài

Chúng ta đã cùng nhau timg hiểu các cách mạnh mẽ để sử dụng vòng lặp với List trong Python. Việc duyệt qua các phần tử của List là một kỹ năng cơ bản nhưng cực kỳ quan trọng, giúp bạn thao tác và phân tích dữ liệu một cách hiệu quả.

Tóm tắt các phương pháp chính:

Vòng lặp for trực tiếp: Cách phổ biến và "Pythonic" nhất để duyệt qua từng giá trị phần tử.
Vòng lặp for với range(len()): Được sử dụng khi bạn cần truy cập cả chỉ số và giá trị của phần tử, hoặc khi bạn muốn thay đổi trực tiếp các phần tử trong List.
Vòng lặp while: Linh hoạt hơn nhưng ít được dùng trực tiếp để duyệt hết List. Hữu ích khi bạn cần điều kiện dừng phức tạp hoặc kiểm soát chỉ số chi tiết, ví dụ như khi xóa phần tử trong quá trình lặp.
Hàm enumerate(): Một cách gọn gàng và dễ đọc để lấy cả chỉ số và giá trị cùng lúc trong vòng lặp for.

Khi nào dùng phương pháp nào?

Dùng for trực tiếp khi bạn chỉ quan tâm đến giá trị của từng phần tử.
Dùng for với range(len()) khi bạn cần chỉ số để truy cập hoặc thay đổi các phần tử.
Dùng enumerate() khi bạn cần cả chỉ số và giá trị nhưng không có ý định thay đổi List.
Dùng while khi bạn cần kiểm soát luồng lặp phức tạp hơn, có thể dừng sớm, hoặc cần điều chỉnh chỉ số trong quá trình duyệt.