如何在Python函数的指定操作执行前注入自定义代码？

完全可以实现，针对你给出的示例场景（在myList.remove调用前注入自定义逻辑），有多种成熟实现方案，最推荐无侵入的装饰器+临时猴子补丁方案，不需要修改原函数内部代码。

方案1：装饰器+临时实例方法替换（推荐，无副作用） #

核心逻辑是在装饰器的包裹逻辑中，临时替换传入参数的列表对象的remove方法，插入自定义逻辑，等原函数执行完成后再还原原始remove方法，既不会影响函数外的其他逻辑，也不会全局污染Python内置的list类型。
示例代码：

import functools

def inject_before_remove(func):
    @functools.wraps(func)
    def wrapper(myList, *args, **kwargs):
        # 保存当前列表实例原生的remove方法
        origin_remove = myList.remove

        # 定义插入了自定义逻辑的钩子方法
        def hooked_remove(value):
            # 下方写你需要注入的任意自定义逻辑
            print(f"[注入逻辑] 准备执行remove，待删除值：{value}")
            # 执行原生remove逻辑
            return origin_remove(value)

        # 临时替换当前实例的remove方法
        myList.remove = hooked_remove
        try:
            # 执行原函数
            return func(myList, *args, **kwargs)
        finally:
            # 无论函数执行是否报错，都还原原生方法，避免影响后续逻辑
            myList.remove = origin_remove
    return wrapper

# 用装饰器修饰原函数即可，原函数代码完全不需要改动
@inject_before_remove
def my_function(myList):
   myList.append(3)
   myList.remove(4)
   myList.append(5)

# 测试运行
if __name__ == "__main__":
    test_list = [1, 2, 4]
    my_function(test_list)
    print(test_list) # 输出：[1, 2, 3, 5]

注意：这个方案只能拦截传入的myList参数的remove调用，如果原函数内部自己新建了列表对象调用remove，该方案无法捕获。

方案2：全局修改内置类方法（仅适合临时调试，不推荐生产用） #

如果你需要拦截函数内部所有list.remove的调用（包括函数内部新建的列表对象的remove操作），可以临时替换全局list类的remove方法，但是一定要记得执行完后还原，否则会影响整个程序的所有列表操作：

import functools

def inject_all_remove(func):
    @functools.wraps(func)
    def wrapper(*args, **kwargs):
        origin_list_remove = list.remove
        def hooked_remove(self, value):
            print(f"[全局注入] 准备对列表{self}执行remove，待删除值：{value}")
            return origin_list_remove(self, value)
        list.remove = hooked_remove
        try:
            return func(*args, **kwargs)
        finally:
            list.remove = origin_list_remove
    return wrapper

这个方案风险很高，原函数执行期间触发的所有list.remove调用都会被拦截，包括第三方库内部的逻辑，非必要不要使用。

方案3：字节码修改（适合极端场景） #

如果你要拦截的不是对象方法，而是函数内部的任意普通操作（比如某个变量赋值、算术运算前插入逻辑），可以通过字节码修改库（比如bytecode）直接解析原函数的字节码，定位到目标操作的偏移位置，插入调用自定义逻辑的字节码指令，再重新生成函数对象。这种方案灵活度最高，但是实现复杂度高，对Python版本兼容性差，普通业务场景完全不需要考虑。

内容的提问来源于stack exchange，提问作者jtcnw