如何确定被调用的具体函数/方法/对象？实现调用行号获取程序

嘿，我来给你梳理下怎么搞定这个问题——精准找到代码里被调用的函数/方法，还能写出程序获取调用的精确行号和对应的定义。

一、怎么精准确定被调用的函数/方法/对象？ #

首先得搞懂Python的核心查找规则，还有方法解析的逻辑：

• 全局/局部调用：比如直接写method(x,y)，Python会按LEGB规则查找：先找局部作用域（Local），再嵌套作用域（Enclosing），然后全局作用域（Global），最后内置作用域（Built-in）。
• 实例/类方法调用：比如y.method()，Python会先检查实例y有没有绑定这个方法，没有的话去它的类A里找，再沿着继承链往上找。这里要敲个重点：Python不支持方法重载，你示例里class A定义了两个method，其实第一个会被第二个完全覆盖，调用y.method()还会因为参数不够报错，这点要注意哦。

要做到精准定位，最靠谱的方式是用**抽象语法树（AST）**解析代码——AST能清晰展示代码的结构、调用节点和定义节点的关联，比简单的字符串匹配靠谱太多。

二、编写程序实现需求 #

我们可以用Python自带的ast模块来实现你要的someMethod函数，它能深度解析代码结构，找到调用对应的定义和行号。

示例代码实现 #

import ast
from typing import Optional, Tuple

def someMethod(file_path: str, target_code: str) -> Optional[Tuple[str, int]]:
    # 读取目标Python文件内容
    with open(file_path, 'r', encoding='utf-8') as f:
        code_content = f.read()
    code_lines = code_content.splitlines()

    # 第一步：找到目标代码所在的行号
    target_line = None
    for idx, line in enumerate(code_lines, 1):
        if target_code.strip() in line.strip():
            target_line = idx
            break
    if not target_line:
        return None

    # 第二步：解析代码为AST树，定位调用节点
    tree = ast.parse(code_content)
    call_node = None

    class CallFinder(ast.NodeVisitor):
        def visit_Call(self, node):
            nonlocal call_node
            if node.lineno == target_line:
                call_node = node
            self.generic_visit(node)

    CallFinder().visit(tree)
    if not call_node:
        return None

    # 提取调用的函数/方法名称
    def get_call_name(node):
        if isinstance(node, ast.Name):
            return node.id
        elif isinstance(node, ast.Attribute):
            return node.attr
        return None

    call_name = get_call_name(call_node.func)
    if not call_name:
        return None

    # 第三步：遍历AST找到对应的函数定义节点
    def_def = None
    # 先给类内的函数节点添加父类标记，方便区分实例方法
    class ParentSetter(ast.NodeVisitor):
        def visit_ClassDef(self, node):
            for item in node.body:
                if isinstance(item, ast.FunctionDef):
                    item.parent = node
            self.generic_visit(node)

    ParentSetter().visit(tree)

    class DefFinder(ast.NodeVisitor):
        def visit_FunctionDef(self, node):
            nonlocal def_def
            if node.name == call_name:
                # 匹配参数数量（处理同名函数/方法的区分）
                call_arg_count = len(call_node.args)
                def_arg_count = len(node.args.args)
                # 实例方法默认带self参数，要减去1
                if hasattr(node, 'parent'):
                    def_arg_count -= 1
                if def_arg_count == call_arg_count:
                    def_def = node
            self.generic_visit(node)

    DefFinder().visit(tree)
    if not def_def:
        return None

    # 提取定义的代码片段和行号
    def_start = def_def.lineno
    def_end = def_def.end_lineno
    def_code = '\n'.join(code_lines[def_start-1:def_end])
    return (def_code, def_start)

# 测试示例（假设你的python.py已修正语法错误）
# 修正后的python.py示例内容：
# class A:
#     def method(self):
#         return None
#     def method(self,x,y):
#         return(y)
# y = A()
# a = y.method()
# def method(x,y):
#     return y
# method(x,y)

# 调用测试
result1 = someMethod('python.py', 'a = y.method()')
if result1:
    print(f"找到对应定义：\n{result1[0]}\n行号：{result1[1]}")

result2 = someMethod('python.py', 'method(x,y)')
if result2:
    print(f"找到对应定义：\n{result2[0]}\n行号：{result2[1]}")

代码说明 #

• 用ast.parse把代码转成AST树，这是精准分析的核心基础。
• 通过自定义NodeVisitor遍历AST，先锁定目标代码所在行的调用节点。
• 再次遍历AST找到对应的函数定义，通过参数数量匹配区分同名函数（毕竟Python不支持重载）。
• 最后提取定义的代码片段和起始行号返回。

注意事项 #

• 你的原始示例代码有几个语法问题：class A的实例方法没加self参数，y = A(1,2)会因为A没有__init__方法报错，使用前要先修正这些问题哦。
• 如果要处理嵌套函数、继承类方法等复杂场景，可以扩展DefFinder的匹配逻辑来适配。

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