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

元组的操作的方式基本上和列表是一致的，所以你在操作元组时，就把元组当成是一个不可变的列表就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)