在职前端Leader学习/转行 AI Agent -DAY3

2026.7.11 13:13

学习路线

Python -> Python进阶 -> Python数据分析 -> LangChain -> 机器学习 -> 神经网络 -> NLP -> Coze -> Dify -> 大模型应用基础 -> 大模型微调 -> 多模态 -> vibeCoding

Python 学习

60. 列表_定义列表

# 定义有内容的列表
# list = [34, 56, 21, 56, 11]  # 不能改原有函数
list1 = [34, 56, 21, 56, 11]
list2 = ['北京', '尚硅谷', '你好啊']
list3 = [23, '尚硅谷', True, None]
list4 = [23, '尚硅谷', True, None, [100, 200, 300]]
print(list1, type(list1))
print(list2, type(list2))
print(list3, type(list3))
print(list4, type(list4))

# 定义空列表（列表中的数据，后期会通过特定写法填充）
list5 = []
list6 = list()
print(list5, type(list5))
print(list6, type(list6))

61. 列表_下标(索引值)

# 定义一个列表
nums = [10, 20, 30, 40, 50]

# 测试正索引
print(nums[0])
print(nums[1])
print(nums[2])
print(nums[3])
print(nums[4])

# 测试负索引
print(nums[-1])
print(nums[-2])
print(nums[-3])
print(nums[-4])
print(nums[-5])

# 测试错误索引
# print(nums[5])  # 错误

# 定义一个嵌套列表
nums = [10, 20, ['你好啊', '尚硅谷'], 40, 50]
# 去除"尚硅谷"
print([nums[2]])
print([nums[2][1]])

62. 列表_增删改查

# 新增操作
# 方法一: 通过列表的append方法，在列表尾部加一个元素
from unittest import result

nums = [10, 20, 30, 40]
nums.append(50)
print(nums)

# 方式二: 通过列表的insert方法，在列表的指定下标出添加一个元素
nums = [10, 20, 30, 40]
nums.insert(2, 666)
print(nums)

# 方式三: 通过列表的extend方法，将可迭代对象中的内容依次取出，追加到列表尾部
nums = [10, 20, 30, 40]
nums.extend('尚硅谷')
print(nums)  # [10, 20, 30, 40, '尚', '硅', '谷']
nums.extend(range(1, 4))
print(nums)  # [10, 20, 30, 40, '尚', '硅', '谷', 1, 2, 3]
x = nums.extend([70, 80, 90])
print(nums)  # [10, 20, 30, 40, '尚', '硅', '谷', 1, 2, 3, 70, 80, 90]
print(x)  # None

# 删除操作
# 方式一: 通过列表的pop方法，删除指定位置的元素，并返回该元素
nums = [10, 20, 10, 40, 50]
result = nums.pop(1)
print(nums)  # [10, 10, 40, 50]
print(result)  # 20

# 方式二: 通过列表的remove方法，删除列表中第一次出现的指定值
nums = [10, 20, 10, 40, 50]
nums.remove(10)
print(nums)  # [20, 10, 40, 50]

# 方式三: 通过列表的clear方法，删除列表中的所有元素（清空列表）
nums = [10, 20, 10, 40, 50]
nums.clear()
print(nums)  # []

# 方式四: 通过del关键字，删除指定元素
nums = [10, 20, 10, 40, 50]
del nums[3]
print(nums)  # [10, 20, 10, 50]

# 修改操作
nums = [10, 20, 10, 40, 50]
nums[2] = 66
print(nums)  # [10, 20, 66, 40, 50]

# 查询操作
nums = [10, 20, 10, 40, 50]
print(nums[3])  # 40

63. 列表_常用方法

# 1. 使用 index 方法，查找指定元素在列表中第一次出现的下标，返回值是: 元素下标
fruits = ['香蕉', '苹果', '橙子', '香蕉']
result = fruits.index('香蕉')
print(result)  # 0
result = fruits.index('苹果')
print(result)  # 1
# result = fruits.index('草莓')  # 运行报错
# print(result)
fruits = ['香蕉', '苹果', '橙子', '香蕉', ['草莓', '菠萝']]
# result = fruits.index('草莓')  # 运行报错，不会往下查找
# print(result)

# 2. 使用 count 方法，统计某个元素在列表中的出现的次数，返回值是: 元素出现的次数
nums = [10, 20, 10, 30, 10, 40]
result = nums.count(10)
print(result)  # 3
result = nums.count(66)
print(result)  # 0
nums = [10, 20, 10, 30, 10, 40, [10, 10, 10]]
result = nums.count(10)
print(result)  # 3，不往下查找

# 3. 使用 reverse 方法，对列表进行反转（会改变原列表）
nums = [23, 11, 32, 30, 17]
nums.reverse()
print(nums)  # [17, 30, 32, 11, 23]
nums = [23, 11, 32, 30, 17, [6, 7, 8, 9]]
nums.reverse()
print(nums)  # [[6, 7, 8, 9], 17, 30, 32, 11, 23，不往下反转

# 4. 使用 sort 方法，队列表排序（默认从小到大），若想从大到小，可以将 reverse 参数设为 True
# 4.1 若列表中的元素: 都是数字，则按照数字的大小顺序进行排序
nums = [23, 11, 32, 30, 17]
nums.sort()
print(nums)  # [11, 17, 23, 30, 32]
nums.sort(reverse=True)
print(nums)  # [32, 30, 23, 17, 11]

# 4.2 若列表中的元素: 既有数字，又有字符串，那就会报错
nums = [23, 11, 32, 30, 17, '尚硅谷']
# nums.sort()  # 运行报错
# print(nums)

# 4.3 若列表中的元素: 都是字符串，则按照字符串的 Unicode 编码大小进行排序
msg_list = ['北京', '尚硅谷', '你好']
msg_list.sort()
print(msg_list)  # ['你好', '北京', '尚硅谷']
print(ord('你'), ord('北'), ord('尚'))
msg_list = ['北京', '北硅谷', '北好']
msg_list.sort()
print(msg_list)  # ['北京', '北好', '北硅谷']
print(ord('京'), ord('好'), ord('硅'))

# 备注: 所有的列表方法，都只作用于"当前层"的元素（浅层操作），不糊自动进入嵌套的"里层"结构中

64. 列表_常用内置函数

# 1. 使用内置的 sorted 函数，返回一个排序后的新容器（不改变原容器，默认顺序: 从小到大）
# 1.1 若列容器中的元素: 都是数字，则按照数字的大小顺序进行排序
nums = [23, 11, 32, 30, 17]
result = sorted(nums)
print(nums)  # [23, 11, 32, 30, 17]
print(result)  # [11, 17, 23, 30, 32]
result = sorted(nums, reverse=True)
print(nums)  # [23, 11, 32, 30, 17]
print(result)  # [32, 30, 23, 17, 11]

# 1.2 若列容器中的元素: 既有数字，又有字符串，那就会报错
nums = [23, 11, 32, 30, 17, '尚硅谷']
# sorted(nums)  # 运行报错

# 1.3 若列容器中的元素: 都是字符串，则按照字符串的 Unicode 编码大小进行排序
msg_list = ['北京', '尚硅谷', '你好']
result = sorted(msg_list)
print(msg_list)  # ['北京', '尚硅谷', '你好']
print(result)  # ['你好', '北京', '尚硅谷']

# 2. 使用内置的 len 函数。获取容器中元素的总数量，返回值是: 元素总数量
nums = [10, 20, 10 ,30, 10, 40]
result = len(nums)
print(result)  # 6
nums = [10, 20, 10 ,30, 10, 40, [50, 60, 70]]
result = len(nums)
print(result)  # 7

# 3. 使用内置的 max 函数，获取容器中的最大值，返回值是: 最大值
# 3.1 若列容器中的元素: 都是数字，那 max 返回的是最大的数
nums = [23, 11, 32, 30, 17]
result = max(nums)
print(nums)
print(result)  # 32

# 3.2 若列容器中的元素: 既有数字又有字符串，那 max 会报错
nums = [23, 11, 32, 30, 17, '尚硅谷']
# result = max(nums)  # 运行报错
# print(result)

# 3.3 若列容器中的元素: 都是字符串，则 max 会返回: Unicode 编码最大的字符
msg_list = ['北京', '尚硅谷', '你好']
result = max(msg_list)
print(msg_list)
print(result)  # '尚硅谷'

# 3.4 max 函数也可以接收多个值，并筛选出最大值
result = max(33, 45, 12, 78, 99)
print(result)  # 99

# 4. 使用内置的 min 函数，获取容器中的最小值，返回值是: 最小值
# 备注: min 函数的使用方式与注意点与 max 函数一样，只不过 min 函数返回的是最小值
nums = [23, 11, 32, 30, 17]
result = min(nums)
print(result)  # 11

# 5. 使用内置的 sum 函数，对容器中的数据进行求和（元素只能是数值）
nums = [10, 20, 30, 40, 50]
result = sum(nums)
print(result)  # 150
nums = [10, 20, 30, 40, 50, '尚硅谷']
# result = sum(nums)  # 运行报错
# print(result)
nums = [10, 20, 30, 40, 50, [60, 70, 80]]
# result = sum(nums)  # 运行报错
# print(result)
msg = '你好啊'
# result = sum(msg)  # 报错
# print(result)
msg = '123456'
# result = sum(msg)  # 报错
# print(result)

65. 列表_循环遍历

# 定义一个成绩列表
score_list = [62, 50, 60, 48, 80, 20, 95]

# 使用 while 循环遍历列表
index = 0
while index < len(score_list):
    # print(index)
    print(score_list[-index])
    index += 1

# index = 1  # 下标越界
# while index <= len(score_list):
#     print(score_list[index])
#     index += 1

# 自己防止下标越界的方法
index = 1
while index <= len(score_list):
    print(score_list[-index])
    index += 1

# 使用 for 循环遍历列表
for item in score_list:
    print(item)

# 使用 for 循环遍历列表（通过 range 函数 和 len 函数按照索引遍历）
for index in range(len(score_list)):
    # print(index)
    print(score_list[index])

# 使用 for 循环遍历列表（通过 enumerate 函数，同时获取下标（索引值）和元素）
for index, item in enumerate(score_list):
# enumerate 的 start 参数，可以让计数从指定值开始（改变的是循环时的"编号"，不是真正的索引值）
# for index, item in enumerate(score_list, start=5):
    print(index, item)
    # print(index, item, score_list[0])
print(enumerate(score_list), type(enumerate(score_list)))  # 自己探索的
print(f'最后的打印{score_list[0]}')

66. 列表_小练习

# 自己写的版本
def input_score():
    score_list = []
    while True:
        score = input('请输入成绩（输入结束后结束输入）: ')
        if score == '结束':
            break
        elif int(score) < 0 or int(score) > 100:
            print('请输入0~100的数字')
        else:
            score_list.append(int(score))
    return score_list

def get_nums(score_list):
    passed_num = 0
    great_num = 0
    for score in score_list:
        if score >= 60:
            passed_num += 1
        if score >= 90:
            great_num += 1
    return [passed_num, great_num]

def get_computed(score_list):
    score_list_len = len(score_list)
    print(f'总人数{score_list_len}')
    print(f'最高分{max(score_list)}')
    print(f'最低分{min(score_list)}')
    computed_get_nums = get_nums(score_list)
    print(f'合格人数{computed_get_nums[0]}')
    print(f'合格率{computed_get_nums[0] / score_list_len}')
    print(f'优秀人数{computed_get_nums[1]}')
    print(f'优秀率{computed_get_nums[1] / score_list_len}')
    print(f'平均分{sum(score_list) / score_list_len}')

def main():
    scores = input_score()
    if scores:
        get_computed(scores)
    else:
        print('请重新输入成绩')
        main()

main()

# 老师写的思路
print('请输入学生成绩，输入"结束"停止录入')
score_list = []

# 持续循环，让用户输入学生成绩
while True:
    data = input('✍请输入成绩: ')
    if data == '结束':
        break
    else:
        score_list.append(int(data))

# 如果 score_list 中有数据，则开始统计
if score_list:
    # print('具体的统计代码')
    # 统计平均分
    avg = sum(score_list) / len(score_list)
    # 合格人数
    pass_count = 0
    # 优秀人数
    excellent_count = 0
    # 遍历列表，开始统计
    for item in score_list:
        if item >= 60:
            pass_count += 1
        elif item >= 90:
            excellent_count += 1
    # 合格率
    pass_rate = pass_count / len(score_list) * 100
    # 优秀率
    excellent_rate = excellent_count / len(score_list) * 100
    # 打印信息
    print('*********👇统计信息如下👇*********')
    print(f'👮总人数为: {len(score_list)}')
    print(f'👆最高分为: {max(score_list)}')
    print(f'👇最低分为: {min(score_list)}')
    print(f'合格人数: {pass_count}人')
    print(f'合格率为: {pass_rate:.1f}%')
    print(f'🏆优秀人数: {excellent_count}人')
    print(f'优秀率为: {excellent_rate:.1f}%')
    print(f'平均分数: {avg:.1f}')
else:
    print('您没有输入任何成绩! ')

67. 列表_小练习

# 自己写的版本
def input_score():
    score_list = []
    while True:
        score = input('请输入成绩（输入结束后结束输入）: ')
        if score == '结束':
            break
        elif int(score) < 0 or int(score) > 100:
            print('请输入0~100的数字')
        else:
            score_list.append(int(score))
    return score_list

def get_nums(score_list):
    passed_num = 0
    great_num = 0
    for score in score_list:
        if score >= 60:
            passed_num += 1
        if score >= 90:
            great_num += 1
    return [passed_num, great_num]

def get_computed(score_list):
    score_list_len = len(score_list)
    print(f'总人数{score_list_len}')
    print(f'最高分{max(score_list)}')
    print(f'最低分{min(score_list)}')
    computed_get_nums = get_nums(score_list)
    print(f'合格人数{computed_get_nums[0]}')
    print(f'合格率{computed_get_nums[0] / score_list_len}')
    print(f'优秀人数{computed_get_nums[1]}')
    print(f'优秀率{computed_get_nums[1] / score_list_len}')
    print(f'平均分{sum(score_list) / score_list_len}')

def main():
    scores = input_score()
    if scores:
        get_computed(scores)
    else:
        print('请重新输入成绩')
        main()

main()

# 老师写的思路
print('请输入学生成绩，输入"结束"停止录入')
score_list = []

# 持续循环，让用户输入学生成绩
while True:
    data = input('✍请输入成绩: ')
    if data == '结束':
        break
    else:
        score_list.append(int(data))

# 如果 score_list 中有数据，则开始统计
if score_list:
    # print('具体的统计代码')
    # 统计平均分
    avg = sum(score_list) / len(score_list)
    # 合格人数
    pass_count = 0
    # 优秀人数
    excellent_count = 0
    # 遍历列表，开始统计
    for item in score_list:
        if item >= 60:
            pass_count += 1
        elif item >= 90:
            excellent_count += 1
    # 合格率
    pass_rate = pass_count / len(score_list) * 100
    # 优秀率
    excellent_rate = excellent_count / len(score_list) * 100
    # 打印信息
    print('*********👇统计信息如下👇*********')
    print(f'👮总人数为: {len(score_list)}')
    print(f'👆最高分为: {max(score_list)}')
    print(f'👇最低分为: {min(score_list)}')
    print(f'合格人数: {pass_count}人')
    print(f'合格率为: {pass_rate:.1f}%')
    print(f'🏆优秀人数: {excellent_count}人')
    print(f'优秀率为: {excellent_rate:.1f}%')
    print(f'平均分数: {avg:.1f}')
else:
    print('您没有输入任何成绩! ')

68. 元组

# 定义元组
from unittest import result

t1 = (28, 67, 21, 67, 11)
t2 = ('北京', '尚硅谷', '你好')
t3 = (100, True, '你好', None)
t4 = (100, True, '你好', None, (50, 60, 70))
print(type(t1), t1)
print(type(t2), t2)
print(type(t3), t3)
print(type(t4), t4)

# 元组的下标
t1 = (28, 67, 21, 67, 11)
print(t1[3])
print(t1[-1])

# 元组中的元素，不可修改
# t1[0] = 100  # 报错

# 元组中的元素。不可修改，但元组中如果存放了可变类型（列表），那可变类型中的内容仍可修改
t2= (28, 67, 21, 67, 11, [100, 200, 300, ('你好', '尚硅谷')])
# t2[5] = 400  # 报错
t2[5][2] = 400
print(t2)
# t2[5][3][0] = 'hello'  # 运行报错

# 定义空元组
t1 = ()
t2 = tuple()
print(type(t1), t1)
print(type(t2), t2)

# 定义只有一个元素的元组
# t1 = ('你好')  # 报错
t1 = (
    '你好',
    '尚硅谷'
)
print(type(t1), t1)  # 你好尚硅谷  不是元组是字符串
t1 = ('你好',)
t2 = (18,)
print(type(t1), t1)  # 是元组
print(type(t2), t2)  # 是元组

# 常用方法
# index 方法: 获取指定元素在元组中第一次出现的下标
t1 = (28, 67, 21, 67, 11)
result = t1.index(67)
print(result)  # 1

# count 方法: 统计指定元素在元组中出现的次数
t1 = (28, 67, 21, 67, 11)
result = t1.count(67)
print(result)  # 2

# 常用内置函数
# max 函数，返回元组中的最大值
t1 = (23, 11, 32, 30, 17)
result = max(t1)
print(result)  # 32

# min 函数，返回元组中的最小值
t1 = (23, 11, 32, 30, 17)
result = min(t1)
print(result)  # 11

# len 函数，返回元组中元素的个数（元组长度）
t1 = (23, 11, 32, 30, 17)
result = len(t1)
print(result)  # 5

# sorted 函数，对元组进行排序（不修改原元组，返回一个新的列表）
t1 = (23, 11, 32, 30, 17)
result = sorted(t1)
print(result)  # [11, 17, 23, 30, 32]
result = sorted(t1, reverse=True)
print(result)  # 列表 [32, 30, 23, 17, 11]
print(tuple(result))  # 元组 (32, 30, 23, 17, 11)

# sum 函数，统计元组中所有元素的和（元素必须是纯数字）
t1 = (23, 11, 32, 30, 17)
result = sum(t1)
print(result)  # 113

# 实际开发中的元组，不一定是我们自己定义的，比如函数的可变参数*args就是一个元组
def demo(*args):
    # print(args)
    return sum(args)
# demo(100, 200, 300)
result = demo(100, 200, 300)
print(result)  # 600

# 元组的循环遍历
t1 = (23, 11, 32, 30, 17)

# while 循环遍历
index = 0
while index < len(t1):
    print(t1[index])
    index += 1

# for 循环遍历
for item in t1:
    print(item)

69. 函数_解包列表或元组传参

# def test(data):
# def test(a, b, c, d):
# 定义函数时，使用*args（变量不一定非要用args，比如写: *data也可以），将收到的多个参数，打包成一个元组
def test(*args):
    # print(f'我是test函数，我收到的参数是: {data}')
    # print(f'我是test函数，我收到的参数是: {a}、{b}、{c}、{d}')
    print(f'我是test函数，我收到的参数是: {args}，参数类型是: {type(args)}')
list1 = [100, 200, 300, 400]
tuple1 = ('你好', '北京', '尚硅谷')

# 函数调用时，正常传递: 列表 或 元组
# test(list1)
# test(tuple1)

# 函数调用时，使用*队: 列表 或 元组进行解包后，再传递参数
test(*list1)  # 此种写法相当于: test(100, 200, 300, 400)  报错，入参过多
test(*tuple1)  # 此种写法相当于: test('你好', '北京', '尚硅谷')  报错，入参过少

70. 函数_综合案例（优化版）

def calc_total(*nums):
# def calc_total(nums):
    """
    计算总运动量（个）
    :param nums: 每一天的运动量（可变参数）
    :return: 总运动量（个）
    """
    return sum(nums)

def calc_avg(total, days=7):
    """
    计算平均值
    :param total: 总运动量（个）
    :param days: 天数（默认值是7）
    :return: 平均值
    """
    return total / days

def check_success(total, goal=120):
    """
    挑战本次挑战是否成功
    :param total: 总运动量
    :param goal: 成功数量（默认值是120）
    :return: 成功或失败的具体信息
    """
    if total >= goal:
        return '恭喜! 挑战成功! '
    else:
        return '抱歉! 挑战失败! '

# def main(title, duration):
def main(title, duration, goal):
    """
    主函数，用于开始一场挑战赛
    :param title: 比赛标题
    :param duration: 比赛持续天数
    :param goal: 目标运动量
    :return: None
    """
    print(f'【{title}】【{duration}天】👊挑战赛（请输入每天的数量）')
    # num1 = int(input('第1天: '))
    # num2 = int(input('第2天: '))
    # num3 = int(input('第3天: '))
    # 定义一个nums列表，用于存储每天的健身数据
    nums = []
    # 根据 duration 的值，循环让用户输入
    for index in range(duration):
        nums.append(int(input(f'请输入第{index + 1}天的数据: ')))

    # 计算总数
    # total = calc_total(num1, num2, num3)
    # total = calc_total(nums)
    total = calc_total(*nums)
    # 计算平均值
    avg = calc_avg(total, duration)
    # 判断挑战是否成功
    result = check_success(total, 30)
    # 打印相关信息
    print(f'【{title}】【{duration}天】健身总结')
    print(f'总数: {total}，平均值: {avg:.1f}')
    print(result)

main('俯卧撑', 3, 40)

71. 字符串（数据容器角度）

# 字符串的下标
from unittest import result

msg = 'welcome to atguigu'
print(msg[3])
print(msg[-1])

# 字符串中的字符，不可修改
msg = 'welcome to atguigu'
# msg[0] = 'a'  # 报错

# 字符串不能嵌套
# msg = 'welcome to 'hello' atguigu'
msg = 'welcome to "hello" atguigu'
print(msg[11])  # 11
msg = 'welcome to 'hello' atguigu'

# 常用方法
# index 方法: 获取指定字符，在字符串中第一次出现的下标
msg = 'welcom to atguigu'
result = msg.index('t')
print(result)  # 8

# split 方法: 将字符串按照指定字符进行分隔，并将分隔后的内容存入一个列表
msg = '尚硅谷@atguigu@你好'
result = msg.index('@')
print(msg)  # '尚硅谷@atguigu@你好'
print(result)  # ['尚硅谷', 'atguigu'. '你好']
result = msg.index('x')
print(result)  # ['尚硅谷@atguigu@你好']
msg = 'welcome to atguigu'
result = msg.index(' ')
print(result)  # ['welcome', 'to', 'atguigu']

# replace 方法: 将字符串中的某个字符片段，替换成目标字符串（不修改原字符串，返回新字符串）
msg = 'welcome to atguigu'
result = msg.replace('g', 'G')
print(msg)  # welcome to atguigu
print(result)  # welcome to atGuiGu
result = msg.replace('atguigu', '尚硅谷')
print(result)  # welcome to 尚硅谷

# count 方法: 统计指定字符，再字符串中出现的次数
msg = 'welcome to atguigu'
result = msg.count('g')
print(result)  # 2

# strip 方法: 从某个字符串中删除: 指定字符串中的任意字符
# 规则: 从字符串两端开始删除，只要遇到i一个不在字符串中的字符就停下
msg = '666尚6硅6谷666'
result = msg.strip('6')
print(msg)  # '666尚6硅6谷666'
print(result)  # '尚6硅6谷

msg = '1234尚12硅34谷4321'
result = msg.strip('1324')
print(msg)  # '1234尚12硅34谷4321'
print(result)  # '尚12硅34谷

msg = '34215尚12硅34谷4132'
result = msg.strip('5432')
print(msg)  # '34215尚12硅34谷4132'
print(result)  # '15尚12硅34谷41

# strip常用
msg = '  尚硅谷  '
result = msg.strip()
print(msg)  # '  尚硅谷  '
print(result)  # '尚硅谷'

# 常用内置函数
# len 函数: 统计字符串中字符串的个数（字符串的长度）
msg = 'welcome to atguigu'
result = len(msg)
print(result)  # 18

# max min sorted 也可以用但是基本没有意义

# 字符串的循环遍历
msg = 'welcome to atguigu'
# while 循环遍历
index = 0
while index < len(msg):
    print(msg[index])
    index += 1

# for 循环遍历
for item in msg:
    print(item)

72. 序列的切片操作

# 切片不包含结束位置 [开始位置:结束位置:步长]
# 开始位置: 默认0
# 结束位置: 默认序列长度
# 步长: 默认1，如果为n，就是间隔n - 1个取元素
# 开始位置>结束位置，步长必须是负数

# 对列表进行切片
list1 = [10, 20, 30, 40, 50, 60, 70, 80, 90, 100]
list2 = list1[0:5:1]
print(list2)  # [10, 20, 30, 40, 50]

list1 = [10, 20, 30, 40, 50, 60, 70, 80, 90, 100]
list2 = list1[1:8:2]
print(list2)  # [20, 40, 60, 80]

list1 = [10, 20, 30, 40, 50, 60, 70, 80, 90, 100]
list2 = list1[1:8:3]
print(list2)  # [20, 50, 80]

list1 = [10, 20, 30, 40, 50, 60, 70, 80, 90, 100]
list2 = list1[0:10:1]
print(list2)  # [10, 20, 30, 40, 50, 60, 70, 80, 90, 100]

list1 = [10, 20, 30, 40, 50, 60, 70, 80, 90, 100]
list2 = list1[::]
print(list2)  # [10, 20, 30, 40, 50, 60, 70, 80, 90, 100]

list1 = [10, 20, 30, 40, 50, 60, 70, 80, 90, 100]
list2 = list1[:999:]
print(list2)  # [10, 20, 30, 40, 50, 60, 70, 80, 90, 100]

list1 = [10, 20, 30, 40, 50, 60, 70, 80, 90, 100]
list2 = list1[3::]
print(list2)  # [40, 50, 60, 70, 80, 90, 100]

list1 = [10, 20, 30, 40, 50, 60, 70, 80, 90, 100]
list2 = list1[:5:]
print(list2)  # [10, 20, 30, 40, 50]

list1 = [10, 20, 30, 40, 50, 60, 70, 80, 90, 100]
list2 = list1[::4]
print(list2)  # [10, 50, 90]

list1 = [10, 20, 30, 40, 50, 60, 70, 80, 90, 100]
list2 = list1[7:2:-1]
print(list2)  # [80, 70, 60, 50, 40]

list1 = [10, 20, 30, 40, 50, 60, 70, 80, 90, 100]
list2 = list1[7:2:1]
print(list2)  # []

# 一个特殊情况: 当同时省略起始索引和结束索引时，如果步长为负数，那Python会自动对调: 起始位置和结束位置
list1 = [10, 20, 30, 40, 50, 60, 70, 80, 90, 100]
list2 = list1[::-1]
print(list2)  # [100, 90, 80, 70, 60, 50, 40, 30, 20, 10]

# 对元组进行切片
tuple1 = (10, 20, 30, 40, 50, 60, 70, 80, 90, 100)
tuple2 = tuple1[0:5:1]
print(tuple2)  # (10, 20, 30, 40, 50)

# 对字符串进行切片
msg1 = 'welcome to atguigu'
msg2 = msg1[2:9:2]
print(msg2)  # 'loet'

73. 序列的其他操作

# 序列相加
list1 = [10, 20, 30, 40]
list2 = [50, 60, 70, 80]
list3 = list1 + list2
print(list3)  # [10, 20, 30, 40, 50, 60, 70, 80]

tuple1 = (10, 20, 30, 40)
tuple2 = (50, 60, 70, 80)
tuple3 = tuple1 + tuple2
print(tuple3)  # (10, 20, 30, 40, 50, 60, 70, 80)

str1 = 'hello'
str2 = 'atguigu'
str3 = str1 + str2
print(str3)  # 'hello atguigu'

# 错误实例
list1 = [10, 20, 30, 40]
str1 = 'hello'
# print(list1 + str1)  # 报错

# 序列相乘（重复）
list1 = [10, 20, 30, 40]
list2 = list1 * 3
print(list2)  # [10, 20, 30, 40, 10, 20, 30, 40, 10, 20, 30, 40]

tuple1 = (10, 20, 30, 40)
tuple2 = tuple1 * 3
print(tuple2)  # (10, 20, 30, 40, 10, 20, 30, 40, 10, 20, 30, 40)

str1 = 'hello'
str2 = str1 * 6
print(str2)  # 'hellohellohellohellohellohello'

2026.7.11 19:43

74. 集合_定义集合

# 定义有内容的【可变集合】
s1 = {10, 20, 20, 30, 40, 40, 50, 60, 60, 70, 80, 90, 100}
s2 = {'你好', 'hello', '你好', 'atguigu', '北京'}
# s3 = {10, '你好', 1, True, 12.4}
s3 = {10, '你好', True, 1, 12.4}
print(type(s1), s1)
print(type(s2), s2)
print(type(s3), s3)
s2.add('尚硅谷')
print(s2)

# 定义有内容的【不可变集合】
s1 = frozenset({10, 20, 20, 30, 40, 40, 50, 60, 60, 70, 80, 90, 100})
s2 = frozenset({'你好', 'hello', '你好', 'atguigu', '北京'})
s3 = frozenset({10, '你好', True, 1, 12.4})
print(type(s1), s1)
print(type(s2), s2)
print(type(s3), s3)
# s2.add('尚硅谷')  # 报错

# frozenset 接受的参数，可以是任意可迭代对象，但最终返回的一定是【不可变集合】
s1 = frozenset([10, 20, 30, 40, 50])
s2 = frozenset((10, 20, 30, 40, 50))
s3 = frozenset('hello')
print(type(s1), s1)
print(type(s2), s2)
print(type(s3), s3)

# 定义空集合（可变集合）
s1 = set()
print(type(s1), s1)  # set set()

# 不能直接写{}来定义空集合，因为直接写{}定义的是: 空字典
s2 = {}
print(type(s2), s2)  # dict {}

# 定义空集合（不可变集合）
s3 = frozenset()
print(type(s3), s3)  # frozenset frozenset()

# 集合中不能嵌套【可变集合】，但可以嵌套【不可变集合】
# 通俗解释: 只有"不可变"的东西，才能安全的放进集合里
s1 = {10, 20, 30, 40, 50}
s2 = frozenset({100, 200, 300, 400, 500})
l1 = [666, 777, 888]
l2 = ('hello', 'atguigu', '北京')

# s3 = {11, 22, 33, s1}  # 运行报错
s3 = {11, 22, 33, s2}
# s3 = {11, 22, 33, l1}  # 运行报错
s3 = {11, 22, 33, l2}
print(s3)

75. 集合_增删改查

# 增
# add 方法: 向集合中添加元素
from unittest import result

s1 = {10, 20, 30, 40, 50}
s1.add(60)
print(s1)

# update 方法: 向集合中添加元素（必须传递可迭代对象，例如: 列表、元组、集合等）
s1 = {10, 20, 30, 40, 50}
s1.update([60, 70])
s1.update((80, 90))
s1.update({90, 100})
s1.update(range(300, 308))
print(s1)

# 删
# remove 方法: 从集合中移除元素（移除不存在的元素，会报错）
s1 = {10, 20, 30, 40, 50}
s1.remove(20)
print(s1)
# s1.remove(80)  # 运行报错

# discard 方法: 从集合中移除元素（移除不存在的元素，不会报错）
s1 = {10, 20, 30, 40, 50}
s1.discard(20)
print(s1)
s1.discard(80)  # 无报错

# pop 方法: 从集合中移除一个任意元素，返回值是移除的那个元素
s1 = {10, 20, 30, 40, 50}
s2 = {'你好', '北京', '尚硅谷', 'hello'}
result = s1.pop()
print(s1)
print(result)
result = s2.pop()
print(s2)
print(result)

# clear 方法: 清空集合
s1 = {10, 20, 30, 40, 50}
s1.clear()
print(s1)

# 改
# 使用 add + remove 的组合，来实现修改的效果
s1 = {10, 20, 30, 40, 50}
s1.remove(20)
s1.add(66)
print(s1)

# 查: 集合不能通过下标去读取元素，但能通过【成员运算符】去查看集合中是否包含指定元素
# 由于成员运算符适用于所有数据容器，所以我们会等所有数据容器都讲完以后，再说成员运算符
s1 = {10, 20, 30, 40, 50}
# s1[0]  # 报错
# 先提前感受一下成员运算符
result = 20 in s1
print(result)  # True
result = 20 not in s1
print(result)  # False

76. 集合_常用方法

# 集合A.difference(集合B):
# 作用: 找出集合A中，不同于集合B的元素（集合A 与 集合B 都不变，返回的是一个新的集合）
s1 = {10, 20, 30, 40, 50}
s2 = {30, 40, 50, 60, 70}
result = s1.difference(s2)
print(s1)
print(s2)
print(result)

# 集合A.difference_update(集合B):
# 作用: 从集合A中，删除集合B中存在的元素（集合A会被修改，集合B不会）
s1 = {10, 20, 30, 40, 50}
s2 = {30, 40, 50, 60, 70}
s1.difference_update(s2)
print(s1)  # {10, 20}
print(s2)
s1 = {10, 20, 30, 40, 50}
s2.difference_update(s1)
print(s1)
print(s2)  # {70, 80}

# 集合A.union(集合B)
# 作用: 合并两个集合，集合A 和 集合B 都不变，返回的是一个新的集合
s1 = {10, 20, 30, 40, 50}
s2 = {30, 40, 50, 60, 70}
result = s1.union(s2)
print(s1)
print(s2)
print(result)
result = s2.union(s1)
print(s1)
print(s2)
print(result)

# 集合A.issubset(集合B)
# 作用: 判断集合A是否为集合B的子集
# 如果 集合A的所有元素都在集合B中，那就返回True，否则返回False
s1 = {10, 20, 30, 40, 50}
s2 = {30, 40, 50, 60, 70}
s3 = {30, 40, 50}
result = s3.issubset(s1)
print(result)  # True
result = s3.issubset(s2)
print(result)  # True
result = s2.issubset(s1)
print(result)  # False

# 集合A.issuperset(集合B)
# 作用: 判断集合A是否是集合B的超集
# 如果集合A中，包含了集合B中的所有元素，那就返回True，否则返回False
s1 = {10, 20, 30, 40, 50}
s2 = {30, 40, 50, 60, 70}
s3 = {30, 40, 50}
result = s1.issuperset(s3)
print(result)  # True
result = s2.issuperset(s3)
print(result)  # True
result = s2.issuperset(s1)
print(result)  # False

# 集合A.isdisjoint(集合B)
# 作用: 判断集合A和集合B是否没有交集
# 如果没有交集，返回True；只要有一个公共元素，就返回False
s1 = {10, 20, 30, 40, 50}
s2 = {30, 40, 50, 60, 70}
s3 = {80, 90}
result = s1.isdisjoint(s3)
print(result)  # True
result = s1.isdisjoint(s2)
print(result)  # False

77. 集合_数学运算

s1 = {10, 20, 30, 40, 50, 60}
s2 = {40, 50, 60, 70, 80, 90}

# 并集
result = s1 | s2
print(result)  # {70, 40, 10, 80, 50, 20, 90, 60, 30}

# 交集
result = s1 & s2
print(result)  # {40, 50, 60}

# 差集
result = s1 - s2
print(result)  # {10, 20, 30}
result = s2 - s1
print(result)  # {80, 90, 70}

# 对称差集
result = s1 ^ s2
print(result)  # {70, 10, 80, 20, 90, 30}

78. 集合_循环遍历

s1 = {10, 20, 30, 40, 50, 60}

# 集合不能使用while循环遍历（以下是错误示例）
index = 0
while index < len(s1):
    print(index)
    # print(s1[index])  # 报错
    index += 1

# 集合可以使用for循环遍历
for item in s1:
    print(item)

79. 字典_定义字典

# 定义有内容的字段
d1 = {'张三': 72, '李四': 60, '王五': 85}
print(type(d1), d1)

# 字典中的key不能重复，若出现重复，则后写的会覆盖之前写的
d1 = {'张三': 72, '李四': 60, '王五': 85, '张三': 99}
print(d1)

# 定义空字典
d1 = {}
d2 = dict()
print(type(d1), d1)
print(type(d2), d2)

# 字典中的key必须是不可变类型，但value可以是任意类型
# 通俗理解: 只有不可变的东西，才能作为key
d1 = {'张三': 72, '李四': 60, '王五': 85}
d1 = {250: 72, '李四': 60, '王五': 85}
d2 = {('抽烟', '喝酒'): 72, '李四': 60, '王五': 85}
print(d1, d2)
# 错误示例: 将列表作为key，是不行的
# d2 = {['抽烟', '喝酒']: 72, '李四': 60, '王五': 85}  # 报错

# 字典可以嵌套
student_dict = {
    2025001: {'姓名': '张三', '年龄': 18, '成绩': 72, '爱好': ['抽烟', '喝酒', '烫头']},
    2025002: {'姓名': '李四', '年龄': 19, '成绩': 60, '爱好': ['唱歌', '跳舞', '打台球']},
    2025003: {'姓名': '王五', '年龄': 20, '成绩': 85, '爱好': ['学习', '看书', '打太极']}
}
print(student_dict)

80. 字典_增删改查

# 查询
from unittest import result

d1 = {'张三': 72, '李四': 60, '王五': 85}
# 直接取值，若键（key）不存在，会报错
result = d1['张三']
print(result)
# result = d1['奥特曼']  # 运行报错
# print(result)
# 安全取值，若键（key）不存在，会返回默认值（若没有设置默认值，则会返回None）
result = d1.get('奥特曼')
print(result)  # None
result = d1.get('奥特曼', '抱歉，key不存在! ')
print(result)  # 抱歉，key不存在!
result = d1.get('张三', '抱歉，key不存在! ')
print(result)  # 72

# 新增
d1 = {'张三': 72, '李四': 60, '王五': 85}
d1['赵六'] = 100
print(d1)

# 修改
d1 = {'张三': 72, '李四': 60, '王五': 85}
# 修改的写法，与新增的写法一样，若字典中有对应的key，就是修改；若没有，就是新增
d1['张三'] = 97
print(d1)

# 批量修改
d1.update({'李四': 40, '王五', 67})
print(d1)

# 删除
d1 = {'张三': 72, '李四': 60, '王五': 85}

# 删除指定key所对应的那组键值对
del d1['张三']
print(d1)

# 删除指定key所对应的那组键值对，并返回这个key所对应的值
result = d1.pop('张三')
print(result)  # 72

# pop方法可以设置默认值
# 默认值可以保证: 当要删除的key不存在的情况下，程序不会报错，并且返回这个默认值
# result = d1.pop('奥特曼')  # 运行报错
print(d1)
print(result)
result = d1.pop('奥特曼', '删除失败')
print(d1)
print(result)  # 删除失败
result = d1.pop('张三', '删除失败')
print(d1)
print(result)  # 73

# 清空字段
d1.clear()
print(d1)