熊猫groupby.size vs series.value_counts vs collections。具有多个系列的计数器

Question

有很多问题处理的计数值 单一系列 。

但是，很少有问题希望找到 对两个或多个系列的组合
进行计数的最佳方法。解决方案呈现），但是，当和为什么要使用的每个没有讨论。

以下是三种潜在方法的一些基准测试。我有两个具体问题：

1. 为什么grouper比这更有效count？我希望count这样会更高效，因为它是用C语言实现的。grouper即使列数从2增加到4 ，持久化的卓越性能仍然存在。
2. 为什么value_counter表现grouper这么差？这是由于构建列表或从列表创建序列的成本吗？

我了解输出是不同的，这也应该为选择提供依据。例如，对于连续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，pandas 0.20.3，numpy 1.13.1上运行

机器规格：Windows 7 64位，双核2.5 GHz，4GB RAM。

键：g = grouper，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这不是错字。

Answer 1

实际上，中有一些隐藏的开销zip(df.A.values,df.B.values)。关键在于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数据结合使用时要非常小心。您可能会经常看到的这种陷阱的一个基本示例是在sumnumpy数组上使用内置的Python
：
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当大多数组仅由单个元素组成时，您实际上可以获得略微更好的性能。

考虑以下几个时间安排（使用@BallpointBen的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

当然，如果您要作为最终对象，则Counter可以通过转换回a来抵消的任何收益Series。