如何获取Python程序中调用指定函数的函数列表（海量函数场景）

嘿，这个问题挺实用的！在Python里要找出调用某个指定函数的所有函数，尤其是当代码量很大的时候，得选对方法才高效。我来给你拆解一下可行的方案，重点说最优的实现方式。

当你有大量函数需要分析时，静态分析是最高效的选择——它不需要运行代码，直接通过解析Python的抽象语法树（AST）就能找出所有直接调用目标函数的函数。这种方法速度快，能覆盖整个代码库的所有可能调用，不会因为函数没被执行而遗漏。

下面是用ast模块实现的示例代码：

import ast
import inspect

def find_all_callers(target_func_name):
    # 获取当前模块的源代码（如果是其他模块，可以用inspect.getsource(module)）
    caller_source = inspect.getsource(inspect.currentframe().f_back)
    # 解析源代码生成AST树
    ast_tree = ast.parse(caller_source)
    
    callers = []
    
    # 定义AST访问器，遍历所有函数和调用节点
    class CallTrackingVisitor(ast.NodeVisitor):
        def __init__(self):
            self.current_function = None
        
        def visit_FunctionDef(self, node):
            # 进入函数定义时，记录当前函数名
            self.current_function = node.name
            # 继续遍历函数内部的所有节点
            self.generic_visit(node)
            # 离开函数后重置当前函数名
            self.current_function = None
        
        def visit_Call(self, node):
            # 检查当前调用的函数是否是目标函数
            if isinstance(node.func, ast.Name) and node.func.id == target_func_name:
                # 如果当前在某个函数内部，且该函数还没被记录，就添加到列表
                if self.current_function and self.current_function not in callers:
                    callers.append(self.current_function)
            # 继续遍历调用节点的子节点
            self.generic_visit(node)
    
    # 启动AST遍历
    visitor = CallTrackingVisitor()
    visitor.visit(ast_tree)
    return callers

# 测试你的示例代码
def myFunc(): pass
def a(): myFunc()
def b(): myFunc()
def c(): a()  # 这个不会被统计，因为c是间接调用myFunc

print(find_all_callers("myFunc"))  # 输出: ['a', 'b']

扩展说明 #

如果需要分析多个模块的代码，只需要把inspect.getsource的参数换成对应的模块对象（比如import my_module，然后用inspect.getsource(my_module)），就能批量扫描整个项目的调用关系。

如果你只关心实际运行时调用目标函数的函数，可以用动态追踪的方法。这种方法通过设置追踪钩子，在函数被调用时记录调用者，但缺点是只有被执行过的函数调用才会被捕获，没运行的函数调用会被遗漏。

示例代码如下：

import sys

def track_runtime_callers(target_func):
    callers = set()
    
    def trace_hook(frame, event, arg):
        if event == 'call':
            # 获取当前被调用的函数名
            current_func_name = frame.f_code.co_name
            # 获取调用者的函数信息
            caller_frame = frame.f_back
            if caller_frame:
                caller_func_name = caller_frame.f_code.co_name
                # 如果当前调用的是目标函数，记录调用者
                if current_func_name == target_func.__name__:
                    callers.add(caller_func_name)
        return trace_hook
    
    # 启动追踪
    sys.settrace(trace_hook)
    return callers

# 测试
def myFunc(): pass
def a(): myFunc()
def b(): myFunc()

callers = track_runtime_callers(myFunc)
# 必须执行函数才能捕获调用关系
a()
b()
# 停止追踪
sys.settrace(None)

print(list(callers))  # 输出: ['a', 'b']

当程序中存在大量函数时，静态分析（基于AST）是最优实现方式——它不需要运行代码，能快速、全面地找出所有直接调用目标函数的函数，效率和覆盖范围都远优于动态追踪。如果你的需求是追踪运行时的实际调用，再考虑动态方法。

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