0%

Python学习笔记 - tuple 元组

元组和列表的区别

  1. 元组一经创建无法修改(也称元组为只读列表)
  2. 元组可哈希
  3. 元组创建时应该注意如果只有一个元素需要在末尾加上一个 ,

创建元组

在 python 中,() 代表了元组,其中的元素以逗号分隔,里面可以加入任意的数据类型,但要注意当元组中只有一个元素的时候末尾需要加上一个 ,

1
2
3
4
5
6
a = () # 创建空元组
a = (1,) # 创建只有一个元素的元组时,元素后面需要加逗号
a = (1, 2, '3') # 创建有多个元素的元组,元组内的元素数据类型可以不同
a = (1, 2, (3, '4')) # 元组可以嵌套
a = (1, 2, [3, '4']) # 元组可以嵌套列表
a = tuple([1, 2, 3) # 可以将列表转换为元组

获取元素(与列表相同)

1
2
m = a[0] # 可以直接通过索引获得元组的元素,元组索引以 0 开始
m = a[1:2] # 元组的切片,返回值为一个新元组

元组的索引(与列表相同)

  1. 元组索引以 0 开始,以元组长度减一为截止。
  2. 元组索引为负数代表元组从后数,-x 的意思是从后数 x 个元素,例如 -1 代表了元组的最后一个元素

元组的切片(与列表相同)

  1. 切片的使用形式是元组元素后跟 [a:b][a:b:s],其返回值是一个新元组
  2. 元组切片元素的 ab 代表了元素索引,s 代表了步长值
  3. 元组切片,会返回索引 a 到索引 b 中间的内容(包括索引 a 对应的内容而不包括索引 b 对应的内容)组成的新元组,其中新元组的每两个相邻元素的索引差值是步长值
  4. 未提供索引 a 则默认为 0,未提供索引 b 则默认为元组长度(即 最后一个元素索引 + 1),未提供步长值 s 则默认为 1
  5. 省略元素时应注意至少有一个 : 存在才会被认为是切片;且只有一个 : 时会认为是 a:b 形式而非其他样式
  6. 步长值为负数时意味着新元组产生方向为从右到左
1
2
3
4
5
6
7
8
9
10
11
12
a = (1, 2, 3, 4, 5, 6, 7, 8, 9)
x = a[4:] # x = (5, 6, 7, 8, 9)
x = a[:3] # x = (1, 2, 3)
x = a[:] # x = (1, 2, 3, 4, 5, 6, 7, 8, 9)
x = a[2:7] # x = (3, 4, 5, 6, 7)
x = a[2:7:2] # x = (3, 5, 7)
x = a[-5:] # x = (5, 6, 7, 8, 9)
x = a[:-3] # x = (1, 2, 3, 4, 5, 6)
x = a[::-1] # x = (9, 8, 7, 6, 5, 4, 3, 2, 1)
x = a[5:1] # x = () 默认的元组产生方式为从左到右,元组索引 a 在 b 之后会返回空元组
x = a[5:1:-1] # x = (6, 5, 4, 3)
x = a[-1:-5] # x = () 新元组的产生方式只与步长值的正负有关而与索引的查询方式无关

关于元素的索引的操作(与列表相同)

1
2
3
4
a = (1, 1, 3, 4, 5, 5, 6)
i = a.index(5) # i = 4,返回第一个值为 5 的元素的索引
n = a.count(5) # n = 2,返回值为 5 的元素的个数
n = len(a) # n = 6,返回元组的元素数量

查询元素是否在元组中(与列表相同)

1
2
1 in a # 若 1 在元组 a 中返回 True,否则返回 False
1 not in a # 若 1 不在元组 a 中返回 True,否则返回 False

Todo: 返回元组全部元素的索引

添加元素

  1. 元组本身是无法修改的,所谓的「添加元素」实质是构造了一个新元组然后替换掉了之前的
  2. 需要更加高级的操作请使用列表(也可以通过 list() 先转换为列表再通过 tuple() 转换回元组)
1
2
3
a += (1, 2, 3) # 在元组末尾添加一个新元组(直接合并元素)(元组可以相加,结果为一个新元组)
a = (1, 2, 3)
a *= 2 # a = (1, 2, 3, 1, 2, 3),将元组元素复制两份

删除元素

元组元素是无法删除的,只能将元组所有元素删除(本质是赋予了一个新的元组),需要更加高级的操作请使用列表(也可以通过 list() 先转换为列表再通过 tuple() 转换回元组)

1
2
a = () # 删除元组全部元素
del a # 取消了此元组的定义

修改元素

元组元素是无法修改的,需要修改请使用列表(也可以通过 list() 先转换为列表再通过 tuple() 转换回元组)

1
2
a = (1, 2, 3)
b = tuple(reversed(a)) # a = (1, 2, 3), b = (3, 2, 1),返回 a 反向后的元组而保持 a 不变

元组的遍历(与列表相同)

  1. 可以通过简单的 for 循环来实现遍历
  2. 可以通过先获取元素数量再循环这个次数来实现遍历
  3. 可以通过 enumerate() 函数来同时遍历元素和其对应的下标,此函数返回一个类似拥有两个元素的元组的类,此类的每一项都是拥有两个元素的元组,第一个元素为索引,第二个元素为此索引对应的对象。(提示:第一个元素实际上并不是索引,而是简单的一个数,此数的起始值可以通过在第二个参数传入起始值而改变)
1
2
3
4
5
6
7
8
9
10
a = (1, 2, 3, 4)
for (i, x) in enumerate(a):
print(i, x)
'''
输出结果为:
0 1
1 2
2 3
3 4
'''
1
2
3
4
5
6
7
8
9
10
a = (1, 2, 3, 4)
for (i, x) in enumerate(a, 2):
print(i, x)
'''
输出结果为:
2 1
3 2
4 3
5 4
'''

应该注意,若再循环中同时需要元素和其下标应避免使用 .index() 方法而选择上面的 2 或 3 所给出的方法,因为 .index() 方法在遇到相同元素时只会返回元素的第一个下标

1
2
3
4
5
6
7
8
9
10
a = (1, 1, 2, 3)
for x in a:
print(a.index(x), x)
'''
输出结果为:
0 1
0 1
2 2
3 3
'''

其他元组函数、方法(与列表相同)

1
2
3
4
a = (1, 2, 3, 4, 5, 5, 7, 8, 9)
max(a) # 返回元组 a 中最大的元素(只能同类元素比较)
min(a) # 返回元组 a 中最大的元素(只能同类元素比较)
type(a) is tuple# True,判断 a 是不是元组

欢迎关注我的其它发布渠道