为什么 Pandas 中的 Pandas .loc 速度取决于 DataFrame 初始化？如何使 MultiIndex .loc 尽可能快？

我正在尝试提高代码性能。 我使用 Pandas 0.19.2 和 Python 3.5。

我刚刚意识到，根据数据帧初始化的不同，一次写入一大堆值的 .loc 速度有很大不同。

有人可以解释为什么，并告诉我什么是最好的初始化吗？它可以让我加快我的代码速度。

这是一个玩具示例。我创建“相似”的数据框。

import pandas as pd
import numpy as np


ncols = 1000
nlines = 1000

columns = pd.MultiIndex.from_product([[0], [0], np.arange(ncols)])
lines = pd.MultiIndex.from_product([[0], [0], np.arange(nlines)])

#df has multiindex
df = pd.DataFrame(columns = columns, index = lines)

#df2 has mono-index, and is initialized a certain way
df2 = pd.DataFrame(columns = np.arange(ncols), index = np.arange(nlines))
for i in range(ncols):
    df2[i] = i*np.arange(nlines)

#df3 is mono-index and not initialized
df3 = pd.DataFrame(columns = np.arange(ncols), index = np.arange(nlines))

#df4 is mono-index and initialized another way compared to df2
df4 = pd.DataFrame(columns = np.arange(ncols), index = np.arange(nlines))
for i in range(ncols):
    df4[i] = i

然后我给他们计时：

%timeit df.loc[(0, 0, 0), (0, 0)] = 2*np.arange(ncols)
1 loop, best of 3: 786 ms per loop
The slowest run took 69.10 times longer than the fastest. This could mean          that an intermediate result is being cached.

%timeit df2.loc[0] = 2*np.arange(ncols)
1000 loops, best of 3: 275 µs per loop

%timeit df3.loc[0] = 2*np.arange(ncols)
10 loops, best of 3: 31.4 ms per loop

%timeit df4.loc[0] = 2*np.arange(ncols)
10 loops, best of 3: 63.9 ms per loop

我是不是做错了什么？？？为什么 df2 的性能比其他的快得多？实际上，在多索引情况下，使用 .at 逐一设置元素要快得多。我在代码中实现了这个解决方案，但我对此并不满意，我认为必须有更好的解决方案。我更愿意保留我漂亮的多索引数据框，但如果我真的需要使用单索引，我会这样做。

def mod(df, arr, ncols):
    for j in range(ncols):
        df.at[(0, 0, 0),(0, 0, j)] = arr[j]
    return df

%timeit mod(df, np.arange(ncols), ncols)
The slowest run took 10.44 times longer than the fastest. This could mean  that an intermediate result is being cached.
100 loops, best of 3: 14.6 ms per loop

我在这里看到的一个区别是，您（有效）使用 dtype=int64 初始化了 df2 和 df4，但使用 dtype=object 初始化了 df 和 df3。对于 df2 和 df4，您可以使用空实值进行初始化：

#df has multiindex
df = pd.DataFrame(np.empty([ncols,nlines]), 
                  columns = columns, index = lines)

#df3 is mono-index and not initialized
df3 = pd.DataFrame(np.empty([ncols,nlines]),
                   columns = np.arange(ncols), index = np.arange(nlines))

您还可以添加dtype=int初始化为整数而不是实数，但这似乎与速度无关。

我得到的时间比你对 df4 的时间快得多（代码没有区别），所以这对我来说是个谜。无论如何，通过上述对 df 和 df3 的更改，df2 到 df4 的时间很接近，但不幸的是 df 仍然很慢。

%timeit df.loc[(0, 0, 0), (0, 0)] = 2*np.arange(ncols)
1 loop, best of 3: 418 ms per loop

%timeit df2.loc[:,0] = 2*np.arange(ncols)
10000 loops, best of 3: 185 µs per loop

%timeit df3.loc[0] = 2*np.arange(ncols)
10000 loops, best of 3: 116 µs per loop

%timeit df4.loc[:,0] = 2*np.arange(ncols)
10000 loops, best of 3: 196 µs per loop

编辑添加：

至于多索引的更大问题，我不知道，但有两个想法：

1）扩展@ptrj的评论，我很快就得到了他的建议（与简单索引方法大致相同）：

%timeit df.loc[(0, 0, 0) ] = 2*np.arange(ncols)
10000 loops, best of 3: 133 µs per loop

所以我再次得到了与你截然不同的时间（？）。 FWIW，当您想要整行带有 loc/iloc 时，建议使用:而不是将列引用留空：

timeit df.loc[(0, 0, 0), : ] = 2*np.arange(ncols)
1000 loops, best of 3: 223 µs per loop

但正如你所看到的，它有点慢，所以我不知道这里建议哪种方式。我想您通常应该按照文档的建议进行操作，但另一方面，这对您来说可能是速度上的重要差异。

2）或者，这相当暴力，但您可以保存索引/列，将索引/列重置为简单，然后将索引/列设置回多。虽然，这与仅仅采取没有什么不同df.values我怀疑对你来说不太方便。