Python数据类型 ——— 元组

元组

元组（tuple）是一种有序且不可更改的集合，元组中允许存在重复的成员。

创建元组

创建空元组

在Python中，()表示一个空元组。比如：

a = ()
print(type(a))  # 
print(a)        # ()
1
2
3

此外，也可以通过tuple的方式来创建一个空元组。比如：

a = tuple()
print(type(a))  # 
print(a)        # ()
1
2
3

创建非空元组

创建元组时可以在()中设置元组的初始值。比如：

a = (1, 2, 3, 4, 5)
print(type(a))  # 
print(a)        # (1, 2, 3, 4, 5)
1
2
3

需要注意的是，元组中存放的元素可以是不同类型的。比如：

a = (1, 'hello', True, [4, 5, 6])
print(type(a))  # 
print(a)        # (1, 'hello', True, [4, 5, 6])
1
2
3

修改元组元素

元组的功能和列表基本是一致的，但元组是一个不可更改的集合，因此元组没有提供任何修改元组的方法。如果想要修改元组中的值，可以将元组转换成列表，更改列表后再将其转换回元组。比如：

a = (1, 2, 3, 4)
tmp = list(a)   # 将元组转换成列表
tmp[0] = 10     # 更改列表
a = tuple(tmp)  # 将列表转换回元组
print(a)        # (10, 2, 3, 4)
1
2
3
4
5

建议： 虽然这种方式可以对元组进行修改，但不建议这样做，如果一个序列中的元素是需要被修改的，最好就直接用列表进行存储。

查找元组元素

in和in not操作符

使用in和in not操作符能够判定某个元素是否在元组中存在。比如：

a = (1, 2, 3, 4)
print(1 in a)       # True
print(10 in a)      # False
print(1 not in a)   # False
print(10 not in a)  # True
1
2
3
4
5

index方法

使用index方法也可以判定某个元素是否在元组中存在。比如：

a = (1, 2, 3, 4)
print(a.index(3))  # 2
# print(a.index(10))  # 不存在,抛异常
1
2
3

注意： 使用index方法时，如果待查找元素在元组中，则返回该元素的下标，否则会抛异常。

下标访问元组元素

访问元组元素

通过下标访问操作符[]可以获取指定下标位置的元素。比如：

a = (1, 2, 3, 4)
print(a[2])  # 3
1
2

注意： 如果指定下标的值超过了元组中的最大下标，则会抛出异常。

负索引

下标访问操作符[]中指定的下标可以取负数，我们称之为负索引，负索引其实就是从元组的最后一个元素开始往前，依次为-1、-2、-3、…。比如：

因此如果想要访问元组的最后一个元素，直接访问下标为-1的元素即可。比如：

a = (1, 2, 3, 4)
print(a[-1])  # 4
1
2

遍历元组元素

for循环遍历

以for循环的方式遍历元组时，可以直接将元组作为可迭代对象进行遍历，也可以对元组中元素的下标进行遍历，然后通过下标访问操作符[]来依次访问每个元素。比如：

a = (1, 2, 3, 4)
# 方式一
for elem in a:
    print(elem)

# 方式二
for i in range(len(a)):
    print(a[i])
1
2
3
4
5
6
7
8

说明一下： 通过len函数能够获取到元组中的元素个数。

while循环遍历

也可以以while循环的方式对元组中元素的下标进行遍历，然后通过下标访问操作符[]来依次访问每个元素。比如：

a = (1, 2, 3, 4)
i = 0
while i < len(a):
    print(a[i])
    i += 1
1
2
3
4
5

子元组提取

[起始下标 : 结束下标]

以[起始下标 : 结束下标]的方式可以从元组中提取出，从起始下标开始到结束下标的一组元素。比如：

a = (1, 2, 3, 4)
print(a[1:3])  # (2, 3)
1
2

注意： 提取出的子元组中包含起始下标的元素，但不包括结束下标的元素（前闭后开）。

切片时省略边界

提取子元组的过程也叫做切片的过程，以[起始下标 : 结束下标]的方式切片时可以省略起始下标或结束下标。

• 如果以[起始下标 : ]的方式进行切片，则子元组中的元素包括起始下标的元素及其后续元素。
• 如果以[ : 结束下标]的方式进行切片，则子元组中的元素包括结束下标之前的所有元素。
• 如果以[ : ]的方式进行切片，则子元组中的元素包括原元组中的所有元素。

切片示例：

a = (1, 2, 3, 4)
print(a[1:])   # (2, 3, 4)
print(a[:2])   # (1, 2)
print(a[:-1])  # (1, 2, 3)
print(a[::])   # (1, 2, 3, 4)
1
2
3
4
5

注意： 切片时也可以使用负索引。

切片时指定步长

以[起始下标 : 结束下标 : 步长]的方式切片可以指定步长，即每访问一个元素后下标自增几步。比如：

a = (1, 2, 3, 4, 5, 6, 7, 8, 9, 0)
print(a[::1])     # (1, 2, 3, 4, 5, 6, 7, 8, 9, 0)
print(a[::2])     # (1, 3, 5, 7, 9)
print(a[::3])     # (1, 4, 7, 0)
print(a[1:-1:2])  # (2, 4, 6, 8)
1
2
3
4
5

此外，切片时指定的步长也可以为负数，这时表示从后往前提取元素。比如：

a = (1, 2, 3, 4, 5, 6, 7, 8, 9, 0)
print(a[::-1])  # (0, 9, 8, 7, 6, 5, 4, 3, 2, 1)
print(a[::-2])  # (0, 8, 6, 4, 2)
1
2
3

切片时下标越界问题

如果切片时填写的下标超出了有效范围，运行程序后不会抛异常，而是尽可能把符合要求的元素提取出来。比如：

a = (1, 2, 3, 4, 5, 6, 7, 8, 9, 0)
print(a[1:100])  # (2, 3, 4, 5, 6, 7, 8, 9, 0)
1
2

拼接元组

使用+拼接元组

使用+可以把两个元组拼接在一起。比如：

a = (1, 2, 3)
b = (4, 5, 6)
c = a + b
print(a)  # (1, 2, 3)
print(b)  # (4, 5, 6)
print(c)  # (1, 2, 3, 4, 5, 6)
1
2
3
4
5
6

注意： 使用+拼接后会生成一个新的元组，该操作不会影响两个原有的元组。

使用+=拼接元组

使用+=可以把一个元组拼接到另一个元组的后面。比如：

a = (1, 2, 3)
b = (4, 5, 6)
a += b
print(a)  # (1, 2, 3, 4, 5, 6)
print(b)  # (4, 5, 6)
1
2
3
4
5

说明一下：

• 因为元组是一个不可更改的集合，因此元组没有提供extend方法将一个元组拼接到另一个元组后面。
• a += b等价于a = a + b，拼接过程中会先构造出拼接后的元组，然后将a原来的元组释放，再将拼接后的元组赋值给a，该过程并没有修改a原来管理的元组。

元组常用接口汇总

元组操作：

元组的成员函数：