元组

定义：

与列表相似，不同点：元素不可修改

使用圆括号表示，定义方式：元组名字=(元素1，元素2，元素...)

元素访问

下标访问

（同列表 、字符串同）元组名称[下标] 都是方括号

切片访问

访问定义语法：元组名字[初始位置:终止位置：步长]，步长不能为0

元组推导式：（同列表推导式，就是最外面是圆括号）

序列：指的是可以从索引位置访问元素的数据结构。标准序列类型：列表，字符串，元组，其中列表叫可变参数

序列的操作

min()和max()

不传参数，直接使用

传入key,该参数接受一个函数，该函数会用于序列中每个元素以确定如何比较元素

默认值：传入default参数，当输入的是空序列时，会打印default参数的内容。

sum()函数会有一个start参数，求和结果是在求和结果上加上start

sorted()用于对序列进行排序，默认是升序排列；与列表sort()不同：返回全新的列表，原有序列不会改变。

reversed（）用于对序列进行反转，与列表reverse()函数不同：该函数返回一个迭代器，须通过强转或for循环来观看（多加一步操作）

all()判断序列所有元素是否为真，返回布尔值

any()判断序列某个元素是否为真，返回类型是布尔值

enumerate():将可遍历的数据对象下标与 元素组合起来，该函数返回的是枚举对象，是一个包含元组的序列，需要强转或for循环调用结果的迭代器，

zip():用于将多个可迭代对象对应位置元素打包为一个元组，然后返回元组组成的迭代器也需要进一步操作才能看到，同enumerate()函数

map()：用于可迭代对象的每个元素应用一个指定的哈数，返回一个包含所有函数调用结果的迭代器，需要强转或for循环调用结果的迭代器。

filter()；会根据提供的函数对指定的可迭代啊对象每个元素进行运算，并将运算结果为真的元素以迭代器的形式返回，需要强转或for循环调用结果的迭代器。

课后习题

编程题：

2.给定一个列表 data = [1, 2, 3, 4,5, 6, 7, 8, 9] 和一个整数group_size = 3 。编写一个 Python脚本，将列表 data 中的元素按group_size 分组，形成一个新的列表，其中每个元素是一个包含group_size 个原始素的元组。如果列表末尾的元素不足 group_size个，则忽略这些元素。打印分组后的列表。预期输出： 
[(1, 2,3）(4,5,6), (7, 8, 9)] 。

参考答案：

data = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] # 增加一个元素测试不足分组的情况
group_size = 3

grouped_list = []
# 使用 for 循环和步长来控制分组的起始位置
for i in range(0, len(data), group_size):
    print(i)
    # 提取当前分组的切片
    group_slice = data[i : i + group_size]
    # 检查切片长度是否等于 group_size (严格按题目要求，不足则忽略)
    if len(group_slice) == group_size:
         # 将切片转换为元组并添加到结果列表
        grouped_list.append(tuple(group_slice))

print(f"原始列表: {data}")
print(f"分组大小: {group_size}")
print(f"分组后的列表 (忽略末尾不足的组): {grouped_list}")

# 使用列表推导式的更简洁写法 (忽略不足的组)
# grouped_list_comp = [tuple(data[i:i+group_size]) for i in range(0, len(data), group_size) if len(data[i:i+group_size]) == group_size]
# print(f"分组后的列表 (列表推导式): {grouped_list_comp}")

我的答案：

data = [1,2,3,4,5,6,7,8,9]
group_size = 3

#按照group_size分组

#目标new_data =[(1,2,3),(4,5,6),(7,8,9)]

x1 =data[0:group_size]
print(tuple(x1))
x2 =data[group_size:group_size+3]
print(tuple(x2))
x3 =data[group_size+3:]
print(tuple(x3))
new_data=[tuple(x1),tuple(x2),tuple(x3)]
print(f"新打印分组后的列表为{new_data}")

总结：

1.较啰嗦且不够通用，手动对每个分组进行了切片和转换，而不是使用循环或列表推导式来更高效地处理任意长度的列表

2.此外，代码虽然正确，但缺乏灵活性，如果列表长度或分组大小变，代码需要手动修改。

3.把for循环格式与切片访问方式混一起了，我在用range()函数的时候，里面语法格式写的是冒号，正确range（起始位置，终止位置，步长）

4.列表推导式无序使用append将取到的切片添加到列表里，对列表推导式定义理解不透彻

补充：

冒泡排序算法：

举例：

n = 5，列表索引 0~4

  • i = 0：待排长度5，比较次数 = 4 → range(4) → j = 0,1,2,3（比较(0,1),(1,2),(2,3),(3,4)）

  • i = 1：待排长度4，比较次数 = 3 → range(3) → j = 0,1,2（比较(0,1),(1,2),(2,3)；索引4已排好）

  • i = 2：待排长度3，比较次数 = 2 → range(2)

  • i = 3：待排长度2，比较次数 = 1 → range(1)

  • i = 4：待排长度1，比较次数 = 0 → range(0)（空循环，其实可以优化到 n-1 轮）

    其中得出结论需要比较的轮数 = n-(i+1)=n-i-1

    #1.给定一个包含元组的列表 items =
[('apple', 2.5), ('banana', 1.8),
('orange', 3.0), ('grape',
2.8)] ，其中每个元组代表（商品名
称, 价格）。编写一个 Python 脚
本，根据元组中的价格（第二个元
素）对这个列表进行升序排序，并打
印排序后的列表。

# 使用冒泡排序手动实现
for i in range(n):
    for j in range(n-i-1):
       if items[i+j][1] > items[i+j+1][1]:
           items[j], items[j+1] = items[j+1], items[j]
print(items)
'''

for j in range(n-i-1)代表需要比较的轮数，i代表需要排列元素的索引。