如何计算百万行DataFrame中Eqn列的表达式值？

这个问题我碰到过好多次，尤其是处理大规模数据的时候，得兼顾正确性和效率，给你几个不同场景下的解决方案：

基础实现（适合小数据量，注意安全风险） #

如果你的数据量不大，或者只是快速验证结果，用apply配合Python内置的eval就能搞定。不过要注意：eval会执行字符串里的任意代码，只有当Eqn列的表达式完全可信（比如自己生成的）时才能用，否则会有代码注入风险。

代码示例：

import pandas as pd

# 模拟你的数据
df = pd.DataFrame({
    'A': [12, 32, 56],
    'B': [3, 8, 12],
    'C': [4, 9, 2],
    'Eqn': ['A+B', 'B*C', 'A+B*C']
})

# 新增Result列，计算每行的表达式
df['Result'] = df.apply(
    lambda row: eval(row['Eqn'], {}, row.to_dict()),
    axis=1
)

print(df)

这里row.to_dict()把当前行的A/B/C转成字典，作为eval的局部变量，这样表达式里的A、B、C就能对应到当前行的数值了。

高效优化方法（适合百万级数据量） #

上面的逐行apply在百万行数据下会很慢，推荐用numexpr库——它专门针对数值运算做了矢量化和编译优化，速度比原生eval快好几倍。

首先安装依赖：

pip install numexpr

然后用numexpr.evaluate替代原生eval：

import numexpr as ne

# 计算结果，利用numexpr的高效运算
df['Result'] = [
    ne.evaluate(row['Eqn'], local_dict=row.to_dict())
    for _, row in df.iterrows()
]

如果你的Eqn列有很多重复的表达式，可以进一步优化：先找出所有唯一表达式，批量计算对应行的结果，避免重复运算：

# 提取唯一表达式，批量计算
results = []
for expr in df['Eqn'].unique():
    # 筛选出当前表达式对应的行
    mask = df['Eqn'] == expr
    # 用numexpr批量计算这些行的结果
    batch_result = ne.evaluate(
        expr,
        local_dict={'A': df.loc[mask, 'A'], 'B': df.loc[mask, 'B'], 'C': df.loc[mask, 'C']}
    )
    # 把结果存入Series，保留原索引
    results.append(pd.Series(batch_result, index=df[mask].index))

# 合并所有结果并排序索引
df['Result'] = pd.concat(results).sort_index()

这种方法比逐行处理快得多，尤其当重复表达式较多时，效率提升明显。

进阶矢量化方案（超大规模数据） #

如果数据量达到千万级甚至更高，可以用AST（抽象语法树）解析表达式，转换成Pandas的矢量化操作，彻底避免循环：

import ast

def parse_and_evaluate(expr, df):
    # 解析表达式为AST
    tree = ast.parse(expr, mode='eval')
    
    # 自定义AST转换器，把变量名替换成df的列引用
    class ColumnReplacer(ast.NodeTransformer):
        def visit_Name(self, node):
            return ast.Subscript(
                value=ast.Name(id='df', ctx=ast.Load()),
                slice=ast.Constant(value=node.id),
                ctx=ast.Load()
            )
    
    # 替换变量并修复AST位置信息
    transformed_tree = ColumnReplacer().visit(tree)
    ast.fix_missing_locations(transformed_tree)
    
    # 编译并执行矢量化运算
    return eval(compile(transformed_tree, '', 'eval'))

# 同样按唯一表达式批量计算
results = []
for expr in df['Eqn'].unique():
    mask = df['Eqn'] == expr
    results.append(pd.Series(parse_and_evaluate(expr, df.loc[mask]), index=df[mask].index))

df['Result'] = pd.concat(results).sort_index()

这个方法把每个表达式转换成Pandas的列运算，完全利用矢量化的优势，是大规模数据下的最优解。

重要安全提示：所有基于eval或AST编译的方法，都只能处理完全可信的表达式。如果Eqn列包含未知来源的内容（比如用户输入），绝对不能使用这些方法，否则可能导致恶意代码执行。

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