Lặp (iteration) là gì?

Một chương trình gửi email nhắc nhở cho 10.000 người dùng không chứa 10.000 bản sao của đoạn code gửi email. Nó chỉ chứa đoạn code đó một lần, bên trong một vòng lặp (loop), và vòng lặp chạy nó một lần cho mỗi người dùng. Mỗi lượt chạy là một lần lặp, và toàn bộ vòng lặp là cách chương trình duyệt qua danh sách người dùng.

Lặp hoạt động thế nào, từng bước

Mọi vòng lặp đều theo cùng một chu trình:

1. Kiểm tra. Xét điều kiện của vòng lặp, một giá trị boolean: còn phần tử nào nữa không, hay bộ đếm vẫn nhỏ hơn giới hạn?
2. Chạy. Nếu câu trả lời là đúng, chạy thân vòng lặp một lần.
3. Cập nhật. Chuyển sang phần tử tiếp theo hoặc thay đổi bộ đếm.
4. Lặp lại. Quay về bước 1. Khi kiểm tra cho kết quả sai, chương trình tiếp tục với phần code sau vòng lặp.

Ở đây thân vòng lặp chạy năm lần, mỗi lần lặp cộng số tiếp theo vào tổng đang tích lũy:

total = 0

for n in range(1, 6):
    total = total + n
    print("iteration", n, "total is now", total)

print("Done:", total)

iteration 1 total is now 1
iteration 2 total is now 3
iteration 3 total is now 6
iteration 4 total is now 10
iteration 5 total is now 15
Done: 15

Biến total nằm ngoài vòng lặp, nên nó giữ giá trị từ lần lặp này sang lần lặp sau. Mẫu này, một biến được gán trước vòng lặp và cập nhật bên trong nó, được gọi là biến tích lũy (accumulator), và nó xuất hiện trong gần như mọi vòng lặp có tính toán.

Vòng lặp đếm và vòng lặp theo điều kiện

Có hai kiểu lặp. Lặp xác định chạy một số lần biết trước: mỗi phần tử trong danh sách một lần, hoặc mỗi số từ 1 đến 5 một lần. Vòng lặp for của Python được thiết kế cho việc này, thường đi cùng range().

Lặp không xác định lặp lại cho đến khi một điều gì đó xảy ra, và số lượt không biết trước. Vòng lặp while hợp với trường hợp này:

balance = 100
years = 0

while balance < 200:
    balance = balance * 1.10
    years = years + 1

print(years, "years, balance", round(balance, 2))

8 years, balance 214.36

Số tiền tăng 10% mỗi năm cần 8 năm để tăng gấp đôi. Chương trình tìm ra điều đó bằng cách lặp, không phải bằng cách giải phương trình. Các hướng dẫn vòng lặp for và vòng lặp while trình bày cả hai trong Python.

Duyệt qua một tập hợp

Phần lớn vòng lặp duyệt qua một tập hợp: các phần tử của một mảng, các ký tự của một chuỗi, các dòng của một tệp. Vòng lặp for của Python đưa cho bạn trực tiếp từng phần tử, còn enumerate() thêm vị trí của nó:

fruits = ["apple", "banana", "cherry"]

for index, fruit in enumerate(fruits):
    print(index, fruit)

0 apple
1 banana
2 cherry

Ở phía sau, for yêu cầu tập hợp cung cấp một iterator bằng iter(), rồi gọi next() trên nó một lần cho mỗi lần lặp. Bạn có thể tự gọi những hàm này:

colors = ["red", "green", "blue"]

it = iter(colors)
print(next(it))
print(next(it))
print(next(it))
print(next(it, "no more items"))

red
green
blue
no more items

Nếu không có giá trị mặc định, lần gọi next() thứ tư sẽ gây ra StopIteration. Ngoại lệ đó là tín hiệu để vòng lặp for biết tập hợp đã hết.

Các ngôn ngữ khác viết cùng ý tưởng này theo cách khác. C đếm bằng chỉ số, còn Java và JavaScript cũng có loại vòng lặp đưa cho bạn từng phần tử:

for (int i = 0; i < 3; i++) {
    printf("%s\n", colors[i]);
}

for (String color : colors) {
    System.out.println(color);
}

for (const color of colors) {
    console.log(color);
}

Lặp và đệ quy

Đệ quy là cách còn lại để làm lặp lại một việc: một hàm tự gọi chính nó với phiên bản nhỏ hơn của bài toán, cho đến khi gặp trường hợp có thể trả lời ngay. Mọi thứ viết bằng cách này đều có thể viết bằng cách kia, nhưng chúng hoạt động khác nhau:

Hàng bộ nhớ có ý nghĩa thực tế. Mặc định Python cho phép khoảng 1.000 lời gọi lồng nhau, nên phép cộng đệ quy 5.000 số sẽ thất bại trong khi vòng lặp không gặp vấn đề gì:

def sum_loop(n):
    total = 0
    for k in range(1, n + 1):
        total = total + k
    return total

def sum_recursive(n):
    if n == 0:
        return 0
    return n + sum_recursive(n - 1)

print(sum_loop(100), sum_recursive(100))
print(sum_loop(5000))

try:
    print(sum_recursive(5000))
except RecursionError:
    print("sum_recursive(5000) failed: RecursionError")

5050 5050
12502500
sum_recursive(5000) failed: RecursionError

Mô phỏng đệ quy cho thấy ngăn xếp lời gọi lớn lên và thu nhỏ lại từng bước.

Những lỗi thường gặp

Vòng lặp vô hạn. Một vòng lặp while có điều kiện không bao giờ trở thành sai sẽ chạy mãi cho đến khi bạn dừng chương trình. Nguyên nhân thường gặp là quên bước cập nhật, chẳng hạn bỏ sót count = count - 1.

Lệch một đơn vị. range(1, 5) cho ra 1, 2, 3 và 4, không có 5, vì giá trị cuối bị loại trừ. Một vòng lặp chạy thừa hoặc thiếu một lần vẫn chạy mà không báo lỗi và cho ra kết quả sai, đó là một lỗi logic.

Sửa danh sách trong lúc đang duyệt nó. Xóa phần tử khỏi chính danh sách bạn đang lặp qua sẽ khiến vòng lặp bỏ sót phần tử:

numbers = [1, 2, 2, 3]

for n in numbers:
    if n == 2:
        numbers.remove(n)

print(numbers)

[1, 2, 3]

Một số 2 vẫn còn, vì khi xóa số 2 đầu tiên, số 2 thứ hai bị dồn vào vị trí mà vòng lặp đã đi qua. Hãy tạo một danh sách mới thay vào đó: numbers = [n for n in numbers if n != 2].

Đọc tiếp

Vòng lặp duyệt qua các tập hợp, nên mảng là gì là trang đi kèm tự nhiên, và boolean là gì giải thích các phép kiểm tra đúng hoặc sai quyết định khi nào vòng lặp dừng. Khi một vòng lặp cho kết quả sai mà không có thông báo lỗi, hãy đọc lỗi logic là gì. Để luyện viết vòng lặp, hãy bắt đầu khóa học Python hoặc thử các ví dụ trên trong Python playground.