如果你只想计算(列a) %(列b)，你不需要应用，直接做:

In [7]: df['a'] % df['c']                                                                                                                                                        
Out[7]: 
0   -1.132022                                                                                                                                                                    
1   -0.939493                                                                                                                                                                    
2    0.201931                                                                                                                                                                    
3    0.511374                                                                                                                                                                    
4   -0.694647                                                                                                                                                                    
5   -0.023486                                                                                                                                                                    
Name: a

好像你忘了你的"弦"

In [43]: df['Value'] = df.apply(lambda row: my_test(row['a'], row['c']), axis=1)

In [44]: df
Out[44]:
                    a    b         c     Value
          0 -1.674308  foo  0.343801  0.044698
          1 -2.163236  bar -2.046438 -0.116798
          2 -0.199115  foo -0.458050 -0.199115
          3  0.918646  bar -0.007185 -0.001006
          4  1.336830  foo  0.534292  0.268245
          5  0.976844  bar -0.773630 -0.570417

顺便说一句，在我看来，以下方式更优雅:

In [53]: def my_test2(row):
....:     return row['a'] % row['c']
....:     

In [54]: df['Value'] = df.apply(my_test2, axis=1)

假设我们想对DataFrame df的列'a'和'b'应用一个函数add5

def add5(x):
    return x+5

df[['a', 'b']].apply(add5)

上面所有的建议都有效，但是如果你想让你的计算更有效，你应该利用numpy向量运算(正如这里指出的)。

import pandas as pd
import numpy as np


df = pd.DataFrame ({'a' : np.random.randn(6),
             'b' : ['foo', 'bar'] * 3,
             'c' : np.random.randn(6)})

例1:使用pandas.apply()进行循环:

%%timeit
def my_test2(row):
    return row['a'] % row['c']

df['Value'] = df.apply(my_test2, axis=1)

最慢的跑步时间是最快的7.49倍。这可能 意味着正在缓存中间结果。1000个循环，最好的 3:4 81µs /环路

例2:使用pandas.apply()进行矢量化:

%%timeit
df['a'] % df['c']

最慢的跑时间是最快的跑时间的458.85倍。这可能 意味着正在缓存中间结果。10000个循环，最好的 3: 70.9µs /回路

例3:使用numpy数组向量化:

%%timeit
df['a'].values % df['c'].values

最慢的跑步时间是最快的7.98倍。这可能 意味着正在缓存中间结果。100000循环，最好 每回路3:6.39µs

因此，使用numpy数组进行向量化将速度提高了近两个数量级。

这与前面的解决方案相同，但我在df中定义了函数。应用本身:

df['Value'] = df.apply(lambda row: row['a']%row['c'], axis=1)

我已经对上述三种方法进行了比较。

使用值

%timeit df['value'] = df['a'].values % df['c'].values

139µs±1.91µs / loop(平均±std. dev. 7次运行，每次10000次循环)

没有值

%timeit df['value'] = df['a']%df['c'] 

216µs±1.86µs / loop(平均±std. dev. 7次运行，每个循环1000次)

应用函数

%timeit df['Value'] = df.apply(lambda row: row['a']%row['c'], axis=1)

474µs±5.07µs / loop(平均±std. dev. 7次运行，每个循环1000次)