一、什么是元组

  元组（tuple）是 Python 中的一种序列结构，和列表类似，也是由一系列按特定顺序排列的元素组成，但它是不可变序列。因此，元组也可以称为不可变的列表。在形式上，元素的所有元素都放在一对“()”中，两个相邻元素间使用“,”分隔。在内容上，可以将整数、实数、字符串、列表、元组等任何类型的内容放在元组中，并且在同一个元素中，元素的类型可以不同。

从元素和列表的定义上看，这两种结构比较相似，两者之间的主要区别为：元组是不可变序列，列表是可变序列。即元组的元素不可以单独修改，而列表可以任意修改。

二、元组的创建、删除和访问

2.1、元组的创建

【1】、使用 () 创建列表

  我们可以通过 () 来创建元组，同其它类型的 Python 变量一样，创建列表时，也可以使用赋值运算符“=”直接将一个元组赋值给变量，语法格式如下：

tuplename = (element1,element2,...)

  我们可以通过 () 来创建一个空元组：

names = ()
print(names)
print(type(names))

  在 Python 中，元组使用一对小括号将所有的内容括起来，但是小括号并不是必须的，只要将一组值用逗号分隔来，Python 就可以视其为元组。

names = ("Sakura","Mikoto","Shana")
print(names)
print(type(names))names = "Kikyō","Kagome","Moroha"
print(names)
print(type(names))

  如果要创建一个的元组只包含一个元素，则需要在定义元素时，在元素后面加一个逗号“,”。

names = "Sakura",
print(names)
print(type(names))names = ("Mikoto",)
print(names)
print(type(names))

创建元组的语法与创建列表的语法类似，只是创建列表时使用的是“[]”，而创建元组时使用的是“()”

【2】、使用 tuple() 方法创建元组

  在 Python 中，可以使用 tuple() 函数直接将可迭代对象转换为元组。

tuplename = tuple(data)

  其中，data 标识可以转换为列表的数据，其类型可以是 range 对象、字符串、元组 或者 其它 可迭代 类型的数据。

num = tuple(range(1,11))
print(num)
print(type(num))

2.2、元组的删除

  对于已经创建好的元组，不再使用时，可以使用 del 语句将其删除，语法格式如下：

del tuplename

  在删除元组前，一定要保证的输入的元组对象是已经存在的，否则会出现以下错误：

NameError: name 'names' is not defined

2.3、访问元组元素

  元组中的对象都会按照插入的顺序存储到元组中，第一个插入的对象保存到第一个位置，第二个保存在第二个位置。我们也可以通过 索引 的方式获取指定的元素。索引 是元素在元组中的位置，元组中的每一个元素都有一个索引。索引是 0 开始的整数，元组第一个位置索引为 0，第二个位置索引为 1，依次类推。它的语法格式如下：

tuplename[index]

names = ("Sakura","Mikoto","Shana")
print(names[0])
print(names[1])
print(names[2])

  如果使用的索引超过最大的索引会报以下错误：

IndexError: tuple index out of range

  在 Python 中索引可以是 负数。这个索引从右向左计数，也就是从最后的一个元素开始计数，即最后一个元素的索引是 -1，倒数第二个第二个元素的索引值为 -2，以此类推。

names = ("Sakura","Mikoto","Shana")
print(names[-1])
print(names[-2])
print(names[-3])

在采用负数做索引时，是从 -1 开始的，而不是从 0 开始的，即最后一个元素的下标为 -1，这是为了防止与第一个元素重合。

2.4、遍历元组

  遍历元组，指的就是将元组中的所有元素取出来，我们可以使用 for 循环直接遍历元组。for 循环的代码块会执行多次，序列中有几个元素就会执行几次，每执行依次就会将序列中的一个元素赋值给变量。

for item in tuplename:# 遍历元组操作

names = ("Sakura","Mikoto","Shana","Kikyō","Kagome","Moroha")
for name in names:print(name)

  我们还可以使用 while 循环来遍历元组。

names = ("Sakura","Mikoto","Shana","Kikyō","Kagome","Moroha")
i = 0
while i < len(names):print(names[i])i += 1

三、元组元素的查找

  在 Python 中，我们还可以使用 in 关键字检查某个元素是否为元组的成员，即检查某个元素是否包含在某个元组中。如果存在，返回 True，否则返回 False。

element in tuplename

names = ("Sakura","Mikoto","Shana","Kikyō","Kagome","Moroha")
result = "Sakura" in names
print(result)

  另外，在 Python 中，我们还可以使用 not in 关键字实现检查某个元素是否不包含在指定的元组中。如果不在，返回 True，否则返回 False。

element not in tuplename

names = ("Sakura","Mikoto","Shana","Kikyō","Kagome","Moroha")
result = "Sakura" not in names
print(result)

四、元组切片

  切片是从现有的元组中，获取一个新的元组，不会影响原有的元组。实现切片的语法格式如下：

tuplename[start : end : step]

  通过切片获取元素时，会包括起始位置的元素，不会包括结束位置的元素。如果不指定起始位置，默认从 0 开始，如果不指定截至位置，默认为元组的长度。

  在进行切片操作时，如果指定了步长，那么将会按照步长遍历元组的元素，否则，将一个一个遍历元组。如果省略步长，默认为 1，最后的一个冒号也可以省略。

names = ("Sakura","Mikoto","Shana","Kikyō","Kagome","Moroha")
name = names[1:5:2]
print(names)
print(name)# 如果省略步长，则默认步长为1
name = names[1:5]
print(name)# 如果省略截至位置，会一直截取到最后
name = names[1:]
print(name)# 如果省略开始位置，则会从第一个元素开始截取
name = names[:5]
print(name)

  如果想复制整个元组，可以将 起始位置 和 截至位置 都省略，但是中间的冒号要保留。

names = ("Sakura","Mikoto","Shana","Kikyō","Kagome","Moroha")
# 如果省略开始位置和截至位置，会复制一个元组
name = names[:]
print(names)
print(name)

  步长不能为 0， 但是可以为负数，如果是负数，将从元组的后部向前取元素。

names = ("Sakura","Mitoto","Shana","Kikyō","Kagome","Moroha")
# 步长如果是负数，则会从元组的后部向前面取元素
name = names[::-1]
print(names)
print(name)

五、元组的常用操作

【1】、元组相加

  在 Python 中，支持元组进行相加操作，即将两个元组进行拼接，不会去除重复的元素，使用加（+）运算符实现。语法格式如下：

names1 = ("Sakura","Mikoto","Shana","Kikyō","Kagome","Moroha")
names2 = ("Akame","Kurome","Sakura")
names = names1 + names2
print(names)

【2】、元组乘法

  在 Python 中，使用数字 n 乘以一个元组会生成一个新的元组。新元组的内容为原来元组被重复 n 次的结果。

names1 = ("Sakura","Mikoto","Shana","Kikyō","Kagome","Moroha")
names2 = names1 * 3
print(names2)

在 Python 中，提供了内置函数计算元组的长度、最大值和最小值分别是：```python
len(s)		                        # 获取元组的长度
min(iterable, *, key=None)		# 返回元组中的最小元素
max(iterable, *, key=None)		# 返回元组中的最大元素

num = (12,43,121,34,64,322,46)
print("元组的长度为：", len(num))
print("元组中的最小元素为：", min(num))
print("元组中的最大元素为：", max(num))

【4】、获取指定元素出现的个数

  使用元组对象的 count() 方法可以获取指定元素在元组中出现的个数。这里只能进行精确的匹配，即不能是元素值的一部分。count() 方法的返回值就是元素在元组中出现的次数。它的语法格式如下：

tuplename.count(x)

names = ("Sakura","Mikoto","Shana","Kikyō","Kagome","Moroha","Mikoto","Sakura")
print(names.count("Sakura"))

【5】、获取指定元素首次出现的下标

  使用元组对象的 index() 方法可以获取指定元素在元组中出现的位置（即索引）。基本语法格式如下：

tuplename.index(x[, start[, stop]])

names = ("Sakura","Mikoto","Shana","Kikyō","Sakura","Kagome","Moroha","Mikoto","Sakura")# 获取指定元素在元组中第一次出现的索引
print(names.index("Sakura"))# index()的第二个参数表示查找的起始位置
print(names.index("Sakura",5))# index()的第三个参数表示查找的结束位置
print(names.index("Sakura",3,5))

  如果获取元组中没有的元素或抛出如下异常：

ValueError: tuple.index(x): x not in tuple

六、元组解包

  解包（解构）就是将元组当中每一个元素都赋值给一个变量。

names = ("Sakura","Mikoto","Shana")
name1,name2,name3 = names
print(name1)
print(name2)
print(name3)

  我们还可以利用元组解包的特性，来实现两个变量的交换。

a = 10
b = 20
print("a = ",a)
print("b = ",b)# 利用元组的解包，交换两个变量的值
a,b = b,a
print("a = ",a)
print("b = ",b)

  在对一个元组进行解包时，变量的数量必须和元组中的元素数量一致，也可以在变量的前面添加一个 * 号，这样变量将会获取元组中剩余的元素。

names = ("Sakura","Mikoto","Shana","Kikyō","Kagome","Moroha")name1,name2,*name3 = names
print(name1)
print(name2)
print(name3)
print(type(name3))

不能同时出现两个或以上的 * 变量；

七、生成器表达式

  使用生成器表达式可以快速生成一个元组，它的表现形式和列表推导式类似，只是将列表推导式中的方括号 “[]” 修改为圆括号 “()”。

tuplename = (表达式 for 变量 in 可迭代对象 if 条件)

num = (value**2 for value in range(1,11))
print(num)
print(type(num))

  从上面的执行结果可以看出，使用生成器表达式生成的结果并不是一个元组或列表，而是一个生成器对象。这一点和列表推导式是不同的，这时需要我们可以把该生成器对象转换为元组或列表。其中，转换为元组需要使用 tuple() 函数，而转换为列表需要使用 list() 函数。

num = (value**2 for value in range(1,11))
num_list = list(num)
print(num_list)
print(type(num_list))

num = (value for value in range(1,11) if value % 2 == 0)
num_tuple = tuple(num)
print(num_tuple)
print(type(num_tuple))

八、列表与元组的区别

列表	元组
列表属于可变序列，它的元素可以随时修改或删除	元组属于不可变序列，其中的元素对应的内存地址不可以改变
列表可以使用 append()、extend()、insert()、remote()、pop() 等方法修改列表元素	元组没有这些方法
列表可以通过使用切片访问和修改列表中的元素	元组只支持通过切片访问元素，不支持修改
列表的访问和处理速度较慢	元组的访问和处理速度较快
列表不能作为字典的键	元组可以作为字典的键

persons = (["Sakura",10],["Mikoto",14])
print(persons)
print("id(persons[0]): ", id(persons[0]))
print("id(persons[1]): ", id(persons[1]))
print()persons[0][1] = 12
print(persons)
print("id(persons[0]): ", id(persons[0]))
print("id(persons[1]): ", id(persons[1]))