Vòng lặp for và hàm range

Vòng lặp for trong Python thường được sử dụng để duyệt qua một dãy giá trị hoặc lặp lại một khối mã với số lần xác định trước thông qua hàm range().

Cơ chế hoạt động của range()

Hàm range(start, stop, step) tạo ra một dãy số bắt đầu từ start (mặc định là 0), kết thúc trước stop (không bao gồm stop), và tăng tiến theo step (mặc định là 1).

def tinh_tong_day_so(a, b):
    ket_qua = 0
    # Duyệt từ a đến b (bao gồm cả b)
    for i in range(a, b + 1):
        ket_qua += i
    return ket_qua

print(tinh_tong_day_so(5, 10)) # Kết quả: 45

Ngoài cách dùng vòng lặp thủ công, Python cung cấp hàm sum() để tối ưu hóa việc tính toán trên một iterable:

def tinh_tong_nhanh(a, b):
    return sum(range(a, b + 1))

Tùy biến bước nhảy và đảo ngược dãy số

Chúng ta có thể thay đổi tham số thứ ba để tạo các bước nhảy khác nhau hoặc sử dụng reversed() để lặp ngược lại.

def tong_so_le(bat_dau, ket_thuc):
    tong = 0
    # Chỉ duyệt qua các số lẻ bằng cách kiểm tra điều kiện bên trong
    for n in range(bat_dau, ket_thuc + 1):
        if n % 2 != 0:
            tong += n
    return tong

# Hoặc sử dụng bước nhảy trong range
def tong_buoc_nhay(m, n, k):
    return sum(range(m, n + 1, k))

# Lặp ngược dãy số
def duyet_nguoc(n):
    for i in reversed(range(n)):
        print(i, end=" ")

Vòng lặp lồng nhau (Nested Loops)

Vòng lặp lồng nhau thường được dùng để xử lý dữ liệu đa chiều hoặc vẽ các hình khối.

def ve_ma_tran_toa_do(hang, cot):
    for r in range(1, hang + 1):
        for c in range(1, cot + 1):
            print(f"[{r},{c}]", end=" ")
        print() # Xuống dòng sau mỗi hàng

ve_ma_tran_toa_do(3, 3)
"""
[1,1] [1,2] [1,3] 
[2,1] [2,2] [2,3] 
[3,1] [3,2] [3,3] 
"""

Một ví dụ khác về việc thay đổi giới hạn của vòng lặp con dựa trên vòng lặp cha:

def ve_tam_giac_so(n):
    for i in range(n):
        print(i, end=": ")
        for j in range(i):
            print("*", end=" ")
        print()

ve_tam_giac_so(5)

Vòng lặp while

Khác với for, vòng lặp while được sử dụng khi chúng ta không biết chính xác số lần lặp, mà chỉ quan tâm đến điều kiện dừng.

def tim_chu_so_dau_tien(n):
    n = abs(n)
    while n >= 10:
        n //= 10
    return n

print(tim_chu_so_dau_tien(98765)) # Kết quả: 9

Lưu ý về phong cách lập trình: Không nên dùng while để thay thế for trong các trường hợp đã biết rõ phạm vi (ví dụ: duyệt từ 1 đến 100), vì for sẽ giúp mã nguồn ngắn gọn và tránh lỗi lặp vô hạn.

Điều khiển vòng lặp với break, continue và pass

• break: Thoát khỏi vòng lặp hiện tại ngay lập tức.
• continue: Bỏ qua các dòng lệnh phía dưới trong lượt lặp hiện tại và chuyển sang lượt lặp kế tiếp.
• pass: Giữ chỗ cho khối lệnh chưa được định nghĩa, không thực hiện hành động nào.

def loc_du_lieu():
    for i in range(10):
        if i == 3:
            continue # Bỏ qua số 3
        if i == 7:
            break    # Dừng vòng lặp khi gặp số 7
        print(i, end=" ")
# Kết quả: 0 1 2 4 5 6

Tối ưu hóa thuật toán trong vòng lặp

Việc giảm thiểu số lần lặp là chìa khóa để cải thiện hiệu năng. Ví dụ điển hình là bài toán kiểm tra số nguyên tố.

import time
import math

# Cách tiếp cận cơ bản
def la_so_nguyen_to(n):
    if n < 2: return False
    for i in range(2, n):
        if n % i == 0:
            return False
    return True

# Cách tiếp cận tối ưu
def la_snt_nhanh(n):
    if n < 2: return False
    if n == 2: return True
    if n % 2 == 0: return False
    
    # Chỉ cần kiểm tra đến căn bậc hai của n
    gioi_han = int(math.sqrt(n))
    for i in range(3, gioi_han + 1, 2):
        if n % i == 0:
            return False
    return True

# Kiểm tra tốc độ với số lớn
so_lon = 104729 * 104729 # Một số lớn
start = time.time()
la_snt_nhanh(102030407)
end = time.time()
print(f"Thời gian thực thi: {(end - start) * 1000:.4f} ms")

Bằng cách sử dụng bước nhảy 2 (chỉ kiểm tra số lẻ) và giới hạn vòng lặp ở sqrt(n), chúng ta có thể giảm đáng kể khối lượng tính toán, giúp chương trình chạy nhanh hơn gấp nhiều lần so với cách duyệt thông thường.