如何优化基于元数据的Pandas DataFrame列转换函数性能？

问题背景 #

我编写了一个工具函数，用于根据列规格元数据转换Pandas DataFrame的列类型，代码如下：

import pandas as pd
import json

def convert_pandas_columns(df: pd.DataFrame, metadata: dict | None) -> pd.DataFrame:
    """
    Convert a pandas DataFrame `df` columns starting from a metadata dict `cols`:
    ```
    {
      "columns": {
        "col1": {
            "type": "str"
        },
        "col2": {
            "type": "datetime"
        },
        "col3": {
            "type": "float"
        }
      }
    }
    ```
    """

    if metadata is None or 'columns' not in metadata:
        # Skip conversion if no metadata is available
        return df

    mappings = {
        'str': lambda x: x.astype(str, errors='ignore'),
        'int': lambda x: pd.to_numeric(x, downcast='integer', errors='coerce'),
        'float': lambda x: pd.to_numeric(x, downcast='float', errors='coerce'),
        'bool': lambda x: x.astype(bool, errors='ignore'),
        'datetime': lambda x: pd.to_datetime(x, errors='coerce'),
        'list': lambda x: json.loads(x) if x else [],  # always expect a json object
    }

    dtypes = {}
    for k, v in metadata['columns'].items():
        pd_type = mappings.get(v['type'], None)
        if pd_type is not None:
            dtypes[k] = pd_type

    return df.transform(
        {
            **{
                column: lambda x: x
                for column in df.columns
            },
            **dtypes,
        },
    )

该函数可正常运行，但速度极慢。此前我使用astype函数，但灵活性不足，请问有哪些优化方法可以提升性能？

优化方案 #

1. 仅处理需要转换的列，消除无意义开销

原函数通过transform对所有列（包括无需转换的列）应用恒等函数，带来大量不必要的计算和内存开销。优化后只针对元数据指定的列进行转换：

def convert_pandas_columns(df: pd.DataFrame, metadata: dict | None) -> pd.DataFrame:
    if metadata is None or 'columns' not in metadata:
        return df.copy()  # 返回副本避免修改原DataFrame

    mappings = {
        'str': lambda col: col.astype(str, errors='ignore'),
        'int': lambda col: pd.to_numeric(col, downcast='integer', errors='coerce'),
        'float': lambda col: pd.to_numeric(col, downcast='float', errors='coerce'),
        'bool': lambda col: col.astype(bool, errors='ignore'),
        'datetime': lambda col: pd.to_datetime(col, errors='coerce'),
        'list': lambda col: col.apply(lambda x: json.loads(x) if pd.notna(x) else [])
    }

    df_copy = df.copy()
    for col_name, specs in metadata['columns'].items():
        if col_name not in df_copy.columns:
            continue
        converter = mappings.get(specs['type'])
        if converter:
            df_copy[col_name] = converter(df_copy[col_name])
    
    return df_copy

2. 矢量化优化列表类型转换

原函数中列表类型的逐元素解析效率极低，可利用pyarrow的矢量化能力大幅提速（需提前安装pyarrow）：

import pyarrow as pa
from pyarrow import pandas as pa_pd

# 替换mappings中的list处理逻辑
'list': lambda col: pa_pd.from_arrow(
    pa.array(col.to_list(), type=pa.list_(pa.string())).fill_null(pa.array([], type=pa.list_(pa.string())))
)

这种方式通过Arrow的批量解析替代逐元素json.loads，性能提升明显。

3. 直接调用原生方法，减少lambda包装开销

对于str、bool这类可直接用astype的类型，跳过lambda包装，直接调用原生方法：

# 在循环中直接处理，替代lambda映射
for col_name, specs in metadata['columns'].items():
    if col_name not in df_copy.columns:
        continue
    dtype = specs['type']
    if dtype == 'str':
        df_copy[col_name] = df_copy[col_name].astype(str, errors='ignore')
    elif dtype == 'bool':
        df_copy[col_name] = df_copy[col_name].astype(bool, errors='ignore')
    # ... 其他类型处理逻辑

4. 放弃transform，改用直接列赋值

df.transform会创建大量中间对象，直接对列进行赋值操作的内存和时间开销远低于transform，这是性能提升的核心优化点。

5. 批量处理同类型列

如果元数据中有多个同类型列，按类型分组批量处理，减少循环次数：

df_copy = df.copy()
# 按类型分组列名
type_groups = {}
for col_name, specs in metadata['columns'].items():
    if col_name in df_copy.columns:
        type_groups.setdefault(specs['type'], []).append(col_name)

# 批量转换同类型列
for dtype, cols in type_groups.items():
    converter = mappings.get(dtype)
    if converter:
        df_copy[cols] = converter(df_copy[cols])

内容的提问来源于stack exchange，提问作者browser-bug