Python快速入门学习笔记七:数据容器 之 元组

❝

Python入门第七课，主要学习最重要的数据容器——元组，元组是Python中不可变的有序序列，一旦创建不能修改，用于保护数据安全和作为字典的键，使数据存储更高效可靠。

• 什么是元组
• 定义元组
• 读取数据
• 元组不可修改
• 元组的常用方法
• 元组的常用内置函数
• 元组的循环遍历
• 解包列表或元组传参
• 元组的特点总结
• 元组 VS 列表

什么是元组

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

❝

由于元组不可变，所以元组不能使用 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就是一个元组。

deftest(*args):    print('args', args, type(args))return sum(args)result = test(1, 2, 3)print(result)

读取数据

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

t1 = (1, 2, 3)print(t1[1]) # 2print(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] = 3000t2[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 = 0while index < len(t1):    print(t1[index])    index += 1

使用 for 循环遍历元组

t1 = (23, 11, 32, 30, 17)for item in t1:    print(item)

解包列表或元组传参

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

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

deftest(*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 列表

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