Kiểu dữ liệu Tuple trong Python - Python căn bản

Trong bài viết này chúng ta sẽ học cách sử dụng kiểu dữ liệu tuple trong Python. Cụ thể hơn sẽ tìm hiểu khái niệm tuple là gì? Cách sử dụng nó như thế nào? Các phương thức được tích hợp sẵn trong tuple.

Ở bài trước chúng ta đã học kiểu dữ liệu mảng và bạn cũng đã biết cách sử dụng rồi phải không nào?

Thực ra tuple cũng không có gì đặc biệt, cách khai báo và sử dụng nó không khác gì mảng. Nhưng tại sao Python lại bổ sung thêm tuple trong khi đã có mảng? Hãy cùng mình tìm hiểu ngay nhé.

1. Kiểu dữ liệu tuple trong Python là gì?

Trong Python, kiểu dữ liệu Tuple tương tự như mảng, sự khác biệt giữa chúng là ta không thể thay đổi các phần tử của một tuple, trừ khi phần tử đó là một mảng.

Ưu điểm của tuple so với mảng

Các phần tử của Tuple rất giống với List nên về cơ bản cả hai đều có thể sử dụng trong một tình huống tương tự nhau. Tuy nhiên, vẫn có một số lợi thế của Tuple so với List:

• Chúng ta thường dùng Tuple cho các kiểu dữ liệu không đồng nhất (các phần tử khác kiểu dữ liệu) và List cho các kiểu dữ liệu đồng nhất (các phần tử cùng kiểu dữ liệu).
• Vì tuple là bất biến, nên việc lặp qua tuple nhanh hơn so với List.
• Tuple có thể được sử dụng làm khóa cho Dictionary, trong khi list thì không thể.
• Nếu bạn có dữ liệu ít thay đổi, việc triển khai nó dưới dạng Tuple sẽ đảm bảo không bị thay đổi.

2. Cách tạo Tuple trong Python

Một tuple được tạo bằng cách đặt tất cả các mục (phần tử) bên trong dấu ngoặc đơn (), được phân tách bằng dấu phẩy. Các dấu ngoặc là tùy chọn, có hoặc không đều được, nhưng tốt nhất là nên sử dụng nó.

my_tuple = (element1, element2, ...)

Một tuple có thể có nhiều phần tử và mỗi phần tử có thể thuộc các kiểu dữ liệu khác nhau (int, float, list, string, v.v.).

# Các phần tử Tuple có thể có các kiểu dữ liệu khác nhau
my_tuple = ("Zaidap.com", [8, 4, 6], (1, 2, 3))
print(my_tuple)
# Kết quả: ("Zaidap.com", [8, 4, 6], (1, 2, 3))

# tuple có thể được tạo bằng cách bỏ đi cặp ngoặc đơn
my_tuple = 3, 4.6, "blog"
print(my_tuple)
# Kết quả: 3, 4.6, "blog"

# Bạn có thể tách các phần tử tuple thành nhiều biến nhỏ
a, b, c = my_tuple
print(a)
print(b)
print(c)
# Kết quả:
# 3
# 4.6
# blog

Việc tạo một Tuple chỉ có một phần tử sẽ phức tạp hơn một xíu, bởi vì trường hợp này thì Python sẽ dễ bị nhầm lẫn sang kiểu string, vì vậy ta phải bổ sung thêm dấu phẩy ở cuối để trình biên dịch Python nhận biết đó là một Tuple.

# Chỉ có một phần tử nên Python hiểu nhầm qua kiểu string
my_tuple = ("hello")
print(type(my_tuple))
# Kết quả: <class 'str'>

# Bạn thêm dấu phẩy để Python biết đây là 1 tuple
my_tuple = ("hello",)
print(type(my_tuple))
# Kết quả: <class 'tuple'>

# Bạn cũng có thể bỏ cặp dấu ngoặc đơn nhưng phải có dấu phẩy
my_tuple = "hello",
print(type(my_tuple))
# Output: <class 'tuple'>

3. Truy cập các phần tử của tuple trong Python

Có nhiều cách khác nhau để truy cập các phần tử của tuple.

Truy cập thông qua chỉ mục index

Chúng ta có thể sử dụng toán tử chỉ mục [] để truy cập đến một phần tử trong một tuple, chỉ mục bắt đầu từ 0.

Ví dụ, một tuple có 6 phần tử thì chỉ mục bắt đầu từ 0 đến 5, nên nếu bạn cố gắng truy cập đến cá phần tử khác như (6, 7, ...) thì sẽ gây ra lỗi IndexError.

Chỉ mục phải là một số nguyên (int), vì vậy bạn không thể sử dụng kiểu float hoặc các loại khác, điều này sẽ dẫn đến TypeError.

Tương tự, tuple lồng nhau được truy cập bằng cách sử dụng lập chỉ mục lồng nhau, như trong ví dụ dưới đây.

# Danh sách Tuple
my_tuple = ('p','e','r','m','i','t')

# Lấy phần tử đầu tiên trong tuple
print(my_tuple[0])
# Output: 'p'

# Lấy phần tử thứ 6 trong tuple
print(my_tuple[5])
# Output: 't'

# Mỗi phần tử của tuple là một mảng hoặc 1 tuple khác
n_tuple = ("mouse", [8, 4, 6], (1, 2, 3))

# Lấy phần tử thứ 4 của phần tử thứ nhất
print(n_tuple[0][3])
# Output: 's'

# Lấy phần tử thứ 2 của phần tử thứ 2
print(n_tuple[1][1])
# Output: 4

Số chỉ mục âm

Python cho phép lập chỉ mục số âm, chỉ số -1 đề cập đến phần tử cuối cùng, -2 cho phần tử cuối cùng thứ hai, v.v.

my_tuple = ('p','e','r','m','i','t')

# Phần tử cuối cùng
print(my_tuple[-1])
# Output: 't'

# Phần tử thứ 6 tính từ cuối lên
print(my_tuple[-6])
# Output: 'p'

Slicing

Chúng ta có thể truy cập vào một loạt các phần tử trong một tuple bằng cách sử dụng toán tử slicing, tức là dấu hai chấm ":".

• [begin:end] : Trong đó end là biên, tức sẽ ko lấy phần tử end mà lấy từ begin đến end - 1.

my_tuple = ('p','r','o','g','r','a','m','i','z')

# Lấy phần tử thứ 2 đến thứ 4
print(my_tuple[1:4])
# Output: ('r', 'o', 'g')

# Phần tử đầu tiên đến thứ hai (tức thứ 7 tính từ sau tới)
print(my_tuple[:-7])
# Output: ('p', 'r')

# Phần tử thứ 8 đến cuối
print(my_tuple[7:])
# Output: ('i', 'z')

# Lấy toàn bộ phần tử
print(my_tuple[:])
# Output: ('p', 'r', 'o', 'g', 'r', 'a', 'm', 'i', 'z')

Slicing có thể được xem là tốt nhất nếu bạn dùng nó để lấy một dãy các phần tử trong Tuple.

4. Thay đổi giá trị cho các phần tử Tuple trong Python

Không giống như mảng, bạn không thể thay đổi các phần tử của Tuple, điều này có nghĩa là các phần tử của một tuple không thể thay đổi một khi nó đã được gán giá trị.

Nhưng nếu phần tử tự nó là một kiểu dữ liệu giống như mảng thì ta có thể thay đổi được.

my_tuple = (4, 2, 3, [6, 5])

# Thay đổi giá trị cho phần tử thứ nhất của phần tử thứ 4 trong my_tuple.
my_tuple[3][0] = 9
print(my_tuple)

# Chương trình này sẽ bị lỗi
my_tuple = ('p','r','o','g','r','a','m','i','z')

# Bỏ dòng này sẽ không có lỗi như hình
# Bạn hãy thử mở lại dòng này sẽ thấy bị lỗi do ta cố tình thay đổi ..
# giá trị cho phần tử tuple
# my_tuple[1] = 'a'

print(my_tuple)

Kết quả:

5. Xóa Tuple

Như đã thảo luận ở trên, chúng ta không thể thay đổi các thành phần trong một tuple, điều đó cũng có nghĩa là chúng ta không thể xóa các phần tử của nó, nhưng hoàn toàn có thể xóa một tuple bằng cách sử dụng từ khóa del.

my_tuple = ('p','r','o','g','r','a','m','i','z')

# Xóa biến my_tuple
del my_tuple

# Lệnh này lỗi vì biến my_tuple đã bị xóa
my_tuple

6. Các phương thức trong Tuple

Trong lớp đối tượng Tuple hỗ trợ hai phương thức, đó là:

7. Một vài thao tác khác với Tuple

Sau đây là một vài thao tác khác với Tuple thường gặp nhất.

Kiểm tra phần tử có xuất hiện trong Tuple

Để kiểm tra một phần tử có xuất hiện trong tuple không thì ta dùng toán tử in.

my_tuple = ('a','p','p','l','e',)

# Toán tử in
print('a' in my_tuple)
# Output: True

print('b' in my_tuple)
# Output: False

# Toán tử not in
print('g' not in my_tuple)
# Output: True

Duyệt qua từng phần tử của Tuple

Để lặp qua từng phần tử của Tuple thì ta có thể sử dụng vòng lặp for.

for name in ('John','Kate'):
     print("Hello",name)   
# Output: 
# Hello John 
# Hello Kate

Ngoài ra vẫn còn một vài function khác thuộc lớp Build-in function.