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

2026.7.16 15:15

学习路线

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

复习巩固总结

一、集合字典
1. 集合 {1,2,3}  set frozenset
- 增 add update
- 删 pop clear remove discord
- 方法 difference union difference_update issubset issuperset isdisjoint

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

二、类
1. 类方法 @classmethod
2. 静态方法 @staticmethond
3. 抽象类 @abstractmethod

三、其他
1. 推导式: [表达式 for 变量 in 可迭代对象 if 筛选条件]
2. 常用内置函数: print input int float str bool list tuple set dict abs round pow divmod max min sum map filter reduce sorted len range enumerate zip type isinstance issubclass id all any ord chr
3. 拷贝: copy.copy copy.deepcopy
4. 闭包: 函数嵌套、【内层函数】访问【外层函数】的变量、【外层函数】返回【内层函数】

Python 学习

120. 函数装饰器

# 装饰器:
# 1. 装饰器是一种【可调用对象】（通常是函数），它能接收一个函数作为参数，并且会返回一个新函数
# 2. 装饰器可以在不修改原函数代码的前提下，增强或改变原函数的功能

def say_hello(func):
    def wrapper(*args, **kwargs):
        print('你好，我要开始计算了')
        return func(*args, **kwargs)
    return wrapper

# def add(x, y):
@say_hello  # 等价于 add = say_hello(add)
def add(x, y, z):
    # print('你好，我要开始计算了')
    # res = x + y
    res = x + y + z
    # print(f'{x}和{y}相加的结果是: {res}')
    print(f'{x}和{y}和{z}相加的结果是: {res}')
    return res
# 正常调用add函数
# result = add(10, 20)
# print(result)

# 在不修改add函数的前提下，给add函数增加一些额外的功能，例如: 计算前先打印一句欢迎语
# 实现方案: 使用装饰器
# add_pro = say_hello(add)
# result = add_pro(10, 20)
# print(result)

# def say_hello(func):
#     # def wrapper():
#     # def wrapper(a, b):
#     # def wrapper(a, b, c):
#     def wrapper(*args, **kwargs):
#         # ***********
#         print('你好，我要开始计算了')
#         # func(a, b)
#         # return
#         # res = func(a, b)
#         # return res
#         # return func(a, b)
#         # return func(args, kwargs)
#         return func(*args, **kwargs)
#     return wrapper

# result = add(10, 20)
# result = add(10, 20, 30)
# print(result)

# add_pro = say_hello(add)
# 下面这行代码，是手动装饰，写起来会麻烦一些，不推荐，推荐: @装饰器名
# add = say_hello(add)
# result = add_pro(10, 20)
# result = add_pro(10, 20, 30)
result = add(10, 20, 30)
print(result)

# 关键点:
# 1. 接收被装饰的函数、同时返回新的函数（wrapper）
# 2. 装饰器“吐出来”的是 wrapper 函数，以后别人调用的也是 wrapper 函数
# 3. 为了保证参数的兼容性，wrapper 函数要通过 *args 和 **kwargs 接收参数
# 4. wrapper 函数中主要做的是: 调用原函数（被装饰的函数）、执行其他逻辑，但要记得将原函数的返回值 return 出去

# 进阶: 带参数的装饰器（三层嵌套，外层接收配置、中间层接收函数、内层接收具体参数）
# def say_hello(func):
def say_hello(msg):
    def outer(func):
        def wrapper(*args, **kwargs):
            # print('你好，我要开始计算了')
            print(f'你好，我要开始{msg}计算了')
            return func(*args, **kwargs)
        return wrapper
    return outer

# @say_hello
@say_hello('加法')  # 运行报错 -> 正常
def add(x, y, z):
    res = x + y + z
    print(f'{x}和{y}和{z}相加的结果是: {res}')
    return res

result = add(10, 20, 30)
print(result)

# @say_hello
@say_hello('减法')  # 运行报错 -> 正常
def sub(x, y):
    res = x - y
    print(f'{x}和{y}相减的结果是: {res}')
    return res

result = sub(20, 10)
print(result)

# 进阶: 多个装饰器一起使用
# def say_hello(func):
def test1(func):
    print('我是test1装饰器')
    def wrapper(*args, **kwargs):
        # print('你好，我要开始计算了')
        # print('我是test1追加的逻辑')
        # return func(*args, **kwargs)
        res = func(*args, **kwargs)
        print('我是test1追加的逻辑')
        return res
    return wrapper

def test2(func):
    print('我是test2装饰器')
    def wrapper(*args, **kwargs):
        # print('我是test2追加的逻辑')
        # return func(*args, **kwargs)
        res = func(*args, **kwargs)
        print('我是test2追加的逻辑')
        return res
    return wrapper

@test1
@test2
# 相当于 add = test1(test2(add))
def add(x, y):
    res = x + y
    print(f'{x}和{y}相加的结果是{res}')
    return res

result = add(10, 20)
print(result)

# 打印:
# 我是test2装饰器
# 我是test1装饰器
# 我是test1追加的逻辑
# 我是test2追加的逻辑
# 10和20相加的结果是30

# 打印:
# 我是test2装饰器
# 我是test1装饰器
# 10和20相加的结果是30
# 我是test2追加的逻辑
# 我是test1追加的逻辑

# 实际应用: 在不改变原函数的前提下，给函数统一加上: 日志、计时、校验、缓存 等功能

2026.07.16 21:43

121. 类装饰器

# 类装饰器
# 1. 包含 __call__ 方法的类，就是类装饰器
# 2. 像调用函数一样，去调用类装饰器的实例对象，就会触发 __call__ 方法的调用
# 3. __call__ 方法通常接收一个函数作为参数，并且会返回一个新函数

class SayHello:
    def __call__(self, func):
        def wrapper(*args, **kwargs):
            print('你好，我要开始计算了')
            return func(*args, **kwargs)
        return wrapper

# @SayHello
# 使用@语法糖使用类装饰器
@SayHello()
def add(x, y):
    res = x + y
    print(f'{x}和{y}相加的结果是{res}')
    return res

# 正常调用add函数
result = add(10, 20)
print(result)

# 使用 SayHello 去装饰 add 函数（手动装饰）
say = SayHello()
# add_pro = say(add)
# result = add_pro(10, 20)
add = say(add)
result = add(10, 20)
print(result)

# 带参数的类装饰器
class SayHello:
    def __init__(self, msg):
        self.msg = msg

    def __call__(self, func):
        def wrapper(*args, **kwargs):
            # print('你好，我要开始计算了')
            print(f'你好，我要开始{self.msg}计算了')
            return func(*args, **kwargs)
        return wrapper

@SayHello('加法')
def add(x, y):
    res = x + y
    print(f'{x}和{y}相加的结果是{res}')
    return res

result = add(10, 20)
print(result)

# 多个类装饰器的使用
class Test1:
    def __call__(self, func):
        def wrapper(*args, **kwargs):
            print('我是Test1追加的逻辑')
            return func(*args, **kwargs)
        return wrapper

class Test2:
    def __call__(self, func):
        def wrapper(*args, **kwargs):
            print('我是Test2追加的逻辑')
            return func(*args, **kwargs)
        return wrapper

@Test1()
@Test2()
def add(x, y):
    res = x + y
    print(f'{x}和{y}相加的结果是{res}')
    return res

result = add(10, 20)
print(result)

# 打印
# 我是Test1追加的逻辑
# 我是Test2追加的逻辑
# 10和20相加的结果是30