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

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