Hướng dẫn Python Tuples

Tuple so với List

Như bạn có thể thấy, tuple rất giống với list. Thực tế, bạn có thể coi chúng là các list bất biến, tức là một khi tuple được tạo ra, bạn không thể xóa hoặc thay đổi giá trị của các phần tử lưu trong đó. Bạn cũng không thể thêm giá trị mới. Xem ví dụ sau:

numbers_tuple = (1,2,3,4,5)
numbers_list = [1,2,3,4,5]

# Append a number to the tuple
numbers_tuple.append(6)

---------------------------------------------------------------------------

AttributeError                            Traceback (most recent call last)

<ipython-input-26-e47776d745ce> in <module>()
      3 
      4 # Append a number to the tuple
----> 5 numbers_tuple.append(6)


AttributeError: 'tuple' object has no attribute 'append'

Điều này gây lỗi vì bạn không thể xóa khỏi hoặc thêm vào một tuple, trong khi với list thì có thể.

# Append numbers to the list
numbers_list.append(6)
numbers_list.append(7)
numbers_list.append(8)

# Remove a number from the list
numbers_list.remove(7)
print(numbers_list)

[1, 2, 3, 4, 5, 6, 8]

Vậy tại sao lại dùng tuple nếu chúng bất biến?

Không chỉ cung cấp quyền truy cập "chỉ đọc" vào dữ liệu, tuple còn nhanh hơn list. Xem các đoạn mã sau:

import timeit
timeit.timeit('x=(1,2,3,4,5,6,7,8,9)', number=100000)

0.0018976779974764213

timeit.timeit('x=[1,2,3,4,5,6,7,8,9]', number=100000)

0.019868606992531568

Vậy "bất biến" thực sự có nghĩa gì đối với tuple?

Theo tài liệu chính thức của Python, bất biến là 'một đối tượng có giá trị cố định', nhưng 'giá trị' là một thuật ngữ khá mơ hồ; thuật ngữ chính xác hơn cho tuple sẽ là 'id'. 'id' là định danh của vị trí một đối tượng trong bộ nhớ.

Hãy xem kỹ hơn một chút:

# Tuple 'n_tuple' với một list là một phần tử của nó.
n_tuple = (1, 1, [3,4])

#Các phần tử có cùng giá trị thì có cùng id.
id(n_tuple[0]) == id(n_tuple[1])

True

#Các phần tử có giá trị khác nhau thì có id khác nhau.
id(n_tuple[0]) == id(n_tuple[2])

False

id(n_tuple[0])

4297148528

id(n_tuple[2])

4359711048

n_tuple.append(5)

---------------------------------------------------------------------------

AttributeError                            Traceback (most recent call last)

<ipython-input-40-3cd258e024ff> in <module>()
----> 1 n_tuple.append(5)


AttributeError: 'tuple' object has no attribute 'append'

Chúng ta không thể thêm phần tử vào một tuple, đó là lý do bạn thấy lỗi ở trên. Đây là lý do tuple được coi là bất biến. Nhưng, bạn luôn có thể làm như sau:

n_tuple[2].append(5)
n_tuple

(1, 1, [3, 4, 5])

Điều này cho phép bạn thực sự thay đổi tuple gốc. Vậy sao tuple vẫn được gọi là bất biến?

Bởi vì id của list bên trong tuple vẫn giữ nguyên ngay cả khi bạn đã thêm 5 vào đó.

id(n_tuple[2])

4359711048

Tóm tắt những gì bạn đã học đến giờ:

Một số tuple (chỉ chứa các đối tượng bất biến: chuỗi, v.v.) là bất biến và một số tuple khác (chứa một hoặc nhiều đối tượng có thể thay đổi: list, v.v.) là có thể thay đổi. Tuy nhiên, đây thường là chủ đề gây tranh luận trong cộng đồng Python và bạn sẽ cần nhiều kiến thức nền hơn để hiểu trọn vẹn. Bài viết này đi sâu hơn về chủ đề đó. Tạm thời, hãy coi tuple nói chung là bất biến.

• Bạn không thể thêm phần tử vào tuple do tính bất biến của chúng. Tuple không có phương thức append() hay extend(),
• Bạn không thể xóa phần tử khỏi tuple, cũng vì tính bất biến. Tuple không có phương thức remove() hay pop(),
• Bạn có thể tìm phần tử trong tuple vì thao tác này không làm thay đổi tuple.
• Bạn cũng có thể dùng toán tử in để kiểm tra một phần tử có tồn tại trong tuple hay không.

Vì vậy, nếu bạn đang định nghĩa một tập hằng số giá trị và tất cả những gì bạn làm là lặp qua chúng, hãy dùng tuple thay cho list. Nó sẽ nhanh hơn và cũng an toàn hơn, vì tuple chứa dữ liệu "chống ghi".

Nếu bạn muốn tìm hiểu thêm về list trong Python, nhớ xem hướng dẫn này!

Các Phép Toán Thông Dụng với Tuple

Python cung cấp cho bạn nhiều cách thao tác với tuple. Hãy cùng xem một số cách quan trọng kèm ví dụ.

Cắt Lát (Slicing) Tuple

Giá trị đầu tiên trong tuple có chỉ mục 0. Giống như với list trong Python, bạn có thể dùng giá trị chỉ mục kết hợp với ngoặc vuông [] để truy cập các phần tử trong tuple:

numbers = (0,1,2,3,4,5)
numbers[0]

0

Bạn cũng có thể dùng chỉ mục âm với tuple:

numbers[-1]

5

Trong khi indexing dùng để lấy từng phần tử riêng lẻ, slicing cho phép bạn lấy một tập con các phần tử. Khi bạn nhập một khoảng muốn trích xuất, đó được gọi là cắt lát theo khoảng. Cú pháp tổng quát của cắt lát theo khoảng là:

[Start index (included):Stop index (excluded):Increment]

Trong đó Increment là tham số tùy chọn, mặc định là 1.

# Phần tử tại chỉ mục 4 bị loại trừ
numbers[1:4]

(1, 2, 3)

# Lấy tất cả phần tử trong tuple
numbers[:]

(0, 1, 2, 3, 4, 5)

# Increment = 2
numbers[::2]

(0, 2, 4)

Mẹo: Bạn cũng có thể dùng bước âm để đảo ngược tuple.

numbers[::-1]

(5, 4, 3, 2, 1, 0)

Cộng Tuple

Bạn có thể kết hợp các tuple để tạo thành một tuple mới. Phép cộng đơn giản là phép nối (concatenation) với tuple.

x = (1,2,3,4)
y = (5,6,7,8)

# Kết hợp hai tuple để tạo tuple mới
z = x + y 

print(z)

(1, 2, 3, 4, 5, 6, 7, 8)

y = [5,6,7,8]
z = x + y
print(z)

---------------------------------------------------------------------------

TypeError                                 Traceback (most recent call last)

<ipython-input-55-d352c6414a4c> in <module>()
      1 y = [5,6,7,8]
----> 2 z = x + y
      3 print(z)


TypeError: can only concatenate tuple (not "list") to tuple

Bạn chỉ có thể cộng hoặc kết hợp các kiểu dữ liệu giống nhau. Vì vậy, kết hợp một tuple và một list sẽ gây lỗi.

Nhân Tuple

Phép nhân đơn giản dẫn đến lặp lại tuple.

x = (1,2,3,4)
z = x*2
print(z)

(1, 2, 3, 4, 1, 2, 3, 4)

Các Hàm với Tuple

Không giống list trong Python, tuple không có các phương thức như append(), remove(), extend(), insert() và pop() do tính bất biến. Tuy nhiên, có nhiều hàm dựng sẵn khác để làm việc với tuple:

count() và len()

count() trả về số lần xuất hiện của một phần tử trong tuple.

a = [1,2,3,4,5,5]
a.count(5)

2

Với hàm len(), bạn có thể trả về độ dài của tuple:

a = (1,2,3,4,5)
print(len(a))

5

any()

Bạn có thể dùng any() để xác định liệu bất kỳ phần tử nào của một tuple có giá trị đúng trong ngữ cảnh boolean hay không. Bạn sẽ nhận về True nếu có, ngược lại sẽ trả về False.

a = (1,)
print(any(a))

True

Lưu ý dấu , trong khai báo tuple a ở trên. Nếu bạn không đặt dấu phẩy khi khởi tạo một phần tử đơn trong tuple, Python sẽ cho rằng bạn vô tình thêm một cặp ngoặc (không gây hại) nhưng kiểu dữ liệu khi đó không phải là tuple. Vì vậy, hãy nhớ thêm dấu phẩy khi khai báo một phần tử đơn trong tuple.

Quay lại hàm any(): Trong ngữ cảnh boolean, giá trị cụ thể của phần tử không quan trọng. Một tuple rỗng là false, bất kỳ tuple nào có ít nhất một phần tử là true.

b = ()
print(any(b))

False

Hàm này hữu ích khi bạn gọi một tuple đâu đó trong chương trình và muốn đảm bảo rằng tuple đã có dữ liệu.

tuple()

Dùng tuple() để chuyển đổi một kiểu dữ liệu sang tuple. Ví dụ, trong đoạn mã dưới đây, bạn chuyển một list trong Python thành tuple.

a_list = [1,2,3,4,5]
b_tuple = tuple(a_list)
print(type(b_tuple))

<class 'tuple'>

min() và max()

max() trả về phần tử lớn nhất trong tuple, còn min() trả về phần tử nhỏ nhất. Xem ví dụ sau:

print(max(a))
print(min(a))

5
A

Bạn cũng có thể dùng điều này với các tuple chứa kiểu dữ liệu chuỗi.

# Chuỗi 'Apple' tự động được chuyển thành một dãy ký tự. 
a = ('Apple') 
print(max(a))

p

sum()

Với hàm này, bạn trả về tổng các phần tử trong một tuple. Chỉ dùng được với các giá trị số.

sum(a)

28

sorted()

Để trả về một dãy đã sắp xếp các phần tử, hãy dùng sorted(), như trong ví dụ sau:

a = (6,7,4,2,1,5,3)
sorted(a)

[1, 2, 3, 4, 5, 6, 7]

Lưu ý kiểu trả về là list chứ không phải tuple. Thứ tự trong tuple gốc 'a' không thay đổi và kiểu dữ liệu của 'a' vẫn là tuple.

Bonus: Gán Nhiều Giá Trị

Một điều thú vị bạn có thể làm với tuple là dùng chúng để gán nhiều giá trị cùng lúc. Xem ví dụ:

a = (1,2,3)
(one,two,three) = a
print(one)

1

a là một tuple gồm ba phần tử và (one,two,three) là một tuple gồm ba biến. Gán (one,two,three) cho tuple a sẽ gán từng giá trị của a cho từng biến: one, two và three, theo thứ tự. Điều này hữu ích khi bạn cần gán một dải giá trị cho một chuỗi được lưu trong tuple.

Chúc mừng!

Bạn đã đi đến cuối hướng dẫn về tuple! Trong quá trình đó, bạn đã hiểu rõ hơn Python tuple là gì, cách khởi tạo, các phép toán thường dùng để thao tác với chúng và những hàm phổ biến giúp bạn khai thác thêm thông tin từ cấu trúc dữ liệu Python này. Như một phần bổ sung, bạn đã biết rằng cũng có thể gán nhiều giá trị cho tuple cùng lúc.