如何在熊猫身上做到这一点:
我在单个文本列上有一个函数extract_text_features，返回多个输出列。具体来说，该函数返回6个值。
该函数可以工作，但是似乎没有任何合适的返回类型(pandas DataFrame/ numpy数组/ Python列表)，以便输出可以正确分配df。Ix [:，10:16] = df.textcol.map(extract_text_features)
所以我认为我需要回落到迭代与df.iterrows()，按此?
更新: 使用df.iterrows()迭代至少要慢20倍，因此我放弃并将该函数分解为6个不同的.map(lambda…)调用。
更新2:这个问题是在v0.11.0版本被问到的，在可用性df之前。在v0.16中改进了Apply或添加了df.assign()。因此，很多问题和答案都不太相关。
当前回答
公认的解决方案对于大量数据来说将会非常慢。获得最多赞数的解决方案读起来有点困难，而且处理数字数据也很慢。如果每个新列都可以独立于其他列计算，那么我将直接分配它们，而不使用apply。
假字符数据的例子
在DataFrame中创建100,000个字符串
df = pd.DataFrame(np.random.choice(['he jumped', 'she ran', 'they hiked'],
size=100000, replace=True),
columns=['words'])
df.head()
words
0 she ran
1 she ran
2 they hiked
3 they hiked
4 they hiked
假设我们想提取一些文本特征，就像在最初的问题中所做的那样。例如，让我们提取第一个字符，计算字母“e”的出现次数，并将短语大写。
df['first'] = df['words'].str[0]
df['count_e'] = df['words'].str.count('e')
df['cap'] = df['words'].str.capitalize()
df.head()
words first count_e cap
0 she ran s 1 She ran
1 she ran s 1 She ran
2 they hiked t 2 They hiked
3 they hiked t 2 They hiked
4 they hiked t 2 They hiked
计时
%%timeit
df['first'] = df['words'].str[0]
df['count_e'] = df['words'].str.count('e')
df['cap'] = df['words'].str.capitalize()
127 ms ± 585 µs per loop (mean ± std. dev. of 7 runs, 10 loops each)
def extract_text_features(x):
return x[0], x.count('e'), x.capitalize()
%timeit df['first'], df['count_e'], df['cap'] = zip(*df['words'].apply(extract_text_features))
101 ms ± 2.96 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)
令人惊讶的是，通过遍历每个值可以获得更好的性能
%%timeit
a,b,c = [], [], []
for s in df['words']:
a.append(s[0]), b.append(s.count('e')), c.append(s.capitalize())
df['first'] = a
df['count_e'] = b
df['cap'] = c
79.1 ms ± 294 µs per loop (mean ± std. dev. of 7 runs, 10 loops each)
另一个假数字数据的例子
创建100万个随机数并从上面测试幂函数。
df = pd.DataFrame(np.random.rand(1000000), columns=['num'])
def powers(x):
return x, x**2, x**3, x**4, x**5, x**6
%%timeit
df['p1'], df['p2'], df['p3'], df['p4'], df['p5'], df['p6'] = \
zip(*df['num'].map(powers))
1.35 s ± 83.6 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)
为每一列赋值速度快25倍，可读性强:
%%timeit
df['p1'] = df['num'] ** 1
df['p2'] = df['num'] ** 2
df['p3'] = df['num'] ** 3
df['p4'] = df['num'] ** 4
df['p5'] = df['num'] ** 5
df['p6'] = df['num'] ** 6
51.6 ms ± 1.9 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)
我在这里也做了类似的回答，并详细说明了为什么申请通常不是正确的选择。
其他回答
你可以返回整行而不是值:
df = df.apply(extract_text_features,axis = 1)
函数在哪里返回行
def extract_text_features(row):
row['new_col1'] = value1
row['new_col2'] = value2
return row
在2020年，我使用apply()参数result_type='expand'
applied_df = df.apply(lambda row: fn(row.text), axis='columns', result_type='expand')
df = pd.concat([df, applied_df], axis='columns')
只需使用result_type="expand"
df = pd.DataFrame(np.random.randint(0,10,(10,2)), columns=["random", "a"])
df[["sq_a","cube_a"]] = df.apply(lambda x: [x.a**2, x.a**3], axis=1, result_type="expand")
我已经研究了几种方法，这里显示的方法(返回熊猫系列)似乎不是最有效的。
如果我们从一个较大的随机数据的数据框架开始:
# Setup a dataframe of random numbers and create a
df = pd.DataFrame(np.random.randn(10000,3),columns=list('ABC'))
df['D'] = df.apply(lambda r: ':'.join(map(str, (r.A, r.B, r.C))), axis=1)
columns = 'new_a', 'new_b', 'new_c'
示例如下:
# Create the dataframe by returning a series
def method_b(v):
return pd.Series({k: v for k, v in zip(columns, v.split(':'))})
%timeit -n10 -r3 df.D.apply(method_b)
10圈，最好的3:2.77秒每圈
另一种方法:
# Create a dataframe from a series of tuples
def method_a(v):
return v.split(':')
%timeit -n10 -r3 pd.DataFrame(df.D.apply(method_a).tolist(), columns=columns)
10个循环，最好的3:8.85毫秒每循环
根据我的估算，采用一系列元组然后将其转换为DataFrame要有效得多。如果我的工作中出现了错误，我很想听听人们的想法。
我通常使用zip:
>>> df = pd.DataFrame([[i] for i in range(10)], columns=['num'])
>>> df
num
0 0
1 1
2 2
3 3
4 4
5 5
6 6
7 7
8 8
9 9
>>> def powers(x):
>>> return x, x**2, x**3, x**4, x**5, x**6
>>> df['p1'], df['p2'], df['p3'], df['p4'], df['p5'], df['p6'] = \
>>> zip(*df['num'].map(powers))
>>> df
num p1 p2 p3 p4 p5 p6
0 0 0 0 0 0 0 0
1 1 1 1 1 1 1 1
2 2 2 4 8 16 32 64
3 3 3 9 27 81 243 729
4 4 4 16 64 256 1024 4096
5 5 5 25 125 625 3125 15625
6 6 6 36 216 1296 7776 46656
7 7 7 49 343 2401 16807 117649
8 8 8 64 512 4096 32768 262144
9 9 9 81 729 6561 59049 531441
