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

2026.7.14 11:38

学习路线

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

复习巩固总结(默写缺失) - 半小时

一、序列
1. 列表：[1,2,3]  list
- 增 append insert (extend)
- 删 del pop clear (remove)
- 方法 max min sum index count len sorted reversed (sort reverse)
- 遍历 while forin enumerate
    
2. 元组：(1,2,3)  tuple
- 方法 max min sum index count len sorted reversed
- 遍历 while forin
    
3. 字符串：'123'  str
- 方法 split len count index replace (sorted max min strip)
- 遍历 while forin

二、集合字典
1. 集合 {1,2,3}  set frozenset
- 增 add (update)
- 删 pop clear remove (discord)
- 方法 difference union difference_update (issubset issuperset isdisjoint)
- 运算 & | - ^
- 遍历 forin

2. 字典  {a:1,b:2}  dict
- 删 clear (del pop)
- 改 update
- 查 get
- 方法 keys values (items len)
- 遍历 forin

三、类
1. 类方法 @classmethod
2. 静态方法 @staticmethond
3. 常用方法 isinstance issubclass
4. 三种权限 a _b __c
5. getter @property
6. setter @a.setter
7. 魔法方法 __init__ __len__ __str__  __lt__ __gt__ __eq__ __getattr__
8. 抽象类 @abstractmethod

2026.07.14 15:35

Python 学习

107. 重新认识函数

# 1. 函数也是对象
a1 = 100                  # int类的实例对象
a2 = 'hello'              # str类的实例对象
a3 = [10, 20, 30]         # list类的实例对象
print(type(a1))
print(type(a2))
print(type(a3))

def welcome():            # function类的实例对象
    print('你好啊')

# print(type(welcome()))
print(type(welcome))

# 2. 函数可以动态添加属性
def welcome():
    print('你好啊')
welcome.desc = '这是一个打招呼的函数'
welcome.version = 1.0
print(welcome.desc)
print(welcome.version)

# 3. 函数可以赋值给变量
def welcome():
    print('你好啊')
welcome.desc = '这是一个打招呼的函数'
welcome.version = 1.0

say_hello = welcome
say_hello()
print(say_hello.desc)
print(say_hello.version)

# 4. 可变参数 vs 不可变参数
# 不可变参数
a = 666
def welcome(data):
    # print(data)
    print('data修改前', data, id(data))  # 666 地址1
    data = 888
    # print(data)
    print('data修改后', data, id(data))  # 888 地址2

print('函数调用前', a, id(a))  # 666 地址1
welcome(a)
# print(a)
print('函数调用后', a, id(a))  # 666 地址1

# 可变参数
a = [10, 20, 30]
def welcome(data):
    # print(data)
    print('data修改前', data, id(data))  # [10, 20, 30] 地址1
    data[2] = 99
    # print(data)
    print('data修改后', data, id(data))  # [10, 20, 99] 地址1

print('函数调用前', a, id(a))  # [10, 20, 30] 地址1
welcome(a)
print(a)
print('函数调用后', a, id(a))  # [10, 20, 99] 地址1

# 5. 函数也可以作为参数
def welcome():
    print('你好啊')

def caller(f):
    print('caller函数调用了')
    f()

caller(welcome)

# 6. 函数也可以作为返回值
def welcome():
    print('你好啊')
    def show_msg(msg):
        print(msg)
    return show_msg

# welcome()
result = welcome()
# print(result) 
# result()
result('尚硅谷')
# show_msg('尚硅谷')  # 报错
welcome()('尚硅谷')

108. 多返回值_参数的打包与解包

# 一、函数的多返回值
def calculate(x, y):
    res1 = x + y
    res2 = x - y
    return res1, res2
    # return (res1, res2)
    # return [res1, res2]

result = calculate(30, 10)
print(result)  # (40, 20) -> [40, 20]

r1, r2 = calculate(30, 10)
print(r1, r2)  # 40 20

# 二、参数的打包与解包

# 1. 打包接收参数:
# *args     : 打包所有的位置参数（会形成一个元组）
# **kwargs   : 打包所有的关键字参数（会形成一个字典）
def show_info(*args, **kwargs):
# def show_info(*qwe, **asd):
    print(args)
    # print(qwe)
    print(kwargs)
    # print(asd)

show_info(10, 20, 30, name='张三', age=18, gender='男')

# 2. 解包传递参数
# *变量名    : 将元组拆解成一个一个独立的位置参数
# **变量名   : 将字典拆解成一个一个 key=value 形式的关键字参数
def show_info(num1, num2, num3, name, age, gender):
    print(num1, num2, num3)
    print(name, age, gender)

show_info(10, 20, 30, '张三', 18, '男')

nums = (10, 20, 30)
person = {'name': '张三', 'age': 18, 'gender': '男'}

show_info(nums[0], nums[1], nums[2], person['name'], person['age'], person['gender'])
show_info(*nums, **person)

# 3. 打包接收参数 和 解包传递参数 一起使用
def show_info(*args, **kwargs):
    print(args)
    print(kwargs)

nums = (10, 20, 30)
person = {'name': '张三', 'age': 18, 'gender': '男'}
show_info(*nums, **person)

109. 高阶函数

# 高阶函数: 当一个函数是【参数是函数】或者【返回值是函数】那该函数就是【高阶函数】

# 高阶函数的意义:
# 1. 代码复用性高: 可以吧行为“独立出去”，传入不同函数实现不同逻辑
# 2. 能让函数更灵活，更通用
# 3. 高阶函数是: 装饰器、闭包的基础（后面会讲）

def info(msg):
    return '[提示]: ' + msg

def warn(msg):
    return '[警告]: ' + msg

def error(msg):
    return '[错误]: ' + msg

def log(func, text):
    print(func(text))

log(info, '文件保存成功! ')
log(warn, '磁盘空间不足! ')
log(error, '该用户不存在! ')

110. 条件表达式

# 表达式: 执行后能得到值的代码，就是表达式（表达式最终会形成一个值，可以写在任何需要值的地方）
# 3 + 5
a1 = 3 + 5
a2 = 'abc' * 3
# a3 = 5 > 3
print(5 > 3)
# a4 = 'y' in 'python'
int('y' in 'python')  # 1
a5 = len('hello')

# 条件表达式: 根据条件的真假，在两个值中二选一的表达式（又称: 三元表达式、三目运算符）
# age = 18
# age = 15
age = 21
text = 'xx'

# 传统的if-else去写:
if age >= 18:
    text = '成年'
else:
    text = '未成年'
print(text)

# 条件表达式去写: 值1 if 条件 else 值2
text = '成年' if age >= 18 else '未成年'
print(text)

# 条件表达式的使用场景: 简单的二选一场景
rain = True
eat = '外卖' if rain else '出去吃'

# is_vip = True
is_vip = False
discount = 0.8 if is_vip else 1.0

# is_login = True
is_login = False
msg = '欢迎回来! ' if is_login else '请先登录! '
# msg = '欢迎回来! ' if is_login else for item in range(10)  # 错误写法
# msg = '欢迎回来! ' if is_login else for item in print('哈哈哈')

print(eat)
print(discount)
print(msg)

result = print(100)
print(result)

111. 匿名函数

# 概念: 所谓【匿名函数】，就是没有名字的函数，它无需使用 def 关键字去定义
# 语法: Python 中使用 lambda 关键字来定义【匿名函数】，格式为: lambda 参数: 表达式
# 使用场景: 当一个函数只能用一次、只做一点点小事，使用匿名函数会更简洁

# 使用普通函数实现计算效果
def add(x, y):
    return x + y

def sub(x, y):
    return x - y

def calculate(func, a, b):
    print(f'计算结果为: {func(a, b)}')

calculate(add, 30, 10)
calculate(sub, 30, 10)

# 匿名函数
add = lambda x, y: x + y
# add = lambda x, y: return x + y  # 语法报错
result = add(30, 10)
print(result)

add2 = lambda x: x + x
add3 = lambda: '我是add3函数'
result2 = add2(30)
result3 = add3()
print(result2, result3)

# 使用匿名函数实现计算效果
def calculate(func, a, b):
    print(f'计算结果为: {func(a, b)}')

calculate(lambda x, y: x + y, 30, 10)
calculate(lambda x, y: x - y, 30, 10)

# 注意点
# 1. 只能写一行，不能写多行代码
# 2. 不能写代码块（if、for、while）
# 3. 冒号右边必须是表达式，且只能写一个表达式
# 4. 表达式结果自动作为返回值

# 语法错误
# is_adult = lambda age:
#     if age >= 18:
#         return '成年'
#     else:
#         return '未成年'

# 语法错误
# is_adult = lambda age: if age >= 18: return '成年' else: return '未成年'

# 运行报错
# is_adult = lambda age: if age >= 18: age + 1, age + 2
# is_adult(19)

is_adult = lambda age: '成年' if age >= 18 else '未成年'
print(is_adult(18))
print(is_adult(13))

112. 数据处理_map函数

# map函数: 对一组数据中的每一个元素，统一执行某种操作（加工），并生成一组新数据
# 语法格式: map(操作函数，可迭代对象)

# 统一数据处理
nums = [10, 20, 30, 40]
def double(x):
    return x * 2

# map函数的返回值是一个迭代器对象，需要我们自己去手动遍历，或者手动类型转换
# map(double())
result = map(double, nums)
print(result)  # <map object at 0x000001E5AFD37D90>
print(list(result))  # [20, 40, 60, 80]
for item in result:
    print(item)

result = map(lambda x: x * 2, nums)
print(list(result))  # [20, 40, 60, 80]
print(nums)  # [10, 20, 30, 40]

# 字符串转换
names = ('python', 'java', 'js')

str1 = 'hello'
result = str1.upper()
print(result)

result = map(lambda x: x.upper(), names)
# print(result)
print(tuple(result))
# print(list(result))
# print(set(result))
print(names)

# 类型转换
str_number = {'1', '2', '3'}
result = map(int, str_number)
print(set(result))
print(str_number)

# 注意点:
# 1. 延迟执行: map 不会立即计算，只有在“需要结果”才执行计算
# 2. 返回的是迭代器对象，且一旦遍历完成，就会被“耗尽”
# 3. map 不会影响元素数量
nums = [10, 20, 30, 40]
result = map(lambda x: x * 2, nums)
# print(result)  # 此时未执行计算
# print(list(result))  # 此时执行计算  [20, 40, 60, 80]
# print(list(result))  # []
nums2 = list(result)
print(nums2)
print(nums2)
print(nums2)
print(nums2)

result = list(map(lambda x: x * 2, nums))
print(result)
print(result)
print(result)
print(result)

113. 数据处理_filter函数

# filter函数: 从一组数据中，筛选出符合条件的元素（过滤），并组成一组新数据
# 语法格式: filter(过滤函数, 可迭代对象)

# 筛选数值
nums = [10, 20, 30, 40, 50]
result = filter(lambda n: n > 30, nums)
print(result)  # <filter object at 0x000001F5259A6410>
print(list(result))  # [40, 50]

result = filter(lambda n: False, nums)
print(list(result))  # []

result = filter(lambda n: True, nums)
print(list(result))  # [10, 20, 30, 40, 50]

print(nums)  # [10, 20, 30, 40, 50]

# 筛选成年人
persons = [
    {'name': '张三', 'age': 15, 'gender': '男'},
    {'name': '李四', 'age': 16, 'gender': '女'},
    {'name': '王五', 'age': 17, 'gender': '男'},
    {'name': '李华', 'age': 18, 'gender': '女'},
    {'name': '赵六', 'age': 19, 'gender': '女'},
    {'name': '孙七', 'age': 20, 'gender': '男'},
]
# result = filter(lambda p: p >= 18, persons)
result = filter(lambda p: p['age'] >= 18, persons)
print(list(result))

# 过滤一下非法字符串
names = ['张三', '', '李四', None, '王五']
# result = filter(lambda n: n != '', names)
result = filter(lambda n: n, names)
# result = filter(lambda n: True, names)
print(list(result))
# print(list(result))  # []

# 注意点
# 1. 延迟执行: filter 不会立刻筛选，只有在“需要结果”才执行计算
# 2. 返回的是迭代器对象，且一旦遍历完成，就会被“耗尽”
# 3. filter可能会影响元素数量

# filter函数的特殊用法: 如果不传递过滤函数，那么会自动过滤掉“假值”
data = [0, 1, '', 'hello', [], (), 5]
# result = filter(data)
result = filter(None, data)
print(list(result))  # [1, 'hello', 5]

114. 数据处理_sorted函数

# sorted函数: 对一组数据进行排序，返回一组新数据
# 语法格式: sorted(可迭代对象, key=xxx, reverse=xxx)

# 数字排序
nums = [30, 40, 20, 10]
result = sorted(nums)
print(result)  # [10, 20, 30, 40]
result = sorted(nums, reverse=True)
print(result)  # [40, 30, 20, 10]

# 按照字符串的长度去排序
names = ['python', 'sql', 'java']
result = sorted(names)
print(result)  # Unicode编码排序  ['java', 'python', 'sql']
print(ord('j'))  # 106
print(ord('p'))  # 112
print(ord('s'))  # 115
result = sorted(names, key=lambda n: len(n))
print(result)  # ['sql', 'java', 'python']
result = sorted(names, key=lambda n: len(n), reverse=True)
print(result)  # ['python', 'java', 'sql']
result = sorted(names, key=len, reverse=True)
print(result)  # ['python', 'java', 'sql']
result = sorted(names, key=len)
print(result)  # ['sql', 'java', 'python']

# 根据字典中的某个字段进行排序
persons = [
    {'name': '张三', 'age': 15, 'gender': '男'},
    {'name': '李四', 'age': 17, 'gender': '女'},
    {'name': '王五', 'age': 19, 'gender': '男'},
    {'name': '李华', 'age': 20, 'gender': '女'},
    {'name': '赵六', 'age': 18, 'gender': '女'},
    {'name': '孙七', 'age': 16, 'gender': '男'},
]
# result = sorted(persons)  # 报错
# result = sorted(persons['age'])  # 报错
result = sorted(persons, key=lambda p: p['age'])
print(result)
result = sorted(persons, key=lambda p: p['age'], reverse=True)
print(result)

# 我们之前讲的max函数、min函数，也可以传递key参数，用于设置筛选依据
nums = [10, 20, 30, 40, 50]
result1 = max(nums)
result2 = min(nums)
print(result1)
print(result2)

# result1 = max(persons)  # 报错
result1 = max(persons, key=lambda p: p['age'])
print(result1)
result2 = min(persons, key=lambda p: p['age'])
print(result2)

115. 数据处理_reduce函数

# reduce 函数: 将一组数据不断“合并”，最终归并成一个结果
# 语法格式: reduce(合并函数, 可迭代对象, 初始值)
# 备注: reduce 函数需要从 functools 模块中引入才能使用

# 从 functools 模块中引入 reduce
from functools import reduce

# 数据统计
nums = [1, 2, 3, 4, 5]

def count(a, b):
# def count(a, b, c):
    print('count函数调用了', a, b)
    return a + b
    # return a + b + c

result = reduce(count, nums)
print(result)  # 15

result = reduce(count, nums， 10)
print(result)  # 25

result = reduce(lambda a, b: a + b, nums, 10)
print(result)  # 25

result = reduce(lambda a, b: a * b, nums, 10)
print(result)  # 1200

# 字符串拼接
str_list = ['ab', 'cd', 'ef']
result = reduce(lambda a, b: a + b, str_list)
print(result)  # 'abcdef'

2026.07.14 21:43

116. 列表推导式

# 列表推导式: 用一条简洁语句，从可迭代对象中，生成新列表的语法结构
# 备注: 列表推导式本质上是对 for循环 + append() 的一种简写形式
# 语法格式: [表达式 for 变量 in 可迭代对象]

# 需求: 让列表中每个元素，都变为原来的2倍，得到是一个新的列表

# 方式一: 用map函数
nums = [10, 20, 30, 40]
result = list(map(lambda n: n * 2, nums))
print(result)

# 方式二: 用 for循环 + append()
nums = [10, 20, 30, 40]
result = []
for n in nums:
    result.append(n * 2)
print(result)

# 方式三: 用列表推导式
nums = [10, 20, 30, 40]
result = [n * 2 for n in nums]
print(result)

# 带条件的列表推导式
nums = [10, 20, 30, 40]
result = [n * 2 for n in nums if n > 20]
print(result)

# 字典推导式
names = ['张三', '李四', '王五']
scores = [60, 70, 80]
# result = {n for n in names}
# result = {n: 90 for n in names}
# result = {n: 90 for n in len(names)}
result = {names[i]: scores[i] for i in range(len(names))}
print(result)

# 集合推导式
names = ['张三', '李四', '王五']
result = {n + '! ' for n in names}
print(result)

names = ['张三', '李四', '王五']
# Python中没有元组推导式，下面这种写法叫: 生成器（后面会仔细讲）
result = (n + '! ' for n in names)
print(result)