『无为则无心』Python序列 — 20、Python元组的介绍与使用

时间:2022-04-05 23:25:02

元组是一个不可变的序列。

元组的操作的方式基本上和列表是一致的,所以你在操作元组时,就把元组当成是一个不可变的列表就OK了。

一般情况下,当我们希望数据不改变时,就使用元组,其余情况都使用列表。

1、元组的应用场景

思考:如果想要存储多个数据,但是这些数据是不能修改的数据,怎么做?

答:列表可以一次性存储多个数据,但是列表中的数据允许更改。

# 结果:[100, 20, 30]
num_list = [10, 20, 30]
num_list[0] = 100
print(num_list)

这个时候,我们就可以定义一个元祖,一个元组可以存储多个数据,元组内的数据是不能修改的。

2、定义元组

元组特点:定义元组使用小括号,且用逗号隔开各个数据,数据可以是不同的数据类型。

示例

# 1. 定义多个元素元组
t1 = (10, 20, 30)
print(type(t1)) # <class 'tuple'> # 2. 定义单个元素的元组
# 如果元组不是空元组,它里边至少要有一个逗号
t2 = (10,)
print(type(t2)) # 3. 如果单个数据的元组不加逗号
t3 = (10)
print(type(t3)) # <class 'int'> t4 = ('aaa')
print(type(t4)) # <class 'str'> t5 = ('aaa',)
print(type(t5)) # <class 'tuple'> # 4.当元组不是空元组时,括号可以省略(封包)
my_tuple = 10,20,30,40
print(type(my_tuple)) # <class 'tuple'>
my_tuple1 = 40,
print(type(my_tuple1)) # <class 'tuple'>

注意:如果定义的元组只有一个数据,那么这个数据后面也要添加逗号,否则该数据类型为对应的基本类型数据。

3、元组的常见操作

元组是不可变对象,所以不能尝试为元组中的元素重新赋值(修改、删除),只支持查找,具体如下:

@1、按下标查找数据

tuple1 = ('aa', 'bb', 'cc', 'bb')
print(tuple1[0]) # aa # 如果下标越界会报异常
# IndexError: tuple index out of range
tuple1 = ('aa', 'bb', 'cc', 'bb')
print(tuple1[7])

@2、index()方法

index()方法:查找某个数据,如果数据存在返回对应的下标,否则报错。

语法和列表、字符串的index()方法相同。

tuple1 = ('aa', 'bb', 'cc', 'bb')
print(tuple1.index('aa')) # 0 # ValueError: tuple.index(x): x not in tuple
print(tuple1.index('aaa'))

@3、count()方法

count()方法:统计某个元素在当前元组出现的次数。没有出现结果就是0。

tuple1 = ('aa', 'bb', 'cc', 'bb')
print(tuple1.count('bb')) # 2
print(tuple1.count('bbb')) # 0

@4、len()方法

len():统计元组中元素的个数。

tuple1 = ('aa', 'bb', 'cc', 'bb')
print(len(tuple1)) # 4

4、元祖中的列表元素

注意:元组内的直接数据如果修改则立即报错

# TypeError: 'tuple' object does not support item assignment
tuple1 = ('aa', 'bb', 'cc', 'bb')
tuple1[0] = 'aaa'

但是如果元组里面有列表,则列表里面的元素是支持修改的,这点要记住。

# 结果:['aa', 'bb', 'cc']
tuple2 = (10, 20, ['aa', 'bb', 'cc'], 50, 30)
print(tuple2[2]) # 访问到列表 # 结果:(10, 20, ['孙悟空', 'bb', 'cc'], 50, 30)
tuple2[2][0] = '孙悟空'
print(tuple2)

5、扩展:序列封包和序列解包

  • 序列封包:程序把多个值赋给一个变量时,Python会自动将多个值封装成元组,这种功能叫做序列封包。
  • 程序允许将序列(字符串、元组、列表等)直接赋值给多个变量,此时序列的各元素会被依次赋值给每个变量(要求序列的元素个数和变量个数相等),这种功能叫做序列解包。

(1)示例说明

# 1.元组封包
# 多个值赋给一个变量,将多个值封装成元组
my_tuple = 10,20,30,40
print(type(my_tuple)) # <class 'tuple'>
print(my_tuple) # (10, 20, 30, 40) # 2.元组解包
# 解包指就是将元组当中每一个元素都赋值给一个变量
my_tuple = (10, 20, 30, 40)
a, b, c, d = my_tuple
print("a = ", a)
print("b = ", b)
print("c = ", c)
print("d = ", d)
"""
输出结果:
a = 10
b = 20
c = 30
d = 40
""" # 3.序列的元素个数和变量个数相等,否则会报错
# 结果:ValueError: too many values to unpack (expected 3)
my_tuple = 10, 20, 30, 40
a, b, c = my_tuple

(2)应用扩展

# 1.如果元组中有100个元素,我想取前两个。
# 可以在变量前边添加一个*,这样变量将会获取元组中所有剩余的元素
my_tuple = (10, 20, 30, 40)
a, b, *c = my_tuple
print("a = ", a)
print("b = ", b)
print("c = ", c)
"""
输出结果:
a = 10
b = 20
c = [30, 40]
""" # 2.*给任何一个变量都可以
my_tuple = (10, 20, 30, 40)
a, *b, c = my_tuple
print("a = ", a)
print("b = ", b)
print("c = ", c)
"""
输出结果:
a = 10
b = [20, 30]
c = 40
""" # 3.不能同时出现两个或以上的*变量,否则会报错
# 结果:SyntaxError: two starred expressions in assignment
my_tuple = (10, 20, 30, 40)
a, *b, *c = my_tuple # 4.同理字符串和列表都支持序列的解包。
a , b , *c = [1,2,3,4,5,6,7]
a , b , *c = 'hello world' # 5.字典拆包
dict1 = {'name': 'TOM', 'age': 18}
a, b = dict1 # 对字典进行拆包,取出来的是字典的key
print(a) # name
print(b) # age # 通过上面的拆包得到了字典中的key名,
# 在通过key名就可以取到字典中key所对应的value值了。
print(dict1[a]) # TOM
print(dict1[b]) # 18

(3)数值交互应用

需求:有变量`a = 10`和`b = 20`,交换两个变量的值。

# 1. 方法一
"""
1.1 定义中间的第三变量,为了临时存储a或b的数据
1.2 把a的数据存储到c,做保存
1.3 把b的数据赋值到a, a = 20
1.4 把c的数据赋值到b, b = 10
"""
a = 10
b = 20 # 交互
c = 0
c = a
a = b
b = c print("a =", a) # a = 20
print("b =", b) # b = 10 # 2.应用序列的组包,拆包
"""
两个变量互换值,如交互a和b的值
等号右边b,a就是一个元祖的定义。(组包)
等号左边的两个变量接收元组中的元素。(拆包) 输出结果:
a = 20
b = 10
""" a, b = b, a
print("a =", a)
print("b =", b)