第十七讲 python中的元组-创建-访问-切片-长度-计数-index-zip函数

1.元租的概念

元组（tuple）是一种不可变的序列类型，用于存储一组有序的元素。元组与列表（list）相似，但元组一旦创建就不能被修改，因此是不可变的。

• 列表属于可变序列，可以任意修改列表中的元素
• 元组属于不可变序列，不能修改元组中的元素。 因此，元组没有增加元素、修改元素、删除元素相关的方法。
• 元组支持如下操作：索引访问、切片操作、连接操作、成员关系操作、比较运算操作、计数：元组长度len()、最大值max()、最小值min()、求和sum()等

• 元组的核心特点是：不可变序列。

• 元组的访问和处理速度比列表快。

• 与整数和字符串一样，元组可以作为字典的键，列表则永远不能作为字典的键使用。

2.元租的创建

 使用逗号和圆括号创建元组

最常见的创建元组的方式是使用逗号分隔的值，并将它们放在圆括号内（尽管圆括号通常是可选的）：

# 使用圆括号创建元组
tup1 = (1, 2, 3, 4, 5)
print(tup1)  # 输出: (1, 2, 3, 4, 5)

# 可以省略圆括号，只用逗号创建元组
tup2 = 1, 2, 3, 4, 5
print(tup2)  # 输出: (1, 2, 3, 4, 5)

创建单元素元组

创建只包含一个元素的元组时，需要特别注意，因为需要在元素后面加上逗号，以区分括号内的表达式和元组：

single_elem_tup = (1,)  # 注意逗号
print(single_elem_tup)  # 输出: (1,)

如果没有逗号，解释器会将圆括号视为数学运算中的括号：

not_a_tup = (1)
print(not_a_tup)  # 输出: 1，这不是一个元组

生成器推导式创建元组

        从形式上看，生成器推导式与列表推导式类似，只是生成器推导式使用小括号。

        列表推导式直接生成列表对象，生成器推导式生成的不是列表也不是元组，而是一个生成器对象

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

#列表推导式： [0, 2, 4, 6, 8]
#a = [x*2	for	x	in range(5)]
#print(a)

s = (x*2 for x in range(5))
print(s)	#<generator object <genexpr> at 0x0000021C80BE2880>
b = tuple(s)
print(b)	#(0, 2, 4, 6, 8)
c = tuple(s)
print(c)	#()



s2 = (x for x in range(3))	
print(s2.__next__())	#0
print(s2.__next__())	#1
print(s2.__next__())	#2
print(s2.__next__())	#报错：StopIteration

3.访问元组元素

元组中的元素可以通过索引访问，索引从0开始。元组是不可变的，意味着一旦创建，就不能修改其内容。

元组的访问和列表是一样的。

tup = (1, 2, 3, 4, 5)

# 访问单个元素
print(tup[0])  # 输出: 1
print(tup[3])  # 输出: 4

# 负数索引从末尾开始计数
print(tup[-1])  # 输出: 5，倒数第一个元素
print(tup[-2])  # 输出: 4，倒数第二个元素

4.元组的切片操作

可以使用切片操作访问元组的子集，元组的切片也是和列表是一样的。

tup = (1, 2, 3, 4, 5)

# 切片操作
print(tup[1:4])  # 输出: (2, 3, 4)，索引1到索引3的子元组
print(tup[:3])   # 输出: (1, 2, 3)，从开头到索引2的子元组
print(tup[2:])   # 输出: (3, 4, 5)，从索引2到末尾的子元组
print(tup[:])    # 输出: (1, 2, 3, 4, 5)，整个元组的复制

5. 元组的长度和计数

可以使用 len() 函数获取元组中元素的数量

tup = (1, 2, 3, 4, 5)
print(len(tup))  # 输出: 5，元组tup中有5个元素

使用 .count() 方法可以统计元组中特定元素的出现次数：

tup = (1, 2, 2, 3, 3, 3, 4, 5)
print(tup.count(2))  # 输出: 2，元素2在元组tup中出现了2次
print(tup.count(3))  # 输出: 3，元素3在元组tup中出现了3次
print(tup.count(6))  # 输出: 0，元素6在元组tup中不存在

6.元组使用index()

元组的 index() 方法用于查找指定元素在元组中第一次出现的索引位置。

语法格式：

tuple.index(value, start, end)

tup = (1, 2, 3, 4, 2, 5, 6, 2)

# 查找元素2的索引
print(tup.index(2))   # 输出: 1，元素2第一次出现在索引1处

# 从索引3开始查找元素2
print(tup.index(2, 3))   # 输出: 4，从索引3开始，元素2第一次出现在索引4处

# 在索引2到索引6之间查找元素5
print(tup.index(5, 2, 7))   # 输出: 5，从索引2到索引6之间，元素5第一次出现在索引5处

# 查找不存在的元素，会触发 ValueError 异常
# print(tup.index(7))   # ValueError: tuple.index(x): x not in tuple

• 如果要查找的元素不存在于元组中，会触发 ValueError 异常。因此，在使用 index() 方法时，建议先使用 in 关键字检查元素是否存在于元组中，以避免异常。
• 可以使用 start 和 end 参数来指定查找范围，这在大型元组中特别有用，可以限制搜索的范围，提高效率。

7.注意列表的排序（如果对列表使用sorted()函数会怎样）

当对元组使用 sorted() 函数时，会返回一个新的列表，该列表包含了元组中的所有元素，并按照升序排列。元组本身是不可变的，因此无法直接对其进行排序，但可以通过 sorted() 函数将其转换为一个排序后的列表。

使用 sorted() 对元组排序的示例：

tup = (3, 1, 4, 1, 5, 9, 2, 6, 5)

sorted_list = sorted(tup)
print(sorted_list)  # 输出: [1, 1, 2, 3, 4, 5, 5, 6, 9]

1. 生成新列表: sorted() 函数不会改变原始的元组 tup，而是生成一个新的列表 sorted_list。

2. 升序排列: sorted() 默认按升序排列元素。

3. 可应用于任何可迭代对象: sorted() 不仅可以对元组进行排序，还可以对列表、集合、字典的键或者值进行排序。

自定义排序顺序：

如果需要按照特定的顺序进行排序，可以通过 key 参数传入一个函数来定义排序的规则。例如，按照元组中元素的绝对值进行排序：

tup = (-3, 1, -4, 1, 5, -9, 2, 6, -5)

sorted_list = sorted(tup, key=abs)
print(sorted_list)  # 输出: [1, 1, 2, -3, -4, -5, 5, 6, -9]

注意事项：

• sorted() 返回的是一个列表，即使原始对象是元组或其他类型。
• 元组是不可变的，因此不能直接修改或排序原始元组，而是通过生成新的列表来实现排序。
• 如果原始元组中的元素具有复杂的数据类型（如元组或自定义对象），可以通过 key 参数指定排序的关键。

8.zip()函数

zip() 函数在Python中用于将多个可迭代对象（例如列表、元组等）中对应的元素打包成一个元组，然后返回这些元组组成的迭代器。每个元组中包含来自每个可迭代对象的相同索引位置的元素。

示例：

假设有两个列表，分别表示姓名和年龄：

names = ['Alice', 'Bob', 'Charlie']
ages = [24, 30, 28]

zipped = zip(names, ages)
print(list(zipped))  # 输出: [('Alice', 24), ('Bob', 30), ('Charlie', 28)]

在这个示例中，zip(names, ages) 将 names 和 ages 中对应位置的元素打包成了元组，然后返回一个迭代器。使用 list(zipped) 将迭代器转换为列表，以便查看结果。

特性和用法：

1. 并行迭代: zip() 使得可以同时迭代多个可迭代对象，而不必手动管理索引。

2. 长度匹配: 如果传递给 zip() 的可迭代对象的长度不一致，它会以最短的长度为准。多余的元素将被忽略。

3. 多种可迭代对象: zip() 不仅限于两个可迭代对象，可以同时处理多个可迭代对象。

# 三个可迭代对象
names = ['Alice', 'Bob', 'Charlie']
ages = [24, 30, 28]
heights = [165, 175, 180]

zipped = zip(names, ages, heights)
print(list(zipped))  # 输出: [('Alice', 24, 165), ('Bob', 30, 175), ('Charlie', 28, 180)]

解压缩

除了打包，zip() 也可以用于解压缩列表。可以通过 zip() 结合 * 运算符实现解压缩。

pairs = [('Alice', 24), ('Bob', 30), ('Charlie', 28)]

names, ages = zip(*pairs)
print(names)  # 输出: ('Alice', 'Bob', 'Charlie')
print(ages)   # 输出: (24, 30, 28)

在解压缩时，*pairs 将列表 pairs 中的元组展开为 zip() 的多个参数，然后 zip() 函数会根据位置解包成多个元组。

注意事项：

• zip() 返回的是一个迭代器，因此如果需要查看或者使用多次结果，需要将其转换为列表或者其他数据结构。
• 在处理大量数据时，使用 zip() 可以使代码更加简洁和高效，避免了显式的循环和索引操作。
• 如果各个迭代器的元素个数不一致，则返回列表长度与最短的对象相同

a = [10,20,30]
b = [40,50,60]
c = [70,80,90,100]
d = zip(a,b,c)
print(d)	#zip object
e = list(d) #列表：[(10,80), (30, 60, 90)]
print(e)