Vòng lặp qua các phần tử của tuple

14.1 Vòng lặp for

Trong Python, việc duyệt qua các phần tử của một tuple thường được thực hiện bằng vòng lặp for. Đây là cách phổ biến nhất, cho phép bạn dễ dàng truy cập vào từng phần tử của tuple và thực hiện một khối mã cho nó.

Vòng lặp for

Vòng lặp for đi qua từng phần tử của tuple, tạm thời gán giá trị của phần tử hiện tại cho biến được chỉ định sau từ khóa for. Ví dụ:

my_tuple = (1, 2, 3, 4, 5)
for number in my_tuple:
    print(number)

Bạn đã có kinh nghiệm làm việc với danh sách và vòng lặp for, vì vậy hãy xem xét một số ví dụ thực tế:

Ví dụ 1: Tính tổng các phần tử của tuple

Hãy xem xét ví dụ, nơi chúng ta tính tổng tất cả các phần tử của tuple.

my_tuple = (10, 20, 30, 40, 50)
total = 0

for number in my_tuple:
    total += number

print(f"Tổng các phần tử của tuple: {total}")

Trong ví dụ này, chúng ta tạo một tuple my_tuple và một biến total để lưu trữ tổng các phần tử. Sử dụng vòng lặp for, chúng ta duyệt qua từng phần tử của tuple và cộng nó vào total. Cuối cùng, chúng ta nhận được tổng của tất cả các phần tử của tuple.

Ví dụ 2: Tìm phần tử lớn nhất

Bây giờ hãy xem xét ví dụ tìm phần tử lớn nhất trong tuple.

my_tuple = (5, 17, 23, 11, 2)
max_value = my_tuple[0]

for number in my_tuple:
    if number > max_value:
        max_value = number

print(f"Giá trị lớn nhất trong tuple: {max_value}")

Trong ví dụ này, chúng ta khởi tạo biến max_value với phần tử đầu tiên của tuple. Sau đó chúng ta duyệt qua tất cả các phần tử của tuple, so sánh từng phần tử với giá trị lớn nhất hiện tại và cập nhật max_value nếu tìm ra giá trị lớn hơn.

14.2 Tuple lồng nhau

Tuple có thể chứa các tuple khác, và vòng lặp for có thể được sử dụng để duyệt qua các cấu trúc dữ liệu lồng nhau.

nested_tuple = ((1, 2, 3), (4, 5, 6), (7, 8, 9))

for inner_tuple in nested_tuple:
    for number in inner_tuple:
        print(number, end=' ')
    print()

Trong ví dụ này, nested_tuple chứa các tuple. Chúng ta sử dụng vòng lặp lồng nhau for để duyệt qua từng phần tử của các tuple lồng nhau. Kết quả thực hiện là:

1 2 3 
4 5 6 
7 8 9 

14.3 Vòng lặp for với chỉ số

Cũng giống như danh sách, các phần tử của tuple có chỉ số, vì vậy có thể duyệt qua các phần tử của nó bằng vòng lặp for (kết hợp với hàm range()). Điều này cho phép bạn làm việc không chỉ với các phần tử mà còn với vị trí của chúng, điều này cần thiết cho các thao tác phức tạp hơn với dữ liệu.

Cơ bản về duyệt theo chỉ số

Để duyệt qua tuple với quyền truy cập vào chỉ số của từng phần tử, có thể sử dụng mã dạng:

my_tuple = ('a', 'b', 'c', 'd')
for i in range(len(my_tuple)):
    print(f'index: {i}, Element: {my_tuple[i]}')

Lợi ích của việc sử dụng chỉ số

Với chỉ số, dễ dàng thực hiện các thuật toán yêu cầu truy cập đồng thời nhiều phần tử của tuple, ví dụ, để so sánh phần tử hiện tại với phần tử trước hoặc kế tiếp.

Ví dụ:

my_tuple = (15, 20, 23, 18, 22, 19, 21)
for i in range(1, len(my_tuple)):
    if my_tuple[i] > my_tuple[i - 1]:  # So sánh phần tử với phần tử trước đó
        print(f'{my_tuple[i]} is greater than {my_tuple[i - 1]}')

Sử dụng vòng lặp for với chỉ số để xử lý dữ liệu

Giả sử chúng ta có một tuple chứa dữ liệu về nhiệt độ trong tuần, và chúng ta muốn tính nhiệt độ trung bình, loại bỏ các giá trị cực đoan (nhiệt độ thấp nhất và cao nhất).

temperatures = (15, 20, 23, 18, 22, 19, 21)
sorted_temps = sorted(temperatures)

# Loại bỏ nhiệt độ đầu tiên và cuối cùng
filtered_temps = sorted_temps[1:-1]

average_temp = sum(filtered_temps) / len(filtered_temps)
print(f"Nhiệt độ trung bình trong tuần (không có giá trị cực đoan): {average_temp}")

14.4 Sử dụng hàm enumerate()

Trong Python, hàm enumerate() cung cấp cách thuận tiện để duyệt qua các phần tử của tuple với quyền truy cập đồng thời vào chỉ số của chúng. Điều này đặc biệt hữu ích khi cần xử lý cả chỉ số và giá trị của phần tử danh sách trong vòng lặp.

Cơ bản về hàm enumerate()

Hàm enumerate() bao bọc tuple trong một đối tượng đặc biệt và trả về một iterator, cái tạo ra các cặp giá trị, bao gồm chỉ số và giá trị phần tử của tuple:

my_tuple = ('apple', 'banana', 'cherry')
for index, element in enumerate(my_tuple):
    print(f'index: {index}, Element: {element}')

Bây giờ bạn không chỉ có phần tử mà còn có chỉ số của nó.

Lợi ích của enumerate()

Sử dụng enumerate() làm mã dễ đọc hơn và cho phép tránh phải quản lý thủ công các chỉ số bằng range(len(…)). Điều này đơn giản hóa các thao tác với các phần tử danh sách, chẳng hạn như thay đổi, truy cập các phần tử và thực hiện các kiểm tra điều kiện.

Các ví dụ sử dụng

Đôi khi cần tìm tất cả các chỉ số nơi gặp một giá trị cụ thể trong tuple.

my_tuple = (1, 2, 3, 2, 4, 2, 5)
search_value = 2
indices = []

for index, value in enumerate(my_tuple):
    if value == search_value:
        indices.append(index)

print(f"Giá trị {search_value} gặp tại các chỉ số: {indices}")

Mã này tìm tất cả các chỉ số, nơi giá trị 2 gặp trong tuple:

Giá trị 2 gặp tại các chỉ số: [1, 3, 5]

Lọc dữ liệu dựa trên chỉ số

Xem xét ví dụ, nơi chúng ta lọc dữ liệu dựa trên chỉ số, chỉ giữ lại các phần tử có chỉ số chẵn.

my_tuple = ('a', 'b', 'c', 'd', 'e', 'f')

filtered_tuple = tuple(value for index, value in enumerate(my_tuple) if index % 2 == 0)
print(f"Tuple với các phần tử tại chỉ số chẵn: {filtered_tuple}")

Mã này tạo một tuple mới, chỉ chứa các phần tử có chỉ số chẵn:

Tuple với các phần tử tại chỉ số chẵn: ('a', 'c', 'e')