什么是元组

元组： 用来存放一组有序的数据，但其中的内容一旦创建就不可修改，不能增、删、改，只能查。

由于元组不可变，所以元组不能使用 append()、insert() 这些方法，它里面的元素也不能被重新赋值。

定义元组

语法格式：使用圆括号()来定义一个元组，用,分隔不同的元素。

# 定义有内容的元组
t1 = (28, 67, 21, 67, 11)
t2 = ('太原', '远方', '你好')
t3 = (100, True, '你好', None)
t4 = (100, True, '你好', None, (500, 600, 800))
print(type(t1), t1) # <class 'tuple'> (28, 67, 21, 67, 11)
print(type(t2), t2) # <class 'tuple'> ('太原', '远方', '你好')
print(type(t3), t3) # <class 'tuple'> (100, True, '你好', None)
print(type(t4), t4) # <class 'tuple'> (100, True, '你好', None, (500, 600, 800))

# 定义空元组
t10 = ()
t11 = tuple()
print(type(t10), t10) # <class 'tuple'> ()
print(type(t11), t11) # <class 'tuple'> ()

注意：当元组中只有一个元素时，末尾必须写上,。下面示例代码定义只有一个元素的元组：

t20 = ('你好')
print(type(t20), t20) # <class 'str'> 你好

t21 = ('你好',)
print(type(t21), t21) # <class 'tuple'> ('你好',)

实际开发中，元组不一定是我们自己定义的，比如函数的可变参数*args就是一个元组。

def test(*args):
    print('args', args, type(args))
    return sum(args)

result = test(1, 2, 3)
print(result)

读取数据

与列表一样，元组也支持下标，所以使用元组名[索引值]的方式来读取值。

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

元组不可修改

元组中的元素不可修改，但元组中如果存放了可变类型（如：列表），那可变类型中的内容仍可修改。

# 元组中的元素不可修改
t1 = (1, 2, 3)
t1[1] = 20 # 此行报错信息：TypeError: 'tuple' object does not support item assignment

# 元组中如果存放了可变类型（列表），那可变类型中的内容仍可修改
t2 = (28, 67, 21, 67, 11, [100, 200, 300, ['你好', '远方']])
print(t2[5]) # [100, 200, 300, ['你好', '远方']]
t2[5][2] = 3000
t2[5][3][0] = 'hello'
print(t2) # (28, 67, 21, 67, 11, [100, 200, 3000, ['hello', '远方']])

元组的常用方法

由于元组不可修改，所以它的常用方法只有两个：index() 和 count()。

使用元组名.index(元素)，获取指定元素在元组中第一次出现的下标（索引值）。

t1 = (28, 67, 21, 67, 11)
result = t1.index(67)
print(result) # 1

使用元组名.count(元素)，获取指定元素在元组中出现的次数。

t1 = (28, 67, 21, 67, 11)
result = t1.count(67)
print(result) # 2

元组的常用内置函数

元组的常用内置函数和列表一样，还是下面这几个：

需知：上面列表中的内置函数，不仅只用于列表，而且适用于：所有数据容器。

sorted 函数对元组进行排序（不修改原元组，返回一个新的“列表”）

t1 = (23, 11, 32, 30, 17)
print(sorted(t1)) # [11, 17, 23, 30, 32]
print(sorted(t1, reverse=True)) # [32, 30, 23, 17, 11]
print(t1) # (23, 11, 32, 30, 17)

len 函数返回元组中元素的个数（元组长度）

len(数据容器)，获取容器中元素的总数量，返回值：元素的总数量。

t1 = (23, 11, 32, 30, 17)
result = len(t1)
print(result) # 5

max 函数返回元组中的最大值

t1 = (23, 11, 32, 30, 17)
result = max(t1)
print(result) # 32

min 函数返回元组中的最小值

t1 = (23, 11, 32, 30, 17)
result = min(t1)
print(result) # 11

sum 函数统计元组中所有元素的和（元素必须是纯数字）

t1 = (23, 11, 32, 30, 17)
result = sum(t1)
print(result) # 113

元组的循环遍历

元组的遍历与列表一样，可以使用while或for循环遍历。

使用 while 循环遍历元组

t1 = (23, 11, 32, 30, 17)

index = 0
while index < len(t1):
    print(t1[index])
    index += 1

使用 for 循环遍历元组

t1 = (23, 11, 32, 30, 17)

for item in t1:
    print(item)

解包列表或元组传参

解包列表、解包元组传参，就是把其中的元素依次取出，作为多个独立的参数传入函数。

定义函数时，使用 args （变量不一定非要用 args ，比如：data 也行），将接收到的多个参数，打包成一个元组。

def test(*params):
    print(params, type(params))

list = [1, 2, 3]
tuple = (10, 20, 30)

# 函数调用时，正常传递：列表 或 元组
test(list) # ([1, 2, 3],) <class 'tuple'>
test(tuple) # ((10, 20, 30),) <class 'tuple'>
test('a', 'b', 'c') # ('a', 'b', 'c') <class 'tuple'>

# 函数调用时，使用*对 列表 或 元组进行解包后，再传递参数
test(*list) # 此种写法相当于：test(1, 2 ,3)，运行结果：(1, 2, 3) <class 'tuple'>
test(*tuple) # 此种写法相当于：test('a', 'b', 'c')，运行结果：(10, 20, 30) <class 'tuple'>

元组的特点总结

• 可存放不同类型的元素。
• 元素是有序存储的（正索引、负索引）。
• 元组中的元素允许重复。
• 元组中的元素不允许修改（不能：增、删、改，只能：查）。
• 长度固定（一旦创建，元素个数不能增减）。

总结：元组是一种“只读”的数据容器，想保存一批“不会变的数据”时，首选元组。

元组 VS 列表

注意：元组不是用来替代列表的，而是用来在数据不需要改变的情况下，作为列表的补充的选择。