Python中的元組(tuple)屬于不可變數據類型，即定義后不能修改，包括新增元素，刪除元素或修改元素的值。

一、tuple數據的定義

tuple中的每一項使用英文半角的逗號進行分隔，并且所有元素值放在一對英文半角的圓括號中“()”，tuple中每一項的數據類型可以不同。

>>> t1 = (1, 2, 3, 1)
>>> print(t1)
(1, 2, 3, 1)
>>> 

從上面的例子中，我們還可以知道，tuple中的元素值可以相同，如上面的例子 t1中有兩個 1.

tuple類型也可以像下面這種方式進行定義：

>>> t2 = 1, 2, 3, None, "Python"
>>> print(t2)
(1, 2, 3, None, 'Python')
>>>

也就是說，在省略圓括號時，Python也把具有逗號分隔的多個值視為tuple類型，同時，None 也可以是tuple的元素。

這個例子也向我們說明了，Python中的tuple可以具有不同數據類型的數據，如上面的數值類型，字符串類型和None類型。

>>> t3 =(('001', '張濤'), ('002', '劉紅', 23))
>>> print(t3)
(('001', '張濤'), ('002', '劉紅', 23))
>>> 

Python中的tuple類型可以為空，即沒有任何元素：

>>> t4 = ()
>>> print(t4)
()
>>>

但是在定義tuple類型時，只有一個元素且沒有逗號時，Python將會把該數據解釋成簡單的數據類型，如：

>>> t5 = (10)
>>> print(t5)
10
>>> print(type(t5))
<class 'int'>
>>>

也就是說，并沒有像用戶期待的輸出(10)，同時，通過使用type來判斷t5的類型發現，t5 是int類型的，這與直接使用 t5 = 10的效果相同。

對于其它類型也有相同的效果，下面給出了幾個例子：

>>> t6 = (12.3)
>>> print(t6, type(t6))
12.3 <class 'float'>
>>> t7 = ("Hello")
>>> print(t7, type(t7))
Hello <class 'str'>
>>>

如果tuple中確只有一個元素值，可以使用在其值后加逗號的方式來定義：

>>> t8 = (12.3,)
>>> print(t8, type(t8))
(12.3, ) <class 'tuple'>
>>> t9 = ('Hello', )
>>> print(t9, type(t9))
('Hello', ) <class 'tuple'>
>>>

二、訪問tuple的元素

我們可以使用tuple元素的索引來訪問元素值，其索引從0開始到tuple的長度-1（即元素個數-1）。訪問的語法格式如下：

tuple_name[索引值]

在使用時索引值不能越界，即當以正數索引訪問時，索引的最大值為：元素個數 - 1，超過此值將會引發 IndexError的錯誤；當以負數索引進行訪問時，索引的最小值是： -元素個數，比此值再小時也會引發 IndexError 錯誤。

t10 = (1, 2, 3, 4, 5)
print(t10[0])  # 輸出 1
print(t10[2])  # 輸出 3
print(t10[4])  # 輸出 5
print(t10[5])  # 索引越界，引發異常
print(t10[-1]) # 輸出 5
print(t10[-4]) # 輸出 2
print(t10[-5]) #輸出 1
print(t10[-6]) #索引越界，引發異常

以上在Python3.8.2中的輸出如下：

從以上可以看出，索引不在有效范圍內時將引發：IndexError 異常，告知：tuple index out of range(元組索引超出范圍）。

下面再介紹一下嵌套元組的訪問方法：

>>> t11 = (1, 2, (3, 4), (5, 6, 7))
>>> t11[0]
1
>>> t11[2][0]
3
>>> t11[3][2]
7
>>> t11[-2][1]
4
>>> t11[-2][-2]
3
>>> t11[3][-2]
6
>>>

從以上各例可以看出，我們可以靈活使用正數索引和負數索引來訪問元組中不同的元素值。

三、元組的切片操作

我們可以使用切邊功能創建一個子元組，即通過切片獲取元組中的部分值。切片的基本語法格式為：

tuple_name[ start : end : step ]

• start：切片開始時的索引，默認為0；
• end：切片結束位置的索引，默認為元組長度-1；
• step：步長，即每 step 獲取一個元素值，默認為1。

根據實際操作情況，三個索引都可以有選擇的使用。

下面使用具體的例子來介紹具體使用方法：

>>> t = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
>>> t1 = t[2 : ]  # 截取從索引2開始到最后的所有元素值
>>> print(t1)
(3, 4, 5, 6, 7, 8, 9, 10)
>>> t2 = t[ :7]  #從開頭到索引7停止，注意不含 索引7處的值
>>> print(t2)
(1, 2, 3, 4, 5, 6, 7)
>>> t3 = t[2 : 8]  # 從索引2開始到索引8停止，不含8處的值
>>> print(t3)
(3, 4, 5, 6, 7, 8)
>>> t4 = t[ 3 : 9 : 2]  # 從索引3到索引9 每2個取1個值
>>> print(t4)
(4, 6, 8)
>>> t5 = t[-5: ]  # 從后端進行索引
>>> print(t5)
(6, 7, 8, 9, 10)
>>> t6 = t[ : -5] # 截止到索引-5，不含-5
>>> print(t6)
(1, 2, 3, 4, 5)
>>> t7 = t[ -8 : -3 ]  # 從索引 -8 截取到 -3
>>> print(t7)
(3, 4, 5, 6, 7)
>>> t8 = t[-8 : -3 : 2] # 從索引 -8 截取到 -3，每2個取1個
>>> print(t8)
(3, 5, 7)
>>> t9 = t[-3 : -8 : -2]  # 從索引-3 開始到索引-8，從后往前每2截取1
>>> print(t9)
(8, 6, 4)
>>> t10 = t[9 : 2 : -2] # 從索引9到索引2，從后往前每2截1
>>> print(t10)
(10, 8, 6, 4)
>>> 
以上各例演示了實際中可能用到的切片方式，特別需要注意：

（1）start 處的值包含在截取結果中，end 指定的是截止位置，end 處的值不含在截取結果中；

（2）在不指定 step 時，start 指定的索引只有在邏輯上處于end的左側或與end相等時才會截取到值；

（2）step指定的截取步，可以理解為 每 step 個截取1個，不能理解為每隔 step 進行截取；

（3）step為正值時是從左往右進行截取，start邏輯上必須在end的左側才會截取到結果；

（4）step為負值時是從右往左截取，start邏輯上必須在end的右側才會截取到結果，如例子中的 t9和t10.

（5）start ，end 和 step 的值都可以省略，省略時，start = 0, end = len(t) - 1, step = 1，但是冒號不能省，

如下幾個例子：

>>> t11 = t[ : ]
>>> print(t11)
(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
>>> t11 = t[ : : ]
>>> print(t11)
(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
>>> t11 = t[]  # 企圖連冒號都要省
SyntaxError: invalid syntax
>>>

當把冒號都省略時會出現語法錯誤：無效的語法格式

以上各例在Python3.8.2中的運行情況如下圖所示：

關于Python中索引的使用方式，大家可以參照這篇文章《Python中創建列表、訪問列表、刪除列表等操作方法》里關于索引的示意圖與說明。Python中關于序列類型的索引方法是一致的。

四、元組不能增加元素、修改元素或刪除元素操作

因為元組tuple屬于不可變類型，其值無法像列表那樣進行增加、修改或刪除。

>>> t = (1, 2, 3, 4)
>>> t[1] = 10  # 企圖修改索引1處的值
Traceback (most recent call last):
    File "<pyshell#30>", line 1, in <module>
        t[1] = 10
TypeError: 'tuple' object does not support item assignment
>>> 

從上例可以看出，企圖修改元組的值是不允許的，給出 TypeError 錯誤。

但是如果元組中的元素是可變類型的話，我們仍可以修改這個元素的值，如下例：

>>> t = (1, 2, ['apple', 'orange', 'banana'], 3)
>>> t
(1, 2, ['apple', 'orange', 'banana'], 3)
>>> t[2][1] = 'berry'
>>> t
(1, 2, ['apple', 'berry', 'banana'], 3)
>>> t[2].remove('banana')
>>> t
(1, 2, ['apple', 'berry'], 3)
>>> 

五、刪除元組的定義

使用 del 命令可以刪除元組的定義。

>>> t = (1, 2, 3)
>>> print(t)
(1, 2, 3)
>>> del t
>>> print(t)
Traceback (most recent call last):
    File "pyshell#40", line 1, in <module>
        t
NameError: name 't' is not defined
>>> 

從上例可以看出，使用 del 命令刪除元組 t 的定義后，企圖再次使用時，將會產生 NameError 錯誤，即名稱 't' 未定義。

六、元組中的運算符

1、元組的連接

使用 + 運算符可以把 2 個或多個元組連接成一個新的元組。

>>> t1 = (1, 2, 3)
>>> t2 = (4, 5, 6, 7)
>>> t = t1 + t2
>>> print(t)
(1, 2, 3, 4, 5, 6, 7)
>>>

2、元組的重復運算

使用 * 可以把元組重復若干次后生成一個新的元組。

>>> t = (1, 2, 'apple', 3)
>>> t1 = t * 3
>>> print(t1)
(1, 2, 'apple', 3, 1, 2, 'apple', 3, 1, 2, 'apple', 3)
>>> 

3、成員檢測運算

使用 "in" 運算符可以檢測一個元組中是否包含某個元素值，也可以使用 "not in" 運算符檢測某個元素值是否不在一個元組中。

>>> t = ('python', 'C#', 'HTML', 'CSS', 'Java', 'R')
>>> print('python' in t)
True
>>> print('HTML' not in t)
False
>>> print('PHP' in t)
False
>>> 

七、迭代輸出元組中的值

我們可以使用for循環迭代輸出元組中的每個值。

langs = ("Python", "R", "PHP", "Java")
for e in langs:
    print(e)

for v in reversed(langs):
    print(v) 

第1個for循環正常順序輸出每個元組中的值，第2個for循環使用了reversed函數，把元組反轉后輸出。

輸出結果：

Python
R
PHP
Java
Java
PHP
R
Python

八、可以運用元組中的一些函數

1、len()函數

len()函數可以獲取元組的長度，即元組中值的個數。

>>> t1 = (1, 2, "python")
>>> print(len(t1))
3
>>> t2 = (1, 2, ["python", "R", "C#"], 'apple')
>>> print(len(t2))
4
>>> 

2、count()函數

count()函數可以統計元組中某元素的個數。

>>> t = ("A", "B", "A", "C", "D", "A")
>>> icnt = t.count("A")
>>> print(icnt)
3
>>> 

3、index()函數

index()函數返回元組中某個范圍內某元素第一次出現的位置索引。

index()函數的語法格式如下：

tup_name.index( x, start, end)

>>> t = (1, 2, 3, 1, 3, 4, 5)
>>> t.index(3)
2
>>> t.index(3, 3)
4
>>> t.index(3, 3, 5)
4
>>> t.index(3, -3)
4
>>> 

九、使用tuple()函數把其他序列值轉換為元組

我們可以只用tuple()函數來創建一個元組?？梢园蚜斜?，字符串等作為其參數來創建元組。

>>> lst1 = [1, 2, 3] # 列表
>>> t1 = tuple(lst1) # 使用列表來創建元組
>>> print(t1)
(1, 2, 3)
>>> s = "Python" # 字符串
>>> t2 = tuple(s) # 使用字符串來創建元組
>>> print(t2)
('P', 'y', 't', 'h', 'o', 'n')
>>> r = range(1, 5) # 生成范圍值
>>> t3 = tuple(r) # 使用范圍值來創建元組
>>> print(t3)
(1, 2, 3, 4, 5)
>>>

 以上是關于tuple類型的全部內容，如有什么疑問請留言評論。