我在Stack Overflow上看到很多关于Pandas方法apply的答案。我也看到用户在下面评论说"apply很慢，应该避免使用"。
我读了很多关于性能的文章，解释了apply很慢。我也看到文档中有一份声明，说明apply只是用于传递UDF的便利函数（现在好像找不到了）。所以，普遍的共识是尽可能避免使用apply。但是，这引发了以下问题：
apply如此糟糕，那么为什么它在API中存在？apply？apply比其他可能的解决方案更好？apply, 你从未需要过的便利函数我们逐个回答OP中的问题。
"如果
apply这么差，为什么还在API中呢？"
DataFrame.apply和Series.apply是分别定义在DataFrame和Series对象上的便利函数。 apply接受任何用户定义的函数，对DataFrame应用变换/聚合操作。 apply实际上是一颗银弹，可以做任何现有的pandas函数无法完成的事情。
apply可以完成以下一些工作:
axis=1)或逐列(axis=0)地应用函数agg或transform)result_type参数)。...等等。有关更多信息，请参见文档中的逐行或逐列应用函数。
那么，拥有所有这些功能，为什么apply不好？ 这是因为apply 很慢。 Pandas对您的函数的性质不作任何假设，因此必要时iteratively applies your function每行/每列。 此外，处理上述所有情况意味着在每次迭代中都会产生一些重大的开销。进一步地，apply消耗了更多的内存，这对于内存受限的应用程序来说是一个挑战。
只有很少几种情况下使用 apply 是适当的 (有关详细信息请参见下面的内容)。 如果您不确定是否应该使用 apply，那么您可能不应该使用。
接下来让我们回答下一个问题。
"我应该如何在什么情况下去除对
apply的调用？"
换句话说，以下是您将希望摆脱任何对apply的调用的常见情况。
如果您使用数字数据，则很可能已经存在一个矢量化的Cython函数，可以精确地执行您要执行的操作(如果没有，请在Stack Overflow上提问或在GitHub上打开功能请求)。
将apply与简单的加法操作的性能进行比较。
df = pd.DataFrame({"A": [9, 4, 2, 1], "B": [12, 7, 5, 4]})
df
A B
0 9 12
1 4 7
2 2 5
3 1 4
<!- ->
df.apply(np.sum)
A 16
B 28
dtype: int64
df.sum()
A 16
B 28
dtype: int64
从性能上来看，没有可比性，经过Cython优化后的等效代码要快得多。不需要绘制图表，因为即使对于玩具数据，差异也很明显。
%timeit df.apply(np.sum)
%timeit df.sum()
2.22 ms ± 41.2 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)
471 µs ± 8.16 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)
即使您使用raw参数启用传递原始数组，速度仍会慢两倍。
%timeit df.apply(np.sum, raw=True)
840 µs ± 691 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)
另一个例子：
df.apply(lambda x: x.max() - x.min())
A 8
B 8
dtype: int64
df.max() - df.min()
A 8
B 8
dtype: int64
%timeit df.apply(lambda x: x.max() - x.min())
%timeit df.max() - df.min()
2.43 ms ± 450 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)
1.23 ms ± 14.7 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)
通常情况下，如果可以，寻找向量化的替代方案。
Pandas 在大多数情况下提供“向量化”的字符串函数，但是有些情况下这些函数不太适用。
一个常见的问题是检查列中的值是否存在于同一行的另一列中。
df = pd.DataFrame({
'Name': ['mickey', 'donald', 'minnie'],
'Title': ['wonderland', "welcome to donald's castle", 'Minnie mouse clubhouse'],
'Value': [20, 10, 86]})
df
Name Value Title
0 mickey 20 wonderland
1 donald 10 welcome to donald's castle
2 minnie 86 Minnie mouse clubhouse
由于“Donald”和“Minnie”分别出现在其相应的“Title”列中，因此这应返回第二行和第三行。
使用apply，可以使用以下方法完成
df.apply(lambda x: x['Name'].lower() in x['Title'].lower(), axis=1)
0 False
1 True
2 True
dtype: bool
df[df.apply(lambda x: x['Name'].lower() in x['Title'].lower(), axis=1)]
Name Title Value
1 donald welcome to donald's castle 10
2 minnie Minnie mouse clubhouse 86
然而，使用列表推导式存在更好的解决方案。
df[[y.lower() in x.lower() for x, y in zip(df['Title'], df['Name'])]]
Name Title Value
1 donald welcome to donald's castle 10
2 minnie Minnie mouse clubhouse 86
%timeit df[df.apply(lambda x: x['Name'].lower() in x['Title'].lower(), axis=1)]
%timeit df[[y.lower() in x.lower() for x, y in zip(df['Title'], df['Name'])]]
2.85 ms ± 38.4 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)
788 µs ± 16.4 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)
需要注意的是，迭代循环通常比apply更快，因为开销较小。如果需要处理NaN和无效数据类型，可以使用自定义函数来构建并在列表推导式内部调用。
有关何时应将列表推导式视为良好选项的更多信息，请参见我的写作：Are for-loops in pandas really bad? When should I care?
请注意：
日期和日期时间操作也具有向量化版本。因此，例如，您应该优先使用pd.to_datetime(df['date']),而不是使用df['date'].apply(pd.to_datetime).了解更多信息，请阅读文档。
s = pd.Series([[1, 2]] * 3)
s
0 [1, 2]
1 [1, 2]
2 [1, 2]
dtype: object
人们往往会尝试使用 apply(pd.Series)。然而，这样做在性能方面是极差的。
s.apply(pd.Series)
0 1
0 1 2
1 1 2
2 1 2
pd.DataFrame(s.tolist())
0 1
0 1 2
1 1 2
2 1 2
%timeit s.apply(pd.Series)
%timeit pd.DataFrame(s.tolist())
2.65 ms ± 294 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)
816 µs ± 40.5 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)
最后,
"是否有适用于
apply的情况？"
apply是一个方便的函数，因此在开销可以忽略不计时，确实存在可以使用它的情况。这取决于函数被调用的次数。
仅对Series向量化但不对DataFrames向量化的函数
如果您想要对多个列应用字符串操作怎么办？如果您想要将多个列转换为日期时间格式怎么办？这些函数仅对Series向量化，因此必须针对每个要转换/操作的列进行应用。
df = pd.DataFrame(
pd.date_range('2018-12-31','2019-01-31', freq='2D').date.astype(str).reshape(-1, 2),
columns=['date1', 'date2'])
df
date1 date2
0 2018-12-31 2019-01-02
1 2019-01-04 2019-01-06
2 2019-01-08 2019-01-10
3 2019-01-12 2019-01-14
4 2019-01-16 2019-01-18
5 2019-01-20 2019-01-22
6 2019-01-24 2019-01-26
7 2019-01-28 2019-01-30
df.dtypes
date1 object
date2 object
dtype: object
这是适用于 apply 的一个可接受的情况：
df.apply(pd.to_datetime, errors='coerce').dtypes
date1 datetime64[ns]
date2 datetime64[ns]
dtype: object
stack或者使用显式循环也是有意义的。所有这些选项都比使用apply稍微快一点，但差异足够小，可以原谅。%timeit df.apply(pd.to_datetime, errors='coerce')
%timeit pd.to_datetime(df.stack(), errors='coerce').unstack()
%timeit pd.concat([pd.to_datetime(df[c], errors='coerce') for c in df], axis=1)
%timeit for c in df.columns: df[c] = pd.to_datetime(df[c], errors='coerce')
5.49 ms ± 247 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)
3.94 ms ± 48.1 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)
3.16 ms ± 216 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)
2.41 ms ± 1.71 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)
您可以对其他操作（例如字符串操作或转换为类别）做出类似的论证。
u = df.apply(lambda x: x.str.contains(...))
v = df.apply(lambda x: x.astype(category))
u = pd.concat([df[c].str.contains(...) for c in df], axis=1)
v = df.copy()
for c in df:
v[c] = df[c].astype(category)
将Series转换为str： astype与apply的区别
使用apply将Series中的整数转换为字符串比使用astype更快，这似乎是API的奇特之处。
该图是使用perfplot 库绘制的。
import perfplot
perfplot.show(
setup=lambda n: pd.Series(np.random.randint(0, n, n)),
kernels=[
lambda s: s.astype(str),
lambda s: s.apply(str)
],
labels=['astype', 'apply'],
n_range=[2**k for k in range(1, 20)],
xlabel='N',
logx=True,
logy=True,
equality_check=lambda x, y: (x == y).all())
使用浮点数，我发现astype与apply的速度基本相同或略快。这是因为测试数据中的数据类型为整数。
GroupBy操作与链接转换GroupBy.apply直到现在才被讨论，但GroupBy.apply也是一个迭代方便函数，用于处理现有GroupBy函数无法处理的任何内容。
一个常见的要求是执行GroupBy，然后执行两个主要操作，例如“滞后累加”：
df = pd.DataFrame({"A": list('aabcccddee'), "B": [12, 7, 5, 4, 5, 4, 3, 2, 1, 10]})
df
A B
0 a 12
1 a 7
2 b 5
3 c 4
4 c 5
5 c 4
6 d 3
7 d 2
8 e 1
9 e 10
<!- ->
在这里，您需要进行两次连续的 groupby 调用：
df.groupby('A').B.cumsum().groupby(df.A).shift()
0 NaN
1 12.0
2 NaN
3 NaN
4 4.0
5 9.0
6 NaN
7 3.0
8 NaN
9 1.0
Name: B, dtype: float64
通过使用apply，您可以将此缩短为一个单独的调用。
df.groupby('A').B.apply(lambda x: x.cumsum().shift())
0 NaN
1 12.0
2 NaN
3 NaN
4 4.0
5 9.0
6 NaN
7 3.0
8 NaN
9 1.0
Name: B, dtype: float64
由于性能取决于数据，很难量化性能。但是通常情况下，如果目标是减少 groupby 调用（因为 groupby 也很昂贵），那么 apply 是一个可接受的解决方案。
除了上面提到的注意事项之外，值得一提的是，apply 在第一行（或列）上操作两次，以确定该函数是否具有任何副作用。如果没有，apply 可能能够使用快速路径来评估结果；否则，它会回退到慢速实现。
df = pd.DataFrame({
'A': [1, 2],
'B': ['x', 'y']
})
def func(x):
print(x['A'])
return x
df.apply(func, axis=1)
# 1
# 1
# 2
A B
0 1 x
1 2 y
这种行为在pandas版本<0.25的GroupBy.apply中也有出现（在0.25版本中已修复，更多信息请参见此处）。
df.apply(np.sum)和df.sum()时似乎找不到相同的时间：df.sum()只比df.apply(np.sum)快约20％，而df.apply(np.sum, raw=True)则快了两倍！我在changelog中没有找到特定于apply的性能改进，所以有点迷惑... - Tranbiapply都相同下面的图表建议何时考虑使用apply1。绿色意味着可能有效；红色避免。
一些是直观的：pd.Series.apply是一种Python级别的逐行循环，同样pd.DataFrame.apply也是逐行操作（axis=1）。这些滥用很多且范围广泛，其他帖子会更详细地介绍。流行的解决方案是使用向量化方法、列表推导式（假设数据干净）或高效工具，如pd.DataFrame构造器（例如，避免apply(pd.Series)）。
如果您正在使用pd.DataFrame.apply逐行操作，请尽可能指定raw=True有利于性能提升。在此阶段，通常最好选择numba。
GroupBy.apply：通常受欢迎重复使用groupby操作以避免apply会损害性能。通常情况下，GroupBy.apply就可以胜任此项工作，前提是您在自定义函数中使用的方法本身是向量化的。有时，在您希望应用组合聚合的情况下，Pandas没有本地方法。在这种情况下，对于一小部分组，使用自定义函数的apply仍然可以提供合理的性能。
pd.DataFrame.apply逐列操作：各有千秋pd.DataFrame.apply逐列操作（axis=0）是一个有趣的案例。当行数较少，列数较多时，它几乎总是代价高昂的。对于相对于列而言行数较多的情况，更常见的情况是，您可能会有时通过使用apply看到显着的性能提升：
# Python 3.7, Pandas 0.23.4
np.random.seed(0)
df = pd.DataFrame(np.random.random((10**7, 3))) # Scenario_1, many rows
df = pd.DataFrame(np.random.random((10**4, 10**3))) # Scenario_2, many columns
# Scenario_1 | Scenario_2
%timeit df.sum() # 800 ms | 109 ms
%timeit df.apply(pd.Series.sum) # 568 ms | 325 ms
%timeit df.max() - df.min() # 1.63 s | 314 ms
%timeit df.apply(lambda x: x.max() - x.min()) # 838 ms | 473 ms
%timeit df.mean() # 108 ms | 94.4 ms
%timeit df.apply(pd.Series.mean) # 276 ms | 233 ms
1 有一些例外，但它们通常是边缘的或不常见的。以下是一些示例：
df['col'].apply(str) 可能会略微优于 df['col'].astype(str)。df.apply(pd.to_datetime) 在处理字符串时，与普通的 for 循环相比，在行数较多时性能不良好。apply应该会更慢。还要注意问题可能是mask（尝试使用np.where代替）。一个需要3-5毫秒的过程不适合基准测试，因为在现实中，当时间如此短时，你可能并不关心性能。 - jppany比apply快大约100倍。我用2000行x 1000列进行了第一次测试，在这里apply比any快两倍。 - Stef对于 axis=1（即按行计算的函数），您可以使用以下函数代替 apply。我想知道为什么这不是 pandas 的默认行为。（未经复合索引测试，但似乎比 apply 快得多）
def faster_df_apply(df, func):
cols = list(df.columns)
data, index = [], []
for row in df.itertuples(index=True):
row_dict = {f:v for f,v in zip(cols, row[1:])}
data.append(func(row_dict))
index.append(row[0])
return pd.Series(data, index=index)
.apply 的实现非常接近，但它执行了一项显著减慢速度的操作，它基本上执行了：row = pd.Series({f:v for f,v in zip(cols, row[1:])})，这增加了很多负担。我写了一个[答案]（https://dev59.com/z1kT5IYBdhLWcg3wMMur#38938507），描述了实现方式，尽管我认为它已经过时，最近的版本尝试在 .apply 中利用Cython，我相信（别引用我） - juanpa.arrivillagazip上调用dict，而是使用推导式？为什么要将列转换为列表，而不是遍历列？ - Daniel Gibsondf.apply(func, axis=1)将返回与faster_df_apply(df, func)相同的结果，但在行数很多的数据框上运行速度会更快。
如果您有更好的解决方案，请分享。我认为告诉人们“不要调用apply”（正如其他人所做的那样）是一个愚蠢的非解决方案。有些人确实想要调用apply，而faster_df_apply是一个完全替代品，可以更快地运行。 - Pete Cacioppi是否存在适用apply的情况？ 是的，有时候。
任务：解码Unicode字符串。
import numpy as np
import pandas as pd
import unidecode
s = pd.Series(['mañana','Ceñía'])
s.head()
0 mañana
1 Ceñía
s.apply(unidecode.unidecode)
0 manana
1 Cenia
更新
我绝不是在提倡使用apply，只是认为既然NumPy无法处理上述情况，pandas apply可能是一个不错的选择。但是，由于@jpp的提醒，我忘记了简单的列表推导。
[unidecode.unidecode(x) for x in s] 或 list(map(unidecode.unidecode, s)) 更好在哪里？ - jppapply进行辩护，只是认为这可能是一个很好的用例。 - BhishanPoudel
returns.add(1).apply(np.log)和np.log(returns.add(1)是一种情况，其中apply通常会稍微快一些，这是 jpp 图表中右下角的绿色框。 - Alexanderapply方法通常速度很快，是一个非常好的API，有80%的时间可以使用。因此，我完全不同意那些建议不要使用它的观点。但是，了解其局限性并掌握一些技巧是明智的，以防万一apply方法变得太慢，可以在顶部答案中列出的技巧中找到解决方案。 - Zephaniah Grunschlag