有许多问题（1,2,3）处理单个系列中的计数值。
然而，关于计算两个或多个系列组合的最佳方法的问题较少。给出了解决方案（1,2），但没有讨论何时以及为什么应该使用每个系列。
以下是三种潜在方法的一些基准测试。我有两个具体问题：
grouper比count更高效？我希望count更高效，因为它是在C中实现的。即使列数从2增加到4，grouper的卓越性能仍然存在。value_counter的表现比石斑鱼差这么多？这是由于构造列表的成本，还是列表中的序列？我知道输出是不同的，这也应该为选择提供信息。例如，使用连续的numpy数组与字典理解相比，按计数过滤更有效：
x, z = grouper(df), count(df)
%timeit x[x.values > 10] # 749µs
%timeit {k: v for k, v in z.items() if v > 10} # 9.37ms
然而，我的问题的重点是在系列和字典中构建可比结果的性能。我的C知识有限，但我希望任何能够指出这些方法背后逻辑的答案。
基准代码
import pandas as pd
import numpy as np
from collections import Counter
np.random.seed(0)
m, n = 1000, 100000
df = pd.DataFrame({'A': np.random.randint(0, m, n),
'B': np.random.randint(0, m, n)})
def grouper(df):
return df.groupby(['A', 'B'], sort=False).size()
def value_counter(df):
return pd.Series(list(zip(df.A, df.B))).value_counts(sort=False)
def count(df):
return Counter(zip(df.A.values, df.B.values))
x = value_counter(df).to_dict()
y = grouper(df).to_dict()
z = count(df)
assert (x == y) & (y == z), "Dictionary mismatch!"
for m, n in [(100, 10000), (1000, 10000), (100, 100000), (1000, 100000)]:
df = pd.DataFrame({'A': np.random.randint(0, m, n),
'B': np.random.randint(0, m, n)})
print(m, n)
%timeit grouper(df)
%timeit value_counter(df)
%timeit count(df)
基准结果
在python 3.6.2、熊猫0.20.3、numpy 1.13.1上运行
机器规格：Windows 7 64位，双核2.5 GHz，4GBRAM。
键：g=石斑鱼，v=value_counter，c=count。
m n g v c
100 10000 2.91 18.30 8.41
1000 10000 4.10 27.20 6.98[1]
100 100000 17.90 130.00 84.50
1000 100000 43.90 309.00 93.50
1这不是错别字。
zip（df. A.值，df.B.值）中实际上有一点隐藏的开销。这里的关键在于numpy数组以与Python对象完全不同的方式存储在内存中。
numpy数组，如np. arange（10），本质上存储为连续的内存块，而不是单个Python对象。相反，Python列表，如list（range（10）），作为指向单个Python对象（即整数0-9）的指针存储在内存中。这种差异是为什么numpy数组在内存中比Python等效列表小，以及为什么您可以在numpy数组上执行更快的计算的基础。
因此，当Counter消费zip时，需要将关联的元组创建为Python对象。这意味着Python需要从numpy数据中提取元组值，并在内存中创建相应的Python对象。这有明显的开销，这就是为什么在将纯Python函数与numpy数据结合时要非常小心。这种陷阱的一个基本例子是在numpy数组上使用内置的Pythonsum：sum（np. arange（10**5））实际上比纯Pythonsum（range（10**5））慢一点，这两个函数当然都比np.sum（np.arange（10**5））慢得多。
有关此主题的更深入讨论，请参阅此视频。
作为特定于此问题的示例，请观察以下时序，比较Counter在压缩numpy数组上的性能与相应的压缩Python列表。
In [2]: a = np.random.randint(10**4, size=10**6)
...: b = np.random.randint(10**4, size=10**6)
...: a_list = a.tolist()
...: b_list = b.tolist()
In [3]: %timeit Counter(zip(a, b))
455 ms ± 4.7 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)
In [4]: %timeit Counter(zip(a_list, b_list))
334 ms ± 4.2 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)
这两个计时之间的差异为您提供了前面讨论的开销的合理估计。
不过，这还不完全是故事的结尾。在熊猫中构造一个groupby对象也涉及一些开销，至少与这个问题相关，因为有一些groupby元数据对于获得size并不是绝对必要的，而Counter做了你关心的一件单一的事情。通常这种开销远低于Counter相关的开销，但是从一些快速的实验中，我发现当大多数组只由单个元素组成时，你实际上可以从Counter中获得稍微好一点的性能。
考虑以下时间安排（使用@Ballpoint Ben的sort=False建议），这些时间安排在少数大型组的范围内
def grouper(df):
return df.groupby(['A', 'B'], sort=False).size()
def count(df):
return Counter(zip(df.A.values, df.B.values))
for m, n in [(10, 10**6), (10**3, 10**6), (10**7, 10**6)]:
df = pd.DataFrame({'A': np.random.randint(0, m, n),
'B': np.random.randint(0, m, n)})
print(m, n)
%timeit grouper(df)
%timeit count(df)
这给了我下表：
m grouper counter
10 62.9 ms 315 ms
10**3 191 ms 535 ms
10**7 514 ms 459 ms
当然，如果您希望将其转换回Series作为最终对象，则可以通过转换回Series来抵消的任何收益。
