Tuple là gì? Sự khác biệt giữa Tuple và List trong Python
Tuple là một trong những kiểu dữ liệu cơ bản và được sử dụng phổ biến bên cạnh List. Tuy nhiên, không phải ai cũng hiểu rõ Tuple là gì và điểm khác biệt giữa Tuple và List ra sao. Bài viết này, Bizfly Cloud sẽ giúp bạn khám phá khái niệm Tuple trong Python cũng như sự khác biệt quan trọng giữa Tuple và List.
Tuple là gì?
Tuple là một kiểu dữ liệu dùng để lưu trữ một tập hợp các phần tử có thứ tự và bất biến (không thể thay đổi sau khi tạo). Nó tương tự như List nhưng khác ở chỗ List có thể thay đổi được (mutable), còn Tuple thì không (immutable). Tuple có thể chứa các phần tử thuộc nhiều kiểu dữ liệu khác nhau và cho phép trùng lặp các phần tử. Các phần tử trong tuple được đánh chỉ mục bắt đầu từ 0 và được đặt trong dấu ngoặc tròn () với các phần tử cách nhau bằng dấu phẩy.
Tuple là gì?
Cấu trúc và cú pháp của Tuple
Cấu trúc Tuple của Tuple như sau:
Tuple được khai báo bằng cách đặt các phần tử vào trong dấu ngoặc đơn () và các phần tử được phân cách nhau bằng dấu phẩy ,.
Các phần tử trong tuple có thể thuộc các kiểu dữ liệu khác nhau như số nguyên, chuỗi, danh sách, hoặc thậm chí là tuple khác (tuple lồng nhau).
Tuple có thứ tự, tức là các phần tử được đánh số chỉ mục (index) bắt đầu từ 0.
Tuple là bất biến, không thể thay đổi, thêm hoặc xóa phần tử sau khi đã tạo.
Ví dụ về tuple:
(1, 2, 3, 4, 5) # Tuple chứa các số nguyên
('k', 't', 'e', 'r') # Tuple chứa các chuỗi
([1, 2], (3, 4)) # Tuple chứa một list và một tuple
(1, 'kteam', [2, 'k9']) # Tuple chứa số nguyên, chuỗi và list
Sự khác biệt giữa Tuple và List trong Python
Đặc điểm | List | Tuple |
Tính thay đổi | Mutable (có thể thay đổi) | Immutable (không thể thay đổi) |
Dấu ngoặc khai báo | [] | () |
Bộ nhớ | Dùng hai khối bộ nhớ | Dùng một khối bộ nhớ |
Hiệu suất | Chậm hơn khi thao tác thêm/xóa | Nhanh hơn khi lặp và truy cập |
Có thể làm key dict? | Không | Có |
Thường dùng cho | Dữ liệu đồng nhất, thay đổi | Dữ liệu không thay đổi, khác nhau |
Truy cập và thao tác với các phần tử trong Tuple
Truy cập phần tử trong Tuple
Truy cập theo chỉ số (Indexing):
Mỗi phần tử trong tuple được đánh số thứ tự bắt đầu từ 0. Ta có thể lấy phần tử bằng cách chỉ định chỉ số đó. Ví dụ:
my_tuple = ("apple", "banana", "cherry")
print(my_tuple[0]) # Kết quả: apple
print(my_tuple[2]) # Kết quả: cherry
Ngoài ra, có thể sử dụng chỉ số âm để truy cập phần tử từ cuối tuple, với -1 là phần tử cuối cùng, -2 là phần tử kế cuối, v.v.
Ví dụ:
print(my_tuple[-1]) # Kết quả: cherry
print(my_tuple[-2]) # Kết quả: banana
Truy cập tuple lồng nhau:
Tuple có thể chứa các tuple khác, ta có thể truy cập phần tử trong tuple lồng nhau bằng cách sử dụng nhiều chỉ số liên tiếp.
Ví dụ:
nested_tuple = (1, 2, (3, 4, 5), 6)
print(nested_tuple[2]) # Kết quả: (3, 4, 5)
print(nested_tuple[2][1]) # Kết quả: 4
Truy cập một phần của Tuple (Slicing)
Slicing cho phép lấy ra một phần con của tuple bằng cách chỉ định phạm vi chỉ số theo cú pháp:
tuple[start:end] (bao gồm phần tử tại start, không bao gồm phần tử tại end). Có thể sử dụng chỉ số âm trong slicing. Ví dụ:
my_tuple = ("a", "b", "c", "d", "e")
print(my_tuple[1:4]) # Kết quả: ('b', 'c', 'd')
print(my_tuple[:3]) # Kết quả: ('a', 'b', 'c')
print(my_tuple[2:]) # Kết quả: ('c', 'd', 'e')
print(my_tuple[-3:-1]) # Kết quả: ('c', 'd')
Truy cập phần tử bằng vòng lặp
Có thể dùng vòng lặp for để duyệt qua từng phần tử của tuple:
fruits = ('apple', 'banana', 'cherry')
for fruit in fruits:
print(fruit)
Kết quả:
apple
banana
cherry
Các thao tác khác với Tuple
Nối Tuple:
Dùng toán tử + để nối hai hoặc nhiều tuple thành một tuple mới.
Ví dụ:
tuple1 = (1, 2, 3)
tuple2 = (4, 5)
tuple3 = tuple1 + tuple2
print(tuple3) # Kết quả: (1, 2, 3, 4, 5)
Nhân Tuple:
Dùng toán tử * để nhân bản tuple, tạo ra tuple mới với phần tử lặp lại.
Ví dụ:
my_tuple = ('apple', 'banana')
new_tuple = my_tuple * 3
print(new_tuple) # Kết quả: ('apple', 'banana', 'apple', 'banana', 'apple', 'banana')
Kiểm tra phần tử tồn tại:
Dùng từ khóa in để kiểm tra phần tử có trong tuple hay không, trả về True hoặc False.
Ví dụ:
'apple'in my_tuple # True
'orange'in my_tuple # False
Các phương thức và hàm tích hợp với Tuple
Phương thức của Tuple
Do tính chất bất biến (immutable) của Tuple, nó chỉ hỗ trợ rất ít phương thức, chủ yếu để truy vấn dữ liệu:
count(obj): Đếm số lần phần tử obj xuất hiện trong Tuple.
Cú pháp: tuple.count(obj)
Ví dụ:
tup = (1, 2, 2, 3)
print(tup.count(2)) # Output: 2
index(obj[, start[, stop]]): Trả về chỉ số của phần tử obj xuất hiện đầu tiên trong Tuple (có thể giới hạn phạm vi tìm kiếm từ start đến stop).
Cú pháp: tuple.index(obj, start=0, stop=len(tuple))
Ví dụ:
tup = (1, 2, 3, 4)
print(tup.index(3)) # Output: 2
Các hàm tích hợp sẵn thường dùng với Tuple
Python cung cấp nhiều hàm tích hợp để thao tác và truy xuất dữ liệu từ Tuple:
len(tuple): Trả về số lượng phần tử trong Tuple.
max(tuple): Trả về phần tử có giá trị lớn nhất trong Tuple (yêu cầu các phần tử có thể so sánh được với nhau).
min(tuple): Trả về phần tử có giá trị nhỏ nhất trong Tuple.
sum(tuple): Tính tổng các phần tử số trong Tuple.
tuple(iterable): Chuyển một iterable (như list, string, dict) thành Tuple mới.
zip(iterable1, iterable2, ...): Kết hợp nhiều iterable thành một iterable mới chứa các tuple các phần tử tương ứng.
Ví dụ sử dụng một số hàm:
tup = (1, 2, 3, 4)
print(len(tup)) # 4
print(max(tup)) # 4
print(min(tup)) # 1
print(sum(tup)) # 10
list1 = [1, 2, 3]
tup2 = tuple(list1)
print(tup2) # (1, 2, 3)
list2 = ['a', 'b', 'c']
zipped = zip(list1, list2)
print(list(zipped)) # [(1, 'a'), (2, 'b'), (3, 'c')]
Ứng dụng thực tiễn của Tuple trong Python
Ứng dụng thực tiễn của Tuple trong Python rất đa dạng nhờ đặc tính bất biến (immutable) và khả năng lưu trữ nhiều giá trị khác kiểu trong một biến duy nhất. Dưới đây là một số ứng dụng phổ biến và thực tế của Tuple trong Python:
Lưu trữ dữ liệu không thay đổi: Tuple thường được dùng để lưu các tập hợp dữ liệu cố định, không cần thay đổi trong quá trình xử lý, ví dụ như tọa độ điểm, cấu hình hệ thống, hoặc các hằng số.
Trả về nhiều giá trị từ hàm: Trong Python, một hàm có thể trả về nhiều giá trị dưới dạng Tuple, giúp gói gọn nhiều kết quả trong một biến duy nhất và dễ dàng unpack (giải nén) các giá trị đó ra các biến riêng biệt.
Sử dụng làm khóa trong dictionary: Vì Tuple là bất biến, nó có thể được dùng làm khóa (key) trong dictionary, trong khi list thì không thể. Điều này rất hữu ích khi bạn cần lưu trữ dữ liệu phức tạp làm khóa để tra cứu nhanh.
Lưu trữ các bộ dữ liệu hỗn hợp: Tuple cho phép chứa các phần tử có kiểu dữ liệu khác nhau (số, chuỗi, boolean, object...), thuận tiện khi bạn cần lưu nhiều thông tin liên quan trong một biến duy nhất mà không cần thay đổi chúng.
Truy cập dữ liệu nhanh và an toàn: Do tính bất biến, Tuple giúp bảo vệ dữ liệu khỏi việc bị thay đổi ngoài ý muốn trong quá trình chạy chương trình, tăng tính an toàn cho dữ liệu quan trọng.
Sử dụng trong unpacking và gán nhiều biến: Tuple hỗ trợ kỹ thuật unpacking, cho phép gán nhanh nhiều giá trị cho nhiều biến cùng lúc, giúp code ngắn gọn và dễ đọc hơn.
Làm cấu trúc dữ liệu cho các thuật toán: Tuple được dùng trong các thuật toán cần lưu trữ các trạng thái hoặc các bộ dữ liệu tạm thời mà không cần thay đổi, ví dụ trong xử lý đồ thị, thuật toán tìm kiếm, hoặc xử lý dữ liệu đa chiều.
Kết hợp và nhân bản dữ liệu: Tuple hỗ trợ các phép toán như nối (+) và nhân bản (*) giúp tạo các bộ dữ liệu mới từ các Tuple hiện có một cách nhanh chóng và hiệu quả.
Kết luận
Trong bài viết này, chúng ta đã tìm hiểu về tuple, một kiểu dữ liệu mạnh mẽ và hữu ích trong Python. Với tính bất biến, cấu trúc đơn giản và khả năng lưu trữ nhiều loại dữ liệu khác nhau, tuple là một lựa chọn tuyệt vời cho nhiều tình huống lập trình.
