开发Python程序读取.py文件生成内容报告，求替代inspect的更优库

Hey there! I’ve run into this exact issue before—using inspect forces you to import the target module, which can execute unwanted code, skip definitions that aren’t loaded at runtime, or break entirely if the module has missing dependencies. The good news is there are static code analysis tools that let you parse and inspect Python files without ever importing them. Here are the top options:

1. Python’s Built-in ast Module (No Extra Installs) #

The ast module is part of Python’s standard library and lets you parse Python code into an Abstract Syntax Tree (AST). You can traverse this tree to extract imports, functions, variables, and more—all without executing the target file. It’s perfect if you want a zero-dependency solution.

Example Code: #

import ast

def generate_code_report(file_path):
    with open(file_path, "r", encoding="utf-8") as f:
        tree = ast.parse(f.read())

    # Extract imported libraries
    imports = []
    for node in ast.walk(tree):
        if isinstance(node, ast.Import):
            for alias in node.names:
                imports.append(alias.name)
        elif isinstance(node, ast.ImportFrom):
            base_module = node.module or ""
            for alias in node.names:
                imports.append(f"{base_module}.{alias.name}".strip("."))

    # Extract function definitions (including async)
    functions = []
    for node in ast.walk(tree):
        if isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef)):
            functions.append(node.name)

    # Extract top-level variables (exclude function-scoped ones)
    variables = []
    for node in ast.walk(tree):
        if isinstance(node, ast.Assign):
            for target in node.targets:
                if isinstance(target, ast.Name):
                    # Check if the assignment is at module level
                    parent_scopes = [n for n in ast.walk(tree) if node in ast.iter_child_nodes(n)]
                    if not any(isinstance(p, (ast.FunctionDef, ast.AsyncFunctionDef)) for p in parent_scopes):
                        variables.append(target.id)

    return {
        "imported_libraries": imports,
        "defined_functions": functions,
        "top_level_variables": variables
    }

# Usage
report = generate_code_report("target_file.py")
print("Imports:", report["imported_libraries"])
print("Functions:", report["defined_functions"])
print("Variables:", report["top_level_variables"])

2. astroid (Third-Party, More User-Friendly AST) #

astroid is the library powering tools like Pylint. It builds on the standard ast module but provides a more intuitive API, with pre-built methods to access imports, functions, variables, and even type information. It handles edge cases (like complex scoping) better than raw ast and saves you from writing tons of custom traversal logic.

Example Code: #

First install it with pip install astroid, then:

import astroid

def analyze_with_astroid(file_path):
    module = astroid.parse_file(file_path)

    # Extract imports
    imports = [imp.name for imp in module.imports]
    imports.extend(f"{imp.modname}.{imp.name}" for imp in module.import_froms)

    # Extract functions
    functions = [func.name for func in module.nodes_of_class((astroid.FunctionDef, astroid.AsyncFunctionDef))]

    # Extract top-level variables
    variables = [var.name for var in module.nodes_of_class(astroid.AssignName) if var.scope() == module]

    return {
        "imports": imports,
        "functions": functions,
        "variables": variables
    }

# Usage
report = analyze_with_astroid("target_file.py")
print(report)

3. jedi (Third-Party, Smart Code Analysis) #

jedi is best known for powering code auto-completion in editors like VS Code, but it’s also great for static analysis. It can infer types, resolve references, and extract detailed information about imports, functions, and variables—all without executing code. It’s ideal if you need more than just basic extraction (like understanding how variables are used across the module).

Example Code: #

Install with pip install jedi, then:

import jedi

def analyze_with_jedi(file_path):
    script = jedi.Script.from_path(file_path)
    # Get only top-level names (exclude function-scoped)
    top_level_names = script.get_names(all_scopes=False)

    imports = []
    functions = []
    variables = []

    for name in top_level_names:
        if name.type == "import":
            imports.append(name.full_name)
        elif name.type == "function":
            functions.append(name.name)
        elif name.type == "variable":
            variables.append(name.name)

    return {
        "imports": imports,
        "functions": functions,
        "variables": variables
    }

# Usage
report = analyze_with_jedi("target_file.py")
print(report)

Why These Are Better Than inspect #

• No code execution: None of these tools import the target module, so you avoid side effects (like file creation, network calls, or runtime errors from missing dependencies).
• Complete static analysis: You get every definition written in the file, not just those that exist at runtime.
• Safer: No risk of running untrusted code (critical if you’re analyzing files from unknown sources).

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