为啥 numpy 函数在 pandas 系列/数据帧上这么慢？
Posted
技术标签:
【中文标题】为啥 numpy 函数在 pandas 系列/数据帧上这么慢？【英文标题】：Why are numpy functions so slow on pandas series / dataframes?为什么 numpy 函数在 pandas 系列/数据帧上这么慢？ 【发布时间】：2018-06-02 06:49:21 【问题描述】：考虑一个小型 MWE，取自 another question：
DateTime Data
2017-11-21 18:54:31 1
2017-11-22 02:26:48 2
2017-11-22 10:19:44 3
2017-11-22 15:11:28 6
2017-11-22 23:21:58 7
2017-11-28 14:28:28 28
2017-11-28 14:36:40 0
2017-11-28 14:59:48 1
目标是裁剪所有上限为 1 的值。我的答案使用np.clip，效果很好。
np.clip(df.Data, a_min=None, a_max=1)
array([1, 1, 1, 1, 1, 1, 0, 1])
或者，
np.clip(df.Data.values, a_min=None, a_max=1)
array([1, 1, 1, 1, 1, 1, 0, 1])
两者都返回相同的答案。我的问题是关于这两种方法的相对性能。考虑 -
df = pd.concat([df]*1000).reset_index(drop=True)
%timeit np.clip(df.Data, a_min=None, a_max=1)
1000 loops, best of 3: 270 µs per loop
%timeit np.clip(df.Data.values, a_min=None, a_max=1)
10000 loops, best of 3: 23.4 µs per loop
为什么两者之间有如此巨大的差异，只是在后者上调用values？也就是说……
为什么 numpy 函数在 pandas 对象上这么慢？
【问题讨论】：
如果 DataFrame 是单个块（没有混合 dtypes），那么它不会创建新数组；否则它会这样做。 我认为这里的比较不是针对相同的功能。 Numpy 通常将函数委托给对象的方法，如果有的话。由于 df['Data'] 有一个 clip 方法，所以它可能使用的是 pandas 版本。 另一个有趣的比较是比较做同样工作的 NumPy 和 pandas 函数。如果它们在相同的 pandas 对象上都一样慢，那么问题就是为什么使用对象比常规数组慢。 Jeffrey Tratner 的演讲真好。 Here 是幻灯片。他在幻灯片 35 中开始谈论块管理器。让我尝试进入这两个版本，看看我是否能想出一个完整的答案。 Numpy 旨在重定向到pandas.Series.clip 函数，但参数不同，然后它回退到asarray(column).clip(..) 函数。
【参考方案1】：
是的，np.clip 在pandas.Series 上似乎比在numpy.ndarrays 上慢很多。这是正确的，但实际上（至少无症状）并没有那么糟糕。 8000 个元素仍处于恒定因素是运行时主要贡献者的状态。我认为这是问题的一个非常重要的方面，所以我将其可视化（借用another answer）：
# Setup
import pandas as pd
import numpy as np
def on_series(s):
return np.clip(s, a_min=None, a_max=1)
def on_values_of_series(s):
return np.clip(s.values, a_min=None, a_max=1)
# Timing setup
timings = on_series: [], on_values_of_series: []
sizes = [2**i for i in range(1, 26, 2)]
# Timing
for size in sizes:
func_input = pd.Series(np.random.randint(0, 30, size=size))
for func in timings:
res = %timeit -o func(func_input)
timings[func].append(res)
%matplotlib notebook
import matplotlib.pyplot as plt
import numpy as np
fig, (ax1, ax2) = plt.subplots(1, 2)
for func in timings:
ax1.plot(sizes,
[time.best for time in timings[func]],
label=str(func.__name__))
ax1.set_xscale('log')
ax1.set_yscale('log')
ax1.set_xlabel('size')
ax1.set_ylabel('time [seconds]')
ax1.grid(which='both')
ax1.legend()
baseline = on_values_of_series # choose one function as baseline
for func in timings:
ax2.plot(sizes,
[time.best / ref.best for time, ref in zip(timings[func], timings[baseline])],
label=str(func.__name__))
ax2.set_yscale('log')
ax2.set_xscale('log')
ax2.set_xlabel('size')
ax2.set_ylabel('time relative to '.format(baseline.__name__))
ax2.grid(which='both')
ax2.legend()
plt.tight_layout()
这是一个对数图，因为我认为这更清楚地显示了重要特征。例如，它显示numpy.ndarray 上的np.clip 更快，但在这种情况下它的常数因子也小得多。大型阵列的差异仅为~3！这仍然是一个很大的差异，但比小数组的差异要小。
但是，这仍然不是时差从何而来的问题的答案。
解决方案其实很简单：np.clip 委托给第一个参数的clip 方法：
>>> np.clip??
Source:
def clip(a, a_min, a_max, out=None):
"""
...
"""
return _wrapfunc(a, 'clip', a_min, a_max, out=out)
>>> np.core.fromnumeric._wrapfunc??
Source:
def _wrapfunc(obj, method, *args, **kwds):
try:
return getattr(obj, method)(*args, **kwds)
# ...
except (AttributeError, TypeError):
return _wrapit(obj, method, *args, **kwds)
_wrapfunc函数的getattr这一行是这里重要的一行，因为np.ndarray.clip和pd.Series.clip是不同的方法，是的，完全不同的方法：
>>> np.ndarray.clip
<method 'clip' of 'numpy.ndarray' objects>
>>> pd.Series.clip
<function pandas.core.generic.NDFrame.clip>
不幸的是，np.ndarray.clip 是一个 C 函数，因此很难对其进行分析，但是 pd.Series.clip 是一个常规 Python 函数，因此很容易进行分析。让我们在这里使用一系列 5000 个整数：
s = pd.Series(np.random.randint(0, 100, 5000))
对于values 上的np.clip，我得到以下行分析：
%load_ext line_profiler
%lprun -f np.clip -f np.core.fromnumeric._wrapfunc np.clip(s.values, a_min=None, a_max=1)
Timer unit: 4.10256e-07 s
Total time: 2.25641e-05 s
File: numpy\core\fromnumeric.py
Function: clip at line 1673
Line # Hits Time Per Hit % Time Line Contents
==============================================================
1673 def clip(a, a_min, a_max, out=None):
1674 """
...
1726 """
1727 1 55 55.0 100.0 return _wrapfunc(a, 'clip', a_min, a_max, out=out)
Total time: 1.51795e-05 s
File: numpy\core\fromnumeric.py
Function: _wrapfunc at line 55
Line # Hits Time Per Hit % Time Line Contents
==============================================================
55 def _wrapfunc(obj, method, *args, **kwds):
56 1 2 2.0 5.4 try:
57 1 35 35.0 94.6 return getattr(obj, method)(*args, **kwds)
58
59 # An AttributeError occurs if the object does not have
60 # such a method in its class.
61
62 # A TypeError occurs if the object does have such a method
63 # in its class, but its signature is not identical to that
64 # of NumPy's. This situation has occurred in the case of
65 # a downstream library like 'pandas'.
66 except (AttributeError, TypeError):
67 return _wrapit(obj, method, *args, **kwds)
但是对于Series 上的np.clip，我得到了完全不同的分析结果：
%lprun -f np.clip -f np.core.fromnumeric._wrapfunc -f pd.Series.clip -f pd.Series._clip_with_scalar np.clip(s, a_min=None, a_max=1)
Timer unit: 4.10256e-07 s
Total time: 0.000823794 s
File: numpy\core\fromnumeric.py
Function: clip at line 1673
Line # Hits Time Per Hit % Time Line Contents
==============================================================
1673 def clip(a, a_min, a_max, out=None):
1674 """
...
1726 """
1727 1 2008 2008.0 100.0 return _wrapfunc(a, 'clip', a_min, a_max, out=out)
Total time: 0.00081846 s
File: numpy\core\fromnumeric.py
Function: _wrapfunc at line 55
Line # Hits Time Per Hit % Time Line Contents
==============================================================
55 def _wrapfunc(obj, method, *args, **kwds):
56 1 2 2.0 0.1 try:
57 1 1993 1993.0 99.9 return getattr(obj, method)(*args, **kwds)
58
59 # An AttributeError occurs if the object does not have
60 # such a method in its class.
61
62 # A TypeError occurs if the object does have such a method
63 # in its class, but its signature is not identical to that
64 # of NumPy's. This situation has occurred in the case of
65 # a downstream library like 'pandas'.
66 except (AttributeError, TypeError):
67 return _wrapit(obj, method, *args, **kwds)
Total time: 0.000804922 s
File: pandas\core\generic.py
Function: clip at line 4969
Line # Hits Time Per Hit % Time Line Contents
==============================================================
4969 def clip(self, lower=None, upper=None, axis=None, inplace=False,
4970 *args, **kwargs):
4971 """
...
5021 """
5022 1 12 12.0 0.6 if isinstance(self, ABCPanel):
5023 raise NotImplementedError("clip is not supported yet for panels")
5024
5025 1 10 10.0 0.5 inplace = validate_bool_kwarg(inplace, 'inplace')
5026
5027 1 69 69.0 3.5 axis = nv.validate_clip_with_axis(axis, args, kwargs)
5028
5029 # GH 17276
5030 # numpy doesn't like NaN as a clip value
5031 # so ignore
5032 1 158 158.0 8.1 if np.any(pd.isnull(lower)):
5033 1 3 3.0 0.2 lower = None
5034 1 26 26.0 1.3 if np.any(pd.isnull(upper)):
5035 upper = None
5036
5037 # GH 2747 (arguments were reversed)
5038 1 1 1.0 0.1 if lower is not None and upper is not None:
5039 if is_scalar(lower) and is_scalar(upper):
5040 lower, upper = min(lower, upper), max(lower, upper)
5041
5042 # fast-path for scalars
5043 1 1 1.0 0.1 if ((lower is None or (is_scalar(lower) and is_number(lower))) and
5044 1 28 28.0 1.4 (upper is None or (is_scalar(upper) and is_number(upper)))):
5045 1 1654 1654.0 84.3 return self._clip_with_scalar(lower, upper, inplace=inplace)
5046
5047 result = self
5048 if lower is not None:
5049 result = result.clip_lower(lower, axis, inplace=inplace)
5050 if upper is not None:
5051 if inplace:
5052 result = self
5053 result = result.clip_upper(upper, axis, inplace=inplace)
5054
5055 return result
Total time: 0.000662153 s
File: pandas\core\generic.py
Function: _clip_with_scalar at line 4920
Line # Hits Time Per Hit % Time Line Contents
==============================================================
4920 def _clip_with_scalar(self, lower, upper, inplace=False):
4921 1 2 2.0 0.1 if ((lower is not None and np.any(isna(lower))) or
4922 1 25 25.0 1.5 (upper is not None and np.any(isna(upper)))):
4923 raise ValueError("Cannot use an NA value as a clip threshold")
4924
4925 1 22 22.0 1.4 result = self.values
4926 1 571 571.0 35.4 mask = isna(result)
4927
4928 1 95 95.0 5.9 with np.errstate(all='ignore'):
4929 1 1 1.0 0.1 if upper is not None:
4930 1 141 141.0 8.7 result = np.where(result >= upper, upper, result)
4931 1 33 33.0 2.0 if lower is not None:
4932 result = np.where(result <= lower, lower, result)
4933 1 73 73.0 4.5 if np.any(mask):
4934 result[mask] = np.nan
4935
4936 1 90 90.0 5.6 axes_dict = self._construct_axes_dict()
4937 1 558 558.0 34.6 result = self._constructor(result, **axes_dict).__finalize__(self)
4938
4939 1 2 2.0 0.1 if inplace:
4940 self._update_inplace(result)
4941 else:
4942 1 1 1.0 0.1 return result
那时我停止进入子例程，因为它已经突出了pd.Series.clip 比np.ndarray.clip 做更多工作的地方。只需将values（55 个计时器单位）上的np.clip 调用的总时间与pandas.Series.clip 方法中的第一个检查之一if np.any(pd.isnull(lower))（158 个计时器单位）进行比较。那时，pandas 方法甚至还没有从裁剪开始，它已经花费了 3 倍的时间。
但是，当数组很大时，这些“开销”中的一些变得微不足道：
s = pd.Series(np.random.randint(0, 100, 1000000))
%lprun -f np.clip -f np.core.fromnumeric._wrapfunc -f pd.Series.clip -f pd.Series._clip_with_scalar np.clip(s, a_min=None, a_max=1)
Timer unit: 4.10256e-07 s
Total time: 0.00593476 s
File: numpy\core\fromnumeric.py
Function: clip at line 1673
Line # Hits Time Per Hit % Time Line Contents
==============================================================
1673 def clip(a, a_min, a_max, out=None):
1674 """
...
1726 """
1727 1 14466 14466.0 100.0 return _wrapfunc(a, 'clip', a_min, a_max, out=out)
Total time: 0.00592779 s
File: numpy\core\fromnumeric.py
Function: _wrapfunc at line 55
Line # Hits Time Per Hit % Time Line Contents
==============================================================
55 def _wrapfunc(obj, method, *args, **kwds):
56 1 1 1.0 0.0 try:
57 1 14448 14448.0 100.0 return getattr(obj, method)(*args, **kwds)
58
59 # An AttributeError occurs if the object does not have
60 # such a method in its class.
61
62 # A TypeError occurs if the object does have such a method
63 # in its class, but its signature is not identical to that
64 # of NumPy's. This situation has occurred in the case of
65 # a downstream library like 'pandas'.
66 except (AttributeError, TypeError):
67 return _wrapit(obj, method, *args, **kwds)
Total time: 0.00591302 s
File: pandas\core\generic.py
Function: clip at line 4969
Line # Hits Time Per Hit % Time Line Contents
==============================================================
4969 def clip(self, lower=None, upper=None, axis=None, inplace=False,
4970 *args, **kwargs):
4971 """
...
5021 """
5022 1 17 17.0 0.1 if isinstance(self, ABCPanel):
5023 raise NotImplementedError("clip is not supported yet for panels")
5024
5025 1 14 14.0 0.1 inplace = validate_bool_kwarg(inplace, 'inplace')
5026
5027 1 97 97.0 0.7 axis = nv.validate_clip_with_axis(axis, args, kwargs)
5028
5029 # GH 17276
5030 # numpy doesn't like NaN as a clip value
5031 # so ignore
5032 1 125 125.0 0.9 if np.any(pd.isnull(lower)):
5033 1 2 2.0 0.0 lower = None
5034 1 30 30.0 0.2 if np.any(pd.isnull(upper)):
5035 upper = None
5036
5037 # GH 2747 (arguments were reversed)
5038 1 2 2.0 0.0 if lower is not None and upper is not None:
5039 if is_scalar(lower) and is_scalar(upper):
5040 lower, upper = min(lower, upper), max(lower, upper)
5041
5042 # fast-path for scalars
5043 1 2 2.0 0.0 if ((lower is None or (is_scalar(lower) and is_number(lower))) and
5044 1 32 32.0 0.2 (upper is None or (is_scalar(upper) and is_number(upper)))):
5045 1 14092 14092.0 97.8 return self._clip_with_scalar(lower, upper, inplace=inplace)
5046
5047 result = self
5048 if lower is not None:
5049 result = result.clip_lower(lower, axis, inplace=inplace)
5050 if upper is not None:
5051 if inplace:
5052 result = self
5053 result = result.clip_upper(upper, axis, inplace=inplace)
5054
5055 return result
Total time: 0.00575753 s
File: pandas\core\generic.py
Function: _clip_with_scalar at line 4920
Line # Hits Time Per Hit % Time Line Contents
==============================================================
4920 def _clip_with_scalar(self, lower, upper, inplace=False):
4921 1 2 2.0 0.0 if ((lower is not None and np.any(isna(lower))) or
4922 1 28 28.0 0.2 (upper is not None and np.any(isna(upper)))):
4923 raise ValueError("Cannot use an NA value as a clip threshold")
4924
4925 1 120 120.0 0.9 result = self.values
4926 1 3525 3525.0 25.1 mask = isna(result)
4927
4928 1 86 86.0 0.6 with np.errstate(all='ignore'):
4929 1 2 2.0 0.0 if upper is not None:
4930 1 9314 9314.0 66.4 result = np.where(result >= upper, upper, result)
4931 1 61 61.0 0.4 if lower is not None:
4932 result = np.where(result <= lower, lower, result)
4933 1 283 283.0 2.0 if np.any(mask):
4934 result[mask] = np.nan
4935
4936 1 78 78.0 0.6 axes_dict = self._construct_axes_dict()
4937 1 532 532.0 3.8 result = self._constructor(result, **axes_dict).__finalize__(self)
4938
4939 1 2 2.0 0.0 if inplace:
4940 self._update_inplace(result)
4941 else:
4942 1 1 1.0 0.0 return result
仍有多个函数调用，例如isna 和np.where，需要大量时间，但总体而言，这至少与np.ndarray.clip 时间相当（这是在时间差的情况下）在我的电脑上约为 3）。
外卖应该是：
许多 NumPy 函数只是委托给传入对象的方法，因此当您传入不同的对象时可能会有很大差异。 分析，尤其是行分析，是查找性能差异所在位置的绝佳工具。 在这种情况下，请始终确保测试不同大小的对象。您可以比较可能无关紧要的常数因子，除非您处理大量小数组。使用过的版本：
Python 3.6.3 64-bit on Windows 10
Numpy 1.13.3
Pandas 0.21.1
【讨论】：
谢谢！这正是我正在寻找的答案。跟进，这些观察是否也解释了其他各种 numpy 函数在系列和数据帧上也变慢的原因？还是这只特定于剪辑？ @COLDSPEED 常数因素可能会影响所有 pandas 函数的性能。然而，clip 有一个特定的渐近性能差距，因为 pandas 不调用 np.clip，它使用 np.where。我试图在下面的答案中解开这个。 这有点深入。从未见过%lprun
@cᴏʟᴅsᴘᴇᴇᴅ 您的后续行动不容易回答，因为有很多 NumPy 函数委托给具有相同名称的方法（但并非全部都这样做！）但它确实取决于实现pandas 和 numpy 的方法。我预计 pandas 通常会做更多的工作（因为几个 pandas 方法可以更优雅地处理 NaN/Nones、对象数组，有时还提供更多功能），因此速度较慢。但差异量必须根据具体情况确定。
很公平，这有点像我希望听到的。我很清楚我想要这个问题的理想答案，你已经勾选了我所有的方框。干杯！【参考方案2】：
看了源码就明白了。
def clip(a, a_min, a_max, out=None):
"""a : array_like Array containing elements to clip."""
return _wrapfunc(a, 'clip', a_min, a_max, out=out)
def _wrapfunc(obj, method, *args, **kwds):
try:
return getattr(obj, method)(*args, **kwds)
#This situation has occurred in the case of
# a downstream library like 'pandas'.
except (AttributeError, TypeError):
return _wrapit(obj, method, *args, **kwds)
def _wrapit(obj, method, *args, **kwds):
try:
wrap = obj.__array_wrap__
except AttributeError:
wrap = None
result = getattr(asarray(obj), method)(*args, **kwds)
if wrap:
if not isinstance(result, mu.ndarray):
result = asarray(result)
result = wrap(result)
return result
纠正：
pandas v0.13.0_ahl1 之后，pandas 有了自己的实现 clip。
【讨论】：
谢谢。我想你已经谈到了重点，但让我等待更多的答案。 @Dark 你是对的，我刚看了评论，我太快了，无法做出判断。【参考方案3】：这里有两部分需要注意的性能差异：
每个库中的 Python 开销（pandas 非常有用）
数值算法实现的差异（pd.clip 实际上调用了np.where）
在一个非常小的数组上运行它应该可以展示 Python 开销的差异。对于 numpy，这是可以理解的非常小的，但是 pandas 在处理大量数字之前会进行大量检查（空值、更灵活的参数处理等）。我试图粗略地展示这两个代码在触及 C 代码基础之前所经历的阶段。
data = pd.Series(np.random.random(100))
在ndarray 上使用np.clip 时，开销只是调用对象方法的numpy 包装函数：
>>> %timeit np.clip(data.values, 0.2, 0.8) # numpy wrapper, calls .clip() on the ndarray
>>> %timeit data.values.clip(0.2, 0.8) # C function call
2.22 µs ± 125 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)
1.32 µs ± 20.4 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)
Pandas 在进入算法之前会花费更多时间检查边缘情况：
>>> %timeit np.clip(data, a_min=0.2, a_max=0.8) # numpy wrapper, calls .clip() on the Series
>>> %timeit data.clip(lower=0.2, upper=0.8) # pandas API method
>>> %timeit data._clip_with_scalar(0.2, 0.8) # lowest level python function
102 µs ± 1.54 µs per loop (mean ± std. dev. of 7 runs, 10000 loops each)
90.4 µs ± 1.01 µs per loop (mean ± std. dev. of 7 runs, 10000 loops each)
73.7 µs ± 805 ns per loop (mean ± std. dev. of 7 runs, 10000 loops each)
相对于总时间而言，这两个库在使用 C 代码之前的开销是相当可观的。对于 numpy，单个包装指令的执行时间与数值处理的时间一样多。仅在前两层函数调用中，Pandas 的开销就增加了约 30 倍。
为了隔离算法级别发生的事情，我们应该在更大的数组上检查这一点，并对相同的函数进行基准测试：
>>> data = pd.Series(np.random.random(1000000))
>>> %timeit np.clip(data.values, 0.2, 0.8)
>>> %timeit data.values.clip(0.2, 0.8)
2.85 ms ± 37.3 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)
2.85 ms ± 15.9 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)
>>> %timeit np.clip(data, a_min=0.2, a_max=0.8)
>>> %timeit data.clip(lower=0.2, upper=0.8)
>>> %timeit data._clip_with_scalar(0.2, 0.8)
12.3 ms ± 135 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)
12.3 ms ± 115 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)
12.2 ms ± 76.5 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)
现在两种情况下的 python 开销都可以忽略不计；相对于 100 万个值的计算时间，包装函数和参数检查的时间很短。但是存在 3-4 倍的速度差异，这可归因于数字实现。通过对源代码的一点研究，我们看到clip 的pandas 实现实际上使用了np.where，而不是np.clip：
def clip_where(data, lower, upper):
''' Actual implementation in pd.Series._clip_with_scalar (minus NaN handling). '''
result = data.values
result = np.where(result >= upper, upper, result)
result = np.where(result <= lower, lower, result)
return pd.Series(result)
def clip_clip(data, lower, upper):
''' What would happen if we used ndarray.clip instead. '''
return pd.Series(data.values.clip(lower, upper))
在进行条件替换之前分别检查每个布尔条件所需的额外工作似乎可以解释速度差异。同时指定upper 和lower 将导致4 次通过numpy 数组（两次不等式检查和两次对np.where 的调用）。对这两个函数进行基准测试表明，3-4 倍速比：
>>> %timeit clip_clip(data, lower=0.2, upper=0.8)
>>> %timeit clip_where(data, lower=0.2, upper=0.8)
11.1 ms ± 101 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)
2.97 ms ± 76.7 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)
我不确定为什么 pandas 开发人员会采用这种实现方式。 np.clip 可能是以前需要解决方法的较新 API 函数。还有一些比我在这里介绍的要多一些，因为 pandas 在运行最终算法之前会检查各种情况，这只是可能被调用的实现之一。
【讨论】：
【参考方案4】：性能不同的原因是因为 numpy 首先倾向于使用 getattr 搜索函数的 pandas 实现，而不是在传递 pandas 对象时在内置 numpy 函数中执行相同操作。
不是pandas对象上的numpy慢，是pandas版本。
当你这样做时
np.clip(pd.Series([1,2,3,4,5]),a_min=None,amax=1)
_wrapfunc 被调用：
# Code from source
def _wrapfunc(obj, method, *args, **kwds):
try:
return getattr(obj, method)(*args, **kwds)
由于_wrapfunc的getattr方法：
getattr(pd.Series([1,2,3,4,5]),'clip')(None, 1)
# Equivalent to `pd.Series([1,2,3,4,5]).clip(lower=None,upper=1)`
# 0 1
# 1 1
# 2 1
# 3 1
# 4 1
# dtype: int64
如果您完成了 pandas 的实施，那么您已经完成了大量的预检查工作。这就是为什么通过 numpy 完成 pandas 实现的功能在速度上有如此差异的原因。
不仅剪辑，功能
比如cumsum,cumprod,reshape,searchsorted,transpose，当你传递一个pandas对象时，更多的是使用它们的pandas版本而不是numpy。
看起来 numpy 正在处理这些对象，但实际上它是 pandas 函数。
【讨论】：
以上是关于为啥 numpy 函数在 pandas 系列/数据帧上这么慢？的主要内容，如果未能解决你的问题，请参考以下文章
为啥 Numpy 和 Pandas 数组比源数据消耗更多内存？ [关闭]
数据分析2 numpy(ndarray数组,属性,创建,索引切片,运算,函数,随机数), Pandas(Series创建,缺失值处理,特性,索引,DataFrame)
如何检查变量是 python 列表、numpy 数组还是 pandas 系列