Bài tập thực hành với Tuple trong Python

Việc học lý thuyết là rất quan trọng, nhưng cách tốt nhất để thực sự hiểu và ghi nhớ một khái niệm lập trình chính là qua thực hành. Loạt bài tập này được thiết kế để giúp bạn củng cố kiến thức về Tuple—một cấu trúc dữ liệu có thứ tự nhưng bất biến.Thông qua các bài tập từ cơ bản đến nâng cao nhẹ, bạn sẽ có cơ hội tự mình tạo, truy cập, cắt lát, và sử dụng các phương thức của Tuple. Hãy cùng nhau bắt tay vào giải quyết các thử thách này để nắm vững Tuple trong Python nhé!

Các Bài tập Thực hành trong Python

Bài tập 1: Khởi tạo và Truy cập phần tử cơ bản

Yêu cầu:

• Tạo một Tuple chứa tên 5 thành phố bạn yêu thích.

• Truy cập và in ra tên thành phố đầu tiên.

• Truy cập và in ra tên thành phố cuối cùng.

• Truy cập và in ra tên thành phố ở vị trí thứ 3.

Gợi ý: Dùng dấu ngoặc đơn () để tạo Tuple. Sử dụng chỉ số dương ([0], [2]) và chỉ số âm ([-1]).

Lời giải mẫu:

# 1. Tạo một Tuple chứa tên 5 thành phố
favorite_cities = ("Hà Nội", "TP. Hồ Chí Minh", "Đà Nẵng", "Huế", "Nha Trang")
print(f"Tuple các thành phố: {favorite_cities}")

# 2. Truy cập và in ra tên thành phố đầu tiên (chỉ số 0)
first_city = favorite_cities[0]
print(f"Thành phố đầu tiên: {first_city}") # Output: Thành phố đầu tiên: Hà Nội

# 3. Truy cập và in ra tên thành phố cuối cùng (chỉ số -1)
last_city = favorite_cities[-1]
print(f"Thành phố cuối cùng: {last_city}") # Output: Thành phố cuối cùng: Nha Trang

# 4. Truy cập và in ra tên thành phố ở vị trí thứ 3 (chỉ số 2)
third_city = favorite_cities[2]
print(f"Thành phố ở vị trí thứ 3: {third_city}") # Output: Thành phố ở vị trí thứ 3: Đà Nẵ

Bài tập 2: Cắt lát (Slicing) Tuple

Yêu cầu:

1. Cho Tuple số: numbers = (10, 20, 30, 40, 50, 60, 70, 80).

2. Tạo một Tuple mới chứa các số từ 30 đến 60 (bao gồm cả 30 và 60).

3. Tạo một Tuple mới chứa 3 số đầu tiên.

4. Tạo một Tuple mới chứa 2 số cuối cùng.

5. Tạo một Tuple mới là bản sao đảo ngược của numbers.

Gợi ý: Dùng cú pháp [start:end:step]. Nhớ end là không bao gồm phần tử tại chỉ số đó. Dùng [::-1] để đảo ngược.

Lời giải mẫu:

numbers = (10, 20, 30, 40, 50, 60, 70, 80)
print(f"Tuple gốc: {numbers}")

# 2. Các số từ 30 đến 60 (chỉ số 2 đến 6)
subset1 = numbers[2:7]
print(f"Các số từ 30 đến 60: {subset1}") # Output: Các số từ 30 đến 60: (30, 40, 50, 60, 70)

# 3. 3 số đầu tiên (từ chỉ số 0 đến 3)
subset2 = numbers[:3]
print(f"3 số đầu tiên: {subset2}") # Output: 3 số đầu tiên: (10, 20, 30)

# 4. 2 số cuối cùng (từ chỉ số -2 đến cuối)
subset3 = numbers[-2:]
print(f"2 số cuối cùng: {subset3}") # Output: 2 số cuối cùng: (70, 80)

# 5. Bản sao đảo ngược của Tuple
reversed_numbers = numbers[::-1]
print(f"Tuple đảo ngược: {reversed_numbers}") # Output: Tuple đảo ngược: (80, 70, 60, 50, 40, 30, 20, 10)

Bài tập 3: Giải nén (Unpacking) Tuple

Yêu cầu:

• Cho Tuple thông tin sản phẩm: product_info = ("Laptop", 1200, "Electronics"). Giải nén Tuple này thành ba biến riêng biệt: name, price, category. In giá trị của từng biến.

• Cho Tuple dữ liệu data = (1, 2, 3, 4, 5, 6, 7). Giải nén để lấy phần tử đầu tiên vào first, phần tử cuối cùng vào last, và tất cả các phần tử còn lại vào một biến middle_items (sử dụng *). In first, last, middle_items.

Gợi ý: Đảm bảo số lượng biến khớp với số lượng phần tử. Dùng * cho extended unpacking.

Lời giải mẫu:

# 1. Giải nén Tuple thông tin sản phẩm
product_info = ("Laptop", 1200, "Electronics")
name, price, category = product_info

print(f"Tên sản phẩm: {name}")       # Output: Tên sản phẩm: Laptop
print(f"Giá: {price}")               # Output: Giá: 1200
print(f"Danh mục: {category}")       # Output: Danh mục: Electronics

# 2. Giải nén Tuple với Extended Unpacking
data = (1, 2, 3, 4, 5, 6, 7)
first, *middle_items, last = data

print(f"Phần tử đầu tiên: {first}")   # Output: Phần tử đầu tiên: 1
print(f"Các phần tử ở giữa: {middle_items}") # Output: Các phần tử ở giữa: [2, 3, 4, 5, 6]
print(f"Phần tử cuối cùng: {last}")   # Output: Phần tử cuối cùng: 7

Bài tập 4: Nối Tuple

Yêu cầu:

• Tạo hai Tuple: part1 = (1, 2, 3) và part2 = (4, 5, 6).

• Nối hai Tuple này lại thành một Tuple mới có tên combined_tuple.

• Thêm một phần tử mới 7 vào cuối combined_tuple để tạo ra một Tuple mới khác.

Gợi ý: Sử dụng toán tử +. Nhớ bọc phần tử đơn lẻ trong () và dấu phẩy , để tạo thành Tuple một phần tử.

Lời giải mẫu:

# 1. Tạo hai Tuple
part1 = (1, 2, 3)
part2 = (4, 5, 6)

# 2. Nối hai Tuple
combined_tuple = part1 + part2
print(f"Tuple đã nối: {combined_tuple}") # Output: Tuple đã nối: (1, 2, 3, 4, 5, 6)

# 3. Thêm một phần tử mới vào cuối
# Nhớ tạo Tuple một phần tử: (7,)
final_tuple = combined_tuple + (7,)
print(f"Tuple sau khi thêm 7: {final_tuple}") # Output: Tuple sau khi thêm 7: (1, 2, 3, 4, 5, 6, 7)

Bài tập 5: Sử dụng Tuple Methods (count(), index())

Yêu cầu:

• Cho Tuple: grades = (85, 90, 75, 90, 80, 95, 90). Đếm số lần điểm 90 xuất hiện.

• Tìm chỉ số của lần xuất hiện đầu tiên của điểm 75.

• Tìm chỉ số của lần xuất hiện thứ hai của điểm 90 (gợi ý: dùng tham số start trong index()).

• Thử tìm chỉ số của điểm 100 và xử lý lỗi ValueError nếu không tìm thấy.

Gợi ý: Dùng grades.count(), grades.index(). Dùng try-except cho lỗi.

Lời giải mẫu:

grades = (85, 90, 75, 90, 80, 95, 90)
print(f"Tuple điểm số: {grades}")

# 1. Đếm số lần điểm 90 xuất hiện
count_90 = grades.count(90)
print(f"Số lần điểm 90 xuất hiện: {count_90}") # Output: Số lần điểm 90 xuất hiện: 3

# 2. Tìm chỉ số của lần xuất hiện đầu tiên của điểm 75
index_75 = grades.index(75)
print(f"Chỉ số của điểm 75: {index_75}") # Output: Chỉ số của điểm 75: 2

# 3. Tìm chỉ số của lần xuất hiện thứ hai của điểm 90 (bắt đầu tìm từ chỉ số 2)
# Chỉ số của 90 đầu tiên là 1, nên ta bắt đầu tìm từ chỉ số 2
second_index_90 = grades.index(90, 2)
print(f"Chỉ số của lần xuất hiện thứ hai của điểm 90: {second_index_90}") # Output: Chỉ số của lần xuất hiện thứ hai của điểm 90: 3

# 4. Xử lý lỗi khi tìm một giá trị không tồn tại
try:
    index_100 = grades.index(100)
    print(f"Chỉ số của điểm 100: {index_100}")
except ValueError:
    print("Không tìm thấy điểm 100 trong Tuple.")
# Output: Không tìm thấy điểm 100 trong Tuple.

Bài tập 6: Sử dụng Built-in Functions với Tuple

Yêu cầu:

• Cho Tuple số: data_points = (15, 22, 10, 30, 18, 25).

• Tìm độ dài của Tuple.

• Tìm giá trị lớn nhất trong Tuple.

• Tìm giá trị nhỏ nhất trong Tuple.

• Tính tổng các giá trị trong Tuple.

• Sắp xếp Tuple này theo thứ tự tăng dần và in ra kết quả (lưu ý: kết quả là List).

Gợi ý: Dùng len(), max(), min(), sum(), sorted().

Lời giải mẫu:

data_points = (15, 22, 10, 30, 18, 25)
print(f"Tuple dữ liệu: {data_points}")

# 2. Tìm độ dài của Tuple
length = len(data_points)
print(f"Độ dài của Tuple: {length}") # Output: Độ dài của Tuple: 6

# 3. Tìm giá trị lớn nhất
max_value = max(data_points)
print(f"Giá trị lớn nhất: {max_value}") # Output: Giá trị lớn nhất: 30

# 4. Tìm giá trị nhỏ nhất
min_value = min(data_points)
print(f"Giá trị nhỏ nhất: {min_value}") # Output: Giá trị nhỏ nhất: 10

# 5. Tính tổng các giá trị
total_sum = sum(data_points)
print(f"Tổng các giá trị: {total_sum}") # Output: Tổng các giá trị: 120

# 6. Sắp xếp Tuple và in ra kết quả (là một List)
sorted_data = sorted(data_points)
print(f"Tuple đã sắp xếp (dưới dạng List): {sorted_data}") # Output: Tuple đã sắp xếp (dưới dạng List): [10, 15, 18, 22, 25, 30]

Kết bài

Qua các bài tập này, bạn không chỉ củng cố lại lý thuyết mà còn tự mình trải nghiệm các thao tác quan trọng nhất với Tuple.

Bạn đã tự tay thực hiện:

• Khởi tạo và truy cập các phần tử Tuple bằng chỉ số.

• Sử dụng kỹ thuật cắt lát (slicing) để tạo ra các Tuple con.

• Thực hiện giải nén (unpacking), bao gồm cả unpacking mở rộng với dấu *.

• Nối các Tuple lại với nhau một cách hiệu quả.

• Sử dụng các method như count(), index() và các hàm tích hợp sẵn như len(), max(), min(), sum(), và sorted().

Lời khuyên cuối cùng:

Hãy xem các bài tập này như một điểm khởi đầu. Tuple là một công cụ tuyệt vời để làm việc với dữ liệu cố định, chẳng hạn như thông tin cấu hình, tọa độ, hoặc các hằng số.

Hãy luôn nhớ rằng Tuple là bất biến. Nếu bạn cần một cấu trúc dữ liệu linh hoạt hơn, có thể thêm, xóa hoặc sửa đổi phần tử, hãy sử dụng List. Việc hiểu rõ sự khác biệt này sẽ giúp bạn chọn đúng công cụ cho từng tác vụ trong các dự án của mình.