【Python基础013】元组的用法

1、定义

        元组（tuple）是不可变的有序集合，和列表一样，也是一种序列。不同的是元组不能修改，也就是说，元组是只读的，不能对元组进行增加、删除、修改。定义元组非常简单，只需要用逗号(，)分隔值即可。

2、创建

        （1）使用()创建，括号可省略

a = 3, 4, 5, 6 # (3, 4, 5, 6)

b = (3, 4, 5, 6) # (3, 4, 5, 6)

c = (3, ) # (3, ) 当创建只含一个元素的元祖时，需要在元素后加上一个逗号，如果不加逗号，则会返回一个int类型

        （2）使用tuple()创建

        使用tuple()创建一个元组时，只能传递一个参数，这个参数可以是字符，列表，元组等等        

# 传递 字符串，注意只能传递一个参数，也就是说这里如果传递多个字符串会报错，必须用方括号或者括号包含起来

a = tuple('abs')

# 传递 序列

b = tuple(range(4))

# 传递 元祖

c = tuple((3, 4, 5, 6))

# 传递 列表

c = tuple([3, 4, 5, 6])

3、基本操作

        （1）不能修改

a = (1, 3, 2, 5, 10)

a[2] = 2

Traceback (most recent call last):

File "", line 1, in

TypeError: 'tuple' object does not support item assignment

        （2）添加

        最开始已经说了元组是不可变的有序集合，一旦创建就无法对其进行修改。因此，元组没有列表的append()、insert()方法来向元组中添加元素，但是方法总比问题多，我们仍然可以通过其他方法来向元组添加元素。

        1）使用加法运算

        可以使用加法运算符将两个元组相加，从而创建一个新的元组，其中包含了原来的元组以及需要添加的元素。

tuple1 = (1, 2, 3, 5, 7, 10)

element = 4

tuple2 = (6, 8, 9, 21)

new_tuple1 = tuple1 + (element,) # (1, 2, 3, 5, 7, 10, 4) 在添加一个元素时，逗号与小括号必须同时存在

new_tuple2 = tuple1[:2] + tuple2[1:] # (1, 2, 8, 9, 21)

        2）列表转换

        先将元组转换为列表，然后在列表中添加元素，最后再将列表转换回元组。

tuple1 = (1, 2, 3, 5, 7, 10)

element = 4

list1 = list(tuple1)

list1.append(element)

new_tuple1 = tuple(list1) # (1, 2, 3, 5, 7, 10, 4)

        3）使用元组解包

        元组解包是一种将元组拆分为单独元素的方法，可以用*tuple的方法将元组解包的方式将元组的元素提取出来，然后再将需要添加的元素与提取出来的元素一起构建一个新的元组。（注意：这种方法跟位置参数 *arg 有点不同，是相反的）

tuple1 = (1, 2, 3, 5, 7, 10)

element = 4

new_tuple1 = (*tuple1, element) # (1, 2, 3, 5, 7, 10, 4)

        （3）切片

        元组的元素访问和列表一样，只不过返回的仍然是元组对象。

tuple1 = (1, 3, 2, 5, 10)

tuple1[1]   # 2

tuple1[2:4] # (2, 5)

tuple1[:3]  # (1, 3, 2)

tuple1[-1]  # 10

        （4）排序

        对元组排序可以使用元组内置函数sorted(tuple)，并生成新的列表序列。

tuple1 = (2, 1, 3, 10, 8, 5, 7, 4)

sorted(tuple1 )   # [1, 2, 3, 4, 5, 7, 8, 10]

        （5）zip合成元组

        zip(列表 1，列表 2，...)将多个列表对应位置的元素组合成为元组，并返回这个 zip 对象。

        请注意，这个返回的zip对象是一个生成器，生成器怎么操作看下文。

list1 = [1, 2, 3]

list2 = [5, 7, 10]

list3= [11, 12, 13]

new_tuple = zip(list1,list2, list3)  # <zip object at 0x00000207EB6707C8>

new_tuple.__next__()   # (1, 5, 11)

new_tuple.__next__()   # (2, 7, 12)

new_tuple.__next__()   # (3, 10, 13)

        （6）倒序

         将元组倒序可以使用元组内置函数reversed(tuple)，并返回一个生成器。

tuple1 = [1, 2, 3]

s = reversed(tuple1)

s.__next__() # 3

s.__next__() # 2

        （7）为元组每个元素加上索引值

        为元组内的每个元素加上索引值可以用enumerate(tuple)函数，并返回一个生成器。

tuple1 = (1, 2, 3)

new_tuple1 = enumerate(tuple1)
 
new_tuple1.__next__()  # (0, 1)

new_tuple1.__next__()  # (1, 2)

new_tuple1.__next__()  # (2, 3)

        （8）生成器推导式创建元组

        从形式上看，生成器推导式与列表推导式类似，只是生成器推导式使用小括号。列表推导式直接生成列表对象，生成器推导式生成的不是列表也不是元组，而是一个生成器对象。

        通过生成器对象，转化成列表或者元组。也可以使用生成器对象的__next__())方法进行遍历，或者直接作为迭代器对象来使用。不管什么方式使用，元素访问结束后，如果需要重新访问其中的元素，必须重新创建该生成器对象。

#生成器的使用

s = (x*2 for x in range(5))

print(s) # 生成器对象  <generator object <genexpr> at 0x00000207EB06D200>

print(tuple(s)) # tuple 函数转换为元组 (0, 2, 4, 6, 8)

print(tuple(s)) # 只能访问一次元素。第二次就为空了。需要再生成一次  ()

s = (x*2 for x in range(5))

print('next 方法获取元素：',s.__next__())   # 0

print('next 方法获取元素：',s.__next__())   # 2

print('next 方法获取元素：',s.__next__())   # 4