如何在 pandas 中将函数应用于列创建新列？不同方法比较

2024-03-17 19:17:03

在数据分析中，我们经常需要对数据进行转换和操作。其中一个常见的任务是将函数应用于 pandas DataFrame 的列，以创建多个新列。本指南将讨论在 pandas 中实现此目标的不同方法，并比较它们的性能和适用性。

方法

方法 1：使用 `df.assign()`

df.assign() 方法是将新列添加到 DataFrame 的一种简洁且高效的方法。它接受一个函数作为参数，该函数将应用于 DataFrame 的每一行，并返回一个或多个新列。

import pandas as pd

# 示例 DataFrame
df = pd.DataFrame({'textcol': ['example text', 'another example']})

# 定义提取文本特征的函数
def extract_text_features(text):
    return {'col1': len(text), 'col2': text.upper(), 'col3': text.count('e')}

# 使用 df.assign() 添加新列
df = df.assign(**extract_text_features(df['textcol']))
print(df)

方法 2：使用 `df.apply()`

df.apply() 方法可以将一个函数应用于 DataFrame 的每一行或列。它返回一个包含应用函数的结果的新 DataFrame。

# 使用 df.apply() 添加新列
df[['col1', 'col2', 'col3']] = df['textcol'].apply(lambda x: pd.Series(extract_text_features(x)))
print(df)

方法 3：使用 `df.iterrows()`

df.iterrows() 方法是一个生成器，可以迭代 DataFrame 中的每一行。它返回一个元组，其中包含行索引和该行的 Series。

# 使用 df.iterrows() 添加新列
for i, row in df.iterrows():
    cols = extract_text_features(row['textcol'])
    df.loc[i, 'col1'] = cols[0]
    df.loc[i, 'col2'] = cols[1]
    df.loc[i, 'col3'] = cols[2]
print(df)

性能比较

这三种方法的性能可能会因 DataFrame 的大小和函数的复杂性而异。一般来说，df.assign() 是最快的，其次是 df.apply()，最后是 df.iterrows()。以下是一个简单的性能测试：

import timeit

# 创建一个较大的 DataFrame 用于性能测试
large_df = pd.DataFrame({'textcol': ['example text'] * 10000})

# 测量 df.assign() 的性能
time_assign = timeit.timeit(lambda: large_df.assign(**extract_text_features(large_df['textcol'])), number=10)

# 测量 df.apply() 的性能
time_apply = timeit.timeit(lambda: large_df['textcol'].apply(lambda x: pd.Series(extract_text_features(x))), number=10)

# 测量 df.iterrows() 的性能
time_iterrows = timeit.timeit(lambda: [extract_text_features(row['textcol']) for i, row in large_df.iterrows()], number=10)

print(f"df.assign() 时间: {time_assign:.4f} 秒")
print(f"df.apply() 时间: {time_apply:.4f} 秒")
print(f"df.iterrows() 时间: {time_iterrows:.4f} 秒")

结论

在 pandas 中应用函数以创建多个新列有多种方法。选择最合适的方法取决于 DataFrame 的大小、函数的复杂性以及所需的性能水平。一般来说，df.assign() 是最简洁和高效的选择，但在某些情况下，df.apply() 可能更灵活。df.iterrows() 通常较慢，但在处理非常复杂的逻辑时可能是必要的。