定义

是 Python 中内置的不可变序列。

在 Python 中使用（）定义元组，元素与元素之间使用英文的逗号分隔。

元组中只有一个元素的时候，逗号也不能省略。

元组的创建方式

（1）使用（）直接创建元组

语法

元组名=(element1,element2,......elementN)

# 使用小括号创建元组
t=('he1lo',[10,20,30],'python','world')
print(t)

（2）使用内置函数tuple()创建元组

元组名=tuple(序列)

# 使用内置函数tuple()创建元组
t=tuple('helloworld')
print(t)

元组的一些操作

引入

t=tuple([10,20,30,40])
print(t)

 这个例子说明了元组也是属于序列的。

基本操作

t = tuple([10, 20, 30, 40])
print(t)print('10在元组中是否存在：', (10 in t))
print('10在元组不存在：', (10 not in t))
print('最大值：', max(t))
print('最小值：', min(t))
print('长度：', len(t))
print('t.index：', t.index(10))
print('t.count：', t.count(10))

  只有一个元素的情况

# 如果元组中只有一个元素
t=(10)
print(t,type(t))# 如果元组中只有一个元素，逗号不能省
y=(10,)
print(y,type(y))

 删除元组

del 元组名

元组的切片 

语法格式

元组切片的基本语法为：tuple [ start : stop : step ] ，其中：

tuple：表示要进行切片操作的元组。

start：指定切片的起始位置（包含该位置的元素），若省略start，则从元组的开头开始切片，默认值为 0。

stop：指定切片的结束位置（不包含该位置的元素），如果省略stop，则切片到元组的末尾

step：指定切片的步长，即每隔多少个元素取一个，step默认值为 1，表示依次取相邻元素。

示例 

# 定义原始元组
t = (10, 20, 30, 40, 50, 60, 70, 80, 90)# 1. 获取部分元素
print("1. 获取部分元素:")
print("t[1:4] = " + str(t[1:4]))      # 输出: (20, 30, 40)
print("t[:4] = " + str(t[:4]))        # 输出: (10, 20, 30, 40)
print("t[3:] = " + str(t[3:]))        # 输出: (40, 50, 60, 70, 80, 90)# 2. 指定步长
print("\n2. 指定步长:")
print("t[1:7:2] = " + str(t[1:7:2]))  # 输出: (20, 40, 60)
print("t[::2] = " + str(t[::2]))      # 输出: (10, 30, 50, 70, 90)# 3. 反向切片
print("\n3. 反向切片:")
print("t[::-1] = " + str(t[::-1]))    # 输出: (90, 80, 70, 60, 50, 40, 30, 20, 10)
print("t[7:2:-1] = " + str(t[7:2:-1]))  # 输出: (80, 70, 60, 50, 40)# 4. 负数索引示例
print("\n4. 负数索引示例:")
print("t[-3:] = " + str(t[-3:]))      # 输出: (70, 80, 90)    

当然也可以同时省略起始值、终止值和步长，但需要保留冒号分隔符：

original = (1, 2, 3, 4, 5)
new_tuple = original[:]  # 省略起始值、终止值和步长print(new_tuple)        # 输出: (1, 2, 3, 4, 5)
print(new_tuple is original)  # 输出: False（证明是新对象）

这个用法的一些常见应用场景：

（1）创建副本

t = (1, 2, 3)
copy_t = t[:]  # 创建元组的副本

（2） 结合步长反转元组

reversed_t = t[::-1]  # 步长为-1，从后向前遍历，输出: (3, 2, 1)

Python 中，元组（tuple）和列表（list）的切片操作语法完全相同

 元组生成式

使用圆括号（）包裹，并返回一个生成器对象。与列表推导式不同，元组生成式不会一次性生成所有元素，而是按需生成。

基本语法

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

表达式：对每个元素进行处理的计算逻辑，生成最终的值。

for 变量 in 可迭代对象：遍历可迭代对象（如列表、元组、字符串等）中的每个元素。

if 条件表达式（可选）：过滤元素，只对满足条件的元素执行表达式。

用例

#生成偶数元组
even_numbers = (x for x in range(10) if x % 2 == 0)
print(tuple(even_numbers))  # 输出: (0, 2, 4, 6, 8)#计算平方元组
squares = (x**2 for x in [1, 2, 3, 4, 5])
print(tuple(squares))  # 输出: (1, 4, 9, 16, 25)#字符串长度元组
words = ["apple", "banana", "cherry"]
lengths = (len(word) for word in words)
print(tuple(lengths))  # 输出: (5, 6, 6)

**注意

（1）生成器对象：元组生成式返回的是生成器对象，需要通过 tuple() 转换为元组或迭代使用。 

（2）一次性使用：生成器对象只能遍历一次，再次遍历时会耗尽。

（3）内存效率：适合处理大量数据，避免一次性加载全部元素到内存。

元组与列表的区别

元组的遍历 

1、for 循环直接遍历元素

tup = (10, 20, "hello", 3.14)
for element in tup:print(element)

2、结合 enumerate 遍历

语法结构

for 索引变量, 值变量 in enumerate(可迭代对象):# 循环体，使用 索引变量 和 值变量print(f"索引: {索引变量}, 值: {值变量}")

可以同时取到元素以及对应索引（位置）

tup = (10, 20, "hello", 3.14)
for index, element in enumerate(tup):print(f"索引 {index}，元素 {element}")

3、 通过索引遍历（range + len）

range 的语法格式

#括号内只有一个值的情况
#默认输出从 0 开始，到倒数第一个元素（意思就是不包含结束值）的整数序列。
range(stop)
#示例
for i in range(5):print(i)  # 输出: 0, 1, 2, 3, 4#完整格式
range(start, stop, step)
#示例
# 正向，步长2
for i in range(0, 10, 2):print(i)  # 输出: 0, 2, 4, 6, 8
# 反向，步长-1
for i in range(5, 0, -1):print(i)  # 输出: 5, 4, 3, 2, 1

 先获取元组的长度，再用 range 生成索引序列，再通过索引来访问元素，适合需要精确控制索引的场景。

tup = (10, 20, "hello", 3.14)
for i in range(len(tup)):print(tup[i])

大家会发现这几种遍历方式都有 for...in 结构，这是因为列表、元组、字符串等都是 “可迭代对象”，它们内部实现了迭代器协议（即包含 __iter__() 方法）。for...in 循环的底层逻辑就是通过调用对象的迭代器，依次获取元素，直到遍历结束。

那这几种遍历方式可以简记为：

1、最基本方式：for + 变量 + in + 可迭代对象；

适用场景：只需元素值，不需要索引。

2、enumerate方式：for + 索引变量，值变量 + in + 可迭代对象；

适用场景：需要同时使用索引和元素值。

3、for + 变量 + in + range（len（可迭代对象））；

适用场景：需要手动控制索引。

基于 range 方式的拓展 -- 反向遍历或跳步遍历：

通过结合 range 的参数：

fruits = ["apple", "banana", "cherry"]# 反向遍历（从后往前）
for i in range(len(fruits)-1, -1, -1):  # 从最后一个索引到0，步长-1print(fruits[i])  # 输出: cherry, banana, apple# 跳步遍历（每隔一个元素取一次）
for i in range(0, len(fruits), 2):  # 从0开始，步长2print(fruits[i])  # 输出: apple, cherry

今天的分享就到这里啦~

谢谢大家的观看！！