在本 Python 教程中，您将掌握关于 Python 元组的所有知识，包括元组的创建、元组的索引和切片，以及您应该熟悉 的各种元组运算符和方法。
元组是经过良好排序的对象的集合，这些对象本质上是不可变的。元组与列表非常相似，它们都遵循序列，但元组不支持对象的变异性，而列表支持变异性。更具体地说，一旦创建了元组，就无法更改其对象，但我们可以轻松地更改列表中的对象。
定义 Python 元组就像定义列表一样简单。Python 元组是通过将一系列有序对象括在括号或 **圆括号** () 中来定义的。每个对象都用 **逗号** , 分隔。尽管括号是可选的，但为了更好的编码和可读性，建议使用。下面的示例将有助于理解如何以不同的方式定义 Python 元组。
空元组：一个不包含任何元素的元组，长度为 0。
emp_tuple =()
单例元组：包含单个元素的元组。单例元组是通过在括号中将单个元素后跟一个逗号来定义的。在定义单个元素时，必须有一个尾随逗号，以强调这是一个元组，而不是一个表达式。
Sin_tuple =(10,)
同质元组：一个包含相同数据类型元素的元组
str_tuple =('a','b','x','y')
异构元组：一个包含各种数据类型元素的元组。
mix_tuple= (6,'Sixty',6.5)嵌套元组：一个包含另一个元组的元组
nest_tuple=('prime',(1,2,3,5,7))
从前面的教程中，我们已经熟悉了 Python 中的索引和切片方法。在元组中，索引和切片与列表的执行方式相同。我们可以使用索引和切片非常轻松地访问元组中的元素。
索引是为元组中的元素分配编号以便于访问的过程。索引始终从零开始，并且必须是整数。
Python 元组中有两种索引方式：
为了彻底理解索引，让我们看一个示例及其可视化。“T”是一个 Python 元组变量，包含元素“cat”、“cow”、“dog”和“rat”。元组中的每个元素都根据其在正向和负向索引中的位置分配了一个编号，如下所示。
T= ('Cat','Cow','Dog','Rat')
print('Element accessed at index 1 is:',T[1])
print('Element accessed at index 3 is:',T[3])
输出
Element accessed at index 1 is: Cow Element accessed at index 3 is: Rat
T= ('Cat','Cow','Dog','Rat')
print('Element accessed at index -2 is:',T[-2])
print('Element accessed at index -3 is:',T[-3])
输出
Element accessed at index -2 is: Dog Element accessed at index -3 is: Cow
Python 元组也支持范围切片运算符 [:]。在这里，使用切片运算符，我们可以根据需要从元组中切片子序列。简而言之，我们可以使用切片运算符创建子元组。范围切片的语法是
T [ m:n]
其中 T 是包含项目的元组
m：起始索引
n：结束索引
T[m:n] 返回从索引 m 到索引 n 的子元组，但不包括索引 n。
切片本身可以通过多种方式完成，使用正向和负向索引。切片可以通过将项目放在索引中间来最好地表示，如下所示。
[m:n] 的切片返回从位置 m 到 n 的子元组，但不包括索引 n。T= ('Cat','Cow','Dog','Rat','Bat')
print("T[1:4] =",T[1:4])
T[1:4] = ('Cow', 'Dog', 'Rat')
[:n] 的切片返回从默认起始位置到 n 的子元组，但不包括索引 n。T= ('Cat','Cow','Dog','Rat','Bat')
print("T[:4] =",T[:4])
T[:4] = ('Cat', 'Cow', 'Dog', 'Rat')
[m:] 的切片返回从位置 m 到最后一个索引的子元组。T= ('Cat','Cow','Dog','Rat','Bat')
print("T[2:] =",T[2:])
T[2:] = ('Dog', 'Rat', 'Bat')
T= ('Cat','Cow','Dog','Rat','Bat')
print("T[-4:-2] =",T[-4:-2])
输出
T[-4:-2] = ('Cow', 'Dog')
T= ('Cat','Cow','Dog','Rat','Bat')
print("T[:-2] =",T[:-2])
T[:-2] = ('Cat', 'Cow', 'Dog')
T= ('Cat','Cow','Dog','Rat','Bat')
print("T[-4:] =",T[-4:])
T[-4:] = ('Cow', 'Dog', 'Rat', 'Bat')
不可变性是 Python 编程语言中数据类型元组的独特特性之一。更具体地说，一旦创建了元组，就无法更改或修改其中的元素。这意味着无法向元组添加、替换或删除元素。如果我们尝试修改元组，我们将收到一个 TypeError 而不是输出。
NT=('prime',[1,2,3,5,7])
NT[0]='ODD'
print(NT)
输出
TypeError: 'tuple' object does not support item assignment
但是，当元组中的元素是可变的时，情况就不同了。例如，元组可以包含列表作为其元素。列表是可变的，因此该元素可以被修改。如果您想在列表中添加另一个素数，可以按下面的示例添加。输出将是一个带有另一个素数 11 的附加列表。
NT=('prime',[1,2,3,5,7])
NT[1].append(11)
print("Modified List in NT is :",NT)
输出
Modified List in NT is : ('prime', [1, 2, 3, 5, 7, 11])
考虑到元组是不可变的，无法删除或移除元组中的元素。但是，我们可以使用 del 关键字删除整个元组。如果我们尝试在删除后打印元组，将引发 NameError。
示例：如何删除元组
OT=(1,3,5,7,9)
del OT;
print(OT)
输出
print(OT) NameError: name 'OT' is not defined
字面上讲，Python 元组是不同或相同项目的有序集合。我们通常使用赋值运算符 = 将右侧的项目赋给左侧的变量。Python 提供了特殊功能，将赋值运算符提升到一个新的水平。
它们是
T=('One','Two','Three','Four')
print("T[0] = ",T[0])
print("T[2] = ",T[2])
输出
T[0] = One T[2] = Three
顾名思义，打包就是将一系列项目打包到一个变量中。将衣服装入袋子的现实生活示例与元组打包非常相似。打包可以如下所示。
解包恰恰相反，即分配给元组变量的每个项目都被解包到新的元组中。再次以现实生活为例，从袋子中解包衣服，每件衣服将放在指定的架子上。解包可以如下说明。
(n1,n2,n3,n4) = T
print("n1 contains :",n1)
print("n2 contains :",n2)
print("n3 contains :",n3)
print("n4 contains :",n4)
输出
n1 contains : One n2 contains : Two n3 contains : Three n4 contains : Four
Python 允许通过将打包和解包结合到一个语句中来实现复合赋值。格式如示例所示。
(n1,n2,n3,n4)= ('One','Two','Three','Four')
print("n2 contains :",n2)
print("n3 contains :",n3)
输出
n2 contains : Two n3 contains : Three
解包时需要考虑的一个重要问题是，左侧的变量对象数量必须等于元组中的值数量。如果数量不匹配，将输出 ValueError 而不是结果。
解包元组时发生 ValueError
(n1,n2,n3) = T
(n1,n2,n3,n4,n5) = ('One','Two','Three','Four')
输出
ValueError: too many values to unpack (expected 3) ValueError: not enough values to unpack (expected 5, got 4)
与列表一样，元组也可以嵌套，这意味着一个元组可以包含另一个元组作为其元素，而后者可能又包含另一个元组。我们可以通过在 () 括号内放置逗号分隔的元素来定义嵌套元组。
nest_tuple=('prime',(1,(2,(4,8)),3,5,7))
我们可以使用正向或负向索引从嵌套元组中访问元素。下面的示例为您提供了从嵌套元组中获取元素的思路。
nest_tuple=('prime',(1,(2,(4,8)),3,5,7))
#Positive indexing
print(nest_tuple[1])
print(nest_tuple[1][1])
print(nest_tuple[1][1][0])
#Negative indexing
print(nest_tuple[-1])
print(nest_tuple[-1][-4])
print(nest_tuple[-1][-4][-1])
输出
i = 10 f = 10.55 C = -5-6i
成员资格运算符用于验证元素或子元组是否存在于元组中。相应的输出将是一个布尔值，即 True 或 False。Python 中有两种成员资格运算符：
T =('prime',1,3,5,7)
print("Validation 3 in tuple is ",3 in T)
print("Validation 8 not in List is",8 not in T)
输出
Validation 3 in List is True Validation 8 not in List is True
Python 元组具有一些内置函数，用于执行一些常用的序列操作。基本函数如下表所示，以便于参考。
| 函数 | 描述 |
|---|---|
| len(tuple) | 返回元组的长度。 |
| max(tuple) | 返回元组中的最大值。 |
| min(tuple) | 返回元组中的最小值。 |
| compare(T1,T2) | 比较元组 T1 中的项与元组 t2 中的项 |
| list(seq) | 将列表转换为元组 |
我们已经学习了元组和列表。现在让我们总结一下 Python 元组和列表的重要相似点和区别。
