python - 在 pandas 和/或 numpy 中高效简单地从长格式转换为宽格式

Question

我有一些以长格式提供的非常简单的数据，我想将其转换为数组。行/列索引是字符串(但可以是非顺序整数)，值是 float 。我在下面生成了一些简化的数据。请注意，真正的原始数据需要在转换为数组之前进行清理，因此起点是 pandas 数据框。

下面的所有解决方案都产生了预期的输出，但没有一个测试的解决方案看起来非常令人满意。 pandas pivot/pivot_table 解决方案很优雅，但比可读性差得多的 numpy 解决方案慢几个数量级。

以前有没有人遇到过这个问题，如果有，您是否找到了干净快速的解决方案？

生成数据

In [1]:
import pandas as pd
import numpy as np
import itertools
import random
import scipy.sparse

In [2]:
pairs = list(itertools.product('ABCD', repeat=2))
random.shuffle(pairs)
data = [(x,y,v) for (x,y),v in list(zip(pairs, np.linspace(0,1,len(pairs))))]
df = pd.DataFrame(data, columns=['row','col','value'], index=range(1,len(data)+1))

In [6]:
df

Out[6]:
    row     col     value
1   D   A   0.000000
2   B   A   0.066667
3   D   B   0.133333
4   C   C   0.200000
5   A   A   0.266667
6   B   B   0.333333
7   C   B   0.400000
8   A   B   0.466667
9   A   C   0.533333
10  C   D   0.600000
11  D   C   0.666667
12  C   A   0.733333
13  A   D   0.800000
14  D   D   0.866667
15  B   D   0.933333
16  B   C   1.000000

预期输出

array([[0.26666667, 0.46666667, 0.53333333, 0.8       ],
       [0.06666667, 0.33333333, 1.        , 0.93333333],
       [0.73333333, 0.4       , 0.2       , 0.6       ],
       [0.        , 0.13333333, 0.66666667, 0.86666667]])

方案一:在pandas中使用pivot_table

In [16]:
%%timeit
pivoted_arr1 = df.pivot_table(index='row', columns='col', values='value').values

3.77 ms ± 159 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)

解决方案 1b:在 pandas 中使用 pivot

In [17]:
%%timeit
pivoted_arr1b = df.pivot(index='row', columns='col', values='value').values

1.15 ms ± 6.98 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)

方案二:在scipy中使用coo_matrix

In [11]:
df = pd.DataFrame(data, columns=['row','col','value'], index=range(1,len(data)+1))

In [18]:
%%timeit
df_indexed = df.set_index(['row', 'col'])
pivoted_arr2 = scipy.sparse.coo_matrix((df_indexed.value, (df_indexed.index.labels[0], df_indexed.index.labels[1]))).toarray()

1.3 ms ± 29.2 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)

方案三:使用numpy

In [19]:
%%timeit
arr = df.values
rows, row_pos = np.unique(arr[:, 0], return_inverse=True)
cols, col_pos = np.unique(arr[:, 1], return_inverse=True)
pivoted_arr3 = np.zeros((len(rows), len(cols)))
pivoted_arr3[row_pos, col_pos] = arr[:, 2]

112 µs ± 487 ns per loop (mean ± std. dev. of 7 runs, 10000 loops each)

Answer 1

所以这样做的原因是 Pandas 的开销很大。因此，当输入较小时，一种复杂的 Pandas 方法比一些廉价的 numpy 方程慢也就不足为奇了。如此小的测试无法得出任何结论。

那么如果你用一个大的例子来测试会发生什么？

pairs = list(itertools.product('abcd', repeat=2))
random.shuffle(pairs)
data = [(x,y,v) for (x,y),v in list(zip(pairs, np.linspace(0,1,len(pairs))))]
df = pd.DataFrame(data, columns=['row','col','value'], index=range(1,len(data)+1))

枢轴小测试

In [21]:
%%timeit
pivoted_arr1b = df.pivot(index='row', columns='col', values='value').values
1000 loops, best of 3: 1.27 ms per loop

Numpy 小型测试

In [22]:
%%timeit
arr = df.values
rows, row_pos = np.unique(arr[:, 0], return_inverse=True)
cols, col_pos = np.unique(arr[:, 1], return_inverse=True)
pivoted_arr3 = np.zeros((len(rows), len(cols)))
pivoted_arr3[row_pos, col_pos] = arr[:, 2]
The slowest run took 4.68 times longer than the fastest. This could mean that an intermediate result is being cached.
10000 loops, best of 3: 120 µs per loop

做一个大测试

In [26]:
pairs = list(itertools.product('qwertyuiopasdfghjklzxcvbnmQWERTYUIOPASDFGHJKLZXCVBNM', repeat=2))
random.shuffle(pairs)
data = [(x,y,v) for (x,y),v in list(zip(pairs, np.linspace(0,1,len(pairs))))]
df = pd.DataFrame(data, columns=['row','col','value'], index=range(1,len(data)+1))

透视大型测试

In [27]:
%%timeit
pivoted_arr1b = df.pivot(index='row', columns='col', values='value').values
100 loops, best of 3: 2.03 ms per loop

透视大型测试

In [28]:
%%timeit
arr = df.values
rows, row_pos = np.unique(arr[:, 0], return_inverse=True)
cols, col_pos = np.unique(arr[:, 1], return_inverse=True)
pivoted_arr3 = np.zeros((len(rows), len(cols)))
pivoted_arr3[row_pos, col_pos] = arr[:, 2]
100 loops, best of 3: 2.27 ms per loop

所以对于大得多的测试用例，pandas 实际上更快。它不仅速度更快，而且时间复杂度也更好。当行数乘以 13 时，时间甚至没有翻倍。

如果你想在很多小矩阵上应用这个操作，这些都没有帮助。但这并不是 Pandas 的真正用途。