元类能否无需赋值操作拦截类作用域中的裸表达式？

当然可以做到！虽然Python默认会丢弃类体里未赋值的裸表达式结果，但我们可以通过AST代码改写的取巧方式，在类代码执行前修改逻辑，自动捕获这些表达式的结果，无需手动赋值给_这类变量。

核心思路 #

类体的代码在执行前会被解析为抽象语法树（AST），我们可以用元类配合AST转换器，把所有裸表达式语句（比如1、2+3）自动替换为“将结果添加到指定列表”的操作，这样就能在类创建时收集到所有裸表达式的输出。

实现代码 #

import ast
import inspect
import sys

class CaptureExprTransformer(ast.NodeTransformer):
    def __init__(self, var_name='_captured_exprs'):
        self.var_name = var_name

    def visit_Expr(self, node):
        # 把裸表达式转成「向捕获列表添加结果」的语句
        append_call = ast.Call(
            func=ast.Attribute(
                value=ast.Name(id=self.var_name, ctx=ast.Load()),
                attr='append',
                ctx=ast.Load()
            ),
            args=[node.value],
            keywords=[]
        )
        return ast.Expr(value=append_call)

class CapturingMetaclass(type):
    @classmethod
    def __prepare__(metacls, name, bases):
        namespace = super().__prepare__(name, bases)
        # 在类命名空间里初始化捕获用的列表
        namespace['_captured_exprs'] = []
        return namespace

    def __new__(cls, name, bases, namespace):
        # 获取当前类所在模块的源代码
        module = sys.modules[namespace['__module__']]
        try:
            source = inspect.getsource(module)
            tree = ast.parse(source)
        except (TypeError, OSError):
            # 处理无法获取源代码的情况（比如交互式环境）
            print("无法捕获表达式：无法获取类源代码")
            return super().__new__(cls, name, bases, namespace)

        # 找到当前类的AST节点
        target_class = None
        for node in ast.walk(tree):
            if isinstance(node, ast.ClassDef) and node.name == name:
                target_class = node
                break

        if target_class:
            # 转换类体中的所有裸表达式
            transformer = CaptureExprTransformer()
            transformer.visit(target_class)
            ast.fix_missing_locations(target_class)

            # 重新编译并执行修改后的类体代码
            exec(compile(tree, filename=inspect.getsourcefile(module), mode='exec'), module.__dict__, namespace)

        # 取出捕获到的表达式结果
        captured = namespace.pop('_captured_exprs', [])
        print(f"捕获到的裸表达式结果：{captured}")

        # 创建并返回类对象
        return super().__new__(cls, name, bases, namespace)

# 测试示例
class MyClass(metaclass=CapturingMetaclass):
    # 这些裸表达式会被自动捕获
    1 + 2
    "Hello, World!"
    [1, 2, 3]

    # 普通赋值语句不受影响
    x = 10
    y = "test"

代码说明 #

1. AST转换器：CaptureExprTransformer会遍历类的AST树，把所有Expr类型的节点（也就是裸表达式）替换为调用列表append方法的语句。
2. 元类准备阶段：__prepare__方法在类命名空间里初始化一个列表，用来存储捕获到的表达式结果。
3. 类创建阶段：__new__方法获取类的源代码，修改AST后重新执行类体，最后取出捕获到的结果并处理。

注意事项 #

• 这个方法依赖于能获取到类的源代码，如果类是通过exec动态生成的，或者在交互式环境中定义，可能无法正常工作。
• 转换器只会处理类体顶层的裸表达式，嵌套在函数、内部类里的裸表达式不会被捕获（如果需要可以修改AST遍历逻辑）。
• 属于hack性质的实现，生产环境中如果可以，更推荐用你之前提到的_ = 表达式的方式，更简洁可靠。

内容的提问来源于stack exchange，提问作者Olivier Melançon