有很多问题(1、2、3)涉及单个系列中的计数值。

但是，关于计数两个或多个系列的组合的最佳方法的问题较少。提出了解决方案(1，2)，但没有讨论何时以及为什么应该使用它们。

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

1. 为什么 grouper 比 count 更高效？我希望 count 效率更高，因为它是在 C 中实现的。即使列数从 2 增加到 4，grouper 的卓越性能仍然存在。
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

¹ 这不是错字。

最佳答案

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 数据组合时要非常小心的原因。您可能经常看到的这个陷阱的一个基本示例是在 numpy 数组上使用内置 Python sum:sum(np.arange(10**5))实际上比纯 Python sum(range(10**5)) 慢一点，当然两者都比 np.sum(np.arange(10* *5)).

见 this video更深入地讨论这个话题。

作为特定于该问题的示例，观察以下时间，比较 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)

这两个时间之间的差异为您提供了对前面讨论的开销的合理估计。

不过，这还不是故事的结局。在 pandas 中构造一个 groupby 对象也涉及一些开销，至少与这个问题相关，因为有一些 groupby 元数据并不是仅仅为了获取 size，而 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 的任何 yield 都可以通过转换回 Series 来抵消，如果这是您想要的最终对象。

关于python - Pandas groupby.size vs series.value_counts vs collections.Counter与多个系列，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/50328246/