熊猫数据帧计数行值答案

【问题标题】：pandas dataframe count row values熊猫数据帧计数行值
【发布时间】：2013-12-20 14:54:56
【问题描述】：

我有一个如下的单词列表。

wordlist = ['p1','p2','p3','p4','p5','p6','p7']

数据框如下所示。

df = pd.DataFrame({'id' : [1,2,3,4],
                'path'  : ["p1,p2,p3,p4","p1,p2,p1","p1,p5,p5,p7","p1,p2,p3,p3"]})

输出：

    id path

    1 p1,p2,p3,p4
    2 p1,p2,p1
    3 p1,p5,p5,p7
    4 p1,p2,p3,p3

我想计算路径数据以获得以下输出。有没有可能得到这样的转变？

id p1 p2 p3 p4 p5 p6 p7
1  1  1  1  1  0  0  0
2  2  1  0  0  0  0  0
3  1  0  0  0  2  0  1
4  1  1  2  0  0  0  0

【问题讨论】：

wordlist 中的单词真的就这么简单吗，或者它们可以互为子串？即使它们可以是子字符串，下面的答案也是你想要的 95%。

标签： python pandas dataframe

【解决方案1】：

我认为这将是有效的

# create Series with dictionaries
>>> from collections import Counter
>>> c = df["path"].str.split(',').apply(Counter)
>>> c
0    {u'p2': 1, u'p3': 1, u'p1': 1, u'p4': 1}
1                        {u'p2': 1, u'p1': 2}
2              {u'p1': 1, u'p7': 1, u'p5': 2}
3              {u'p2': 1, u'p3': 2, u'p1': 1}

# create DataFrame
>>> pd.DataFrame({n: c.apply(lambda x: x.get(n, 0)) for n in wordlist})
   p1  p2  p3  p4  p5  p6  p7
0   1   1   1   1   0   0   0
1   2   1   0   0   0   0   0
2   1   0   0   0   2   0   1
3   1   1   2   0   0   0   0

更新

另一种方法：

>>> dfN = df["path"].str.split(',').apply(lambda x: pd.Series(Counter(x)))
>>> pd.DataFrame(dfN, columns=wordlist).fillna(0)
   p1  p2  p3  p4  p5  p6  p7
0   1   1   1   1   0   0   0
1   2   1   0   0   0   0   0
2   1   0   0   0   2   0   1
3   1   1   2   0   0   0   0

更新 2

一些粗略的性能测试：

>>> dfL = pd.concat([df]*100)
>>> timeit('c = dfL["path"].str.split(",").apply(Counter); d = pd.DataFrame({n: c.apply(lambda x: x.get(n, 0)) for n in wordlist})', 'from __main__ import dfL, wordlist; import pandas as pd; from collections import Counter', number=100)
0.7363274283027295

>>> timeit('splitted = dfL["path"].str.split(","); d = pd.DataFrame({name : splitted.apply(lambda x: x.count(name)) for name in wordlist})', 'from __main__ import dfL, wordlist; import pandas as pd', number=100)
0.5305424618886718

# now let's make wordlist larger
>>> wordlist = wordlist + list(lowercase) + list(uppercase)

>>> timeit('c = dfL["path"].str.split(",").apply(Counter); d = pd.DataFrame({n: c.apply(lambda x: x.get(n, 0)) for n in wordlist})', 'from __main__ import dfL, wordlist; import pandas as pd; from collections import Counter', number=100)
1.765344003293876

>>> timeit('splitted = dfL["path"].str.split(","); d = pd.DataFrame({name : splitted.apply(lambda x: x.count(name)) for name in wordlist})', 'from __main__ import dfL, wordlist; import pandas as pd', number=100)
2.33328927599905

更新 3

阅读this topic后发现Counter真的很慢。您可以使用defaultdict 对其进行一些优化：

>>> def create_dict(x):
...     d = defaultdict(int)
...     for c in x:
...         d[c] += 1
...     return d
>>> c = df["path"].str.split(",").apply(create_dict)
>>> pd.DataFrame({n: c.apply(lambda x: x[n]) for n in wordlist})
   p1  p2  p3  p4  p5  p6  p7
0   1   1   1   1   0   0   0
1   2   1   0   0   0   0   0
2   1   0   0   0   2   0   1
3   1   1   2   0   0   0   0

还有一些测试：

>>> timeit('c = dfL["path"].str.split(",").apply(create_dict); d = pd.DataFrame({n: c.apply(lambda x: x[n]) for n in wordlist})', 'from __main__ import dfL, wordlist, create_dict; import pandas as pd; from collections import defaultdict', number=100)
0.45942801555111146

# now let's make wordlist larger
>>> wordlist = wordlist + list(lowercase) + list(uppercase)
>>> timeit('c = dfL["path"].str.split(",").apply(create_dict); d = pd.DataFrame({n: c.apply(lambda x: x[n]) for n in wordlist})', 'from __main__ import dfL, wordlist, create_dict; import pandas as pd; from collections import defaultdict', number=100)
1.5798653213942089

【讨论】：

我的问题并不像我问的问题那么简单。这就是为什么花了一点时间来接受答案。谢谢:)
请注意，如果您没有更大的词表（或与词表相比相对较大的数据框），即使您的最后一个解决方案也比我的慢。我想说的是，取决于确切的实际用例:-)而且我喜欢我的简单。
@joris 同意简单性和可读性也很重要。如果我有时间，我会尝试用字典考虑简单的解决方案，我认为应该有一个 :)

【解决方案2】：

您可以使用矢量化字符串方法str.count()（请参阅docs 和reference），并将单词列表中的每个元素都提供给新的数据框：

In [4]: pd.DataFrame({name : df["path"].str.count(name) for name in wordlist})
Out[4]:
    p1  p2  p3  p4  p5  p6  p7
id
1    1   1   1   1   0   0   0
2    2   1   0   0   0   0   0
3    1   0   0   0   2   0   1
4    1   1   2   0   0   0   0

更新：对 cmets 的一些回答。实际上，如果字符串可以是彼此的子字符串，这将不起作用（但 OP 应该在那时澄清它）。如果是这样的话，这将起作用（而且速度也更快）：

splitted = df["path"].str.split(",")
pd.DataFrame({name : splitted.apply(lambda x: x.count(name)) for name in wordlist})

还有一些测试来支持我更快的说法 :-)
当然，我不知道实际的用例是什么，但我将数据框放大了一点（只是重复了 1000 次，然后差异更大）：

In [37]: %%timeit
   ....: splitted = df["path"].str.split(",")
   ....: pd.DataFrame({name : splitted.apply(lambda x: x.count(name)) for name i
n wordlist})
   ....:
100 loops, best of 3: 17.9 ms per loop

In [38]: %%timeit
   ....: pd.DataFrame({name:df["path"].str.count(name) for name in wordlist})
   ....:
10 loops, best of 3: 23.6 ms per loop

In [39]: %%timeit
   ....: c = df["path"].str.split(',').apply(Counter)
   ....: pd.DataFrame({n: c.apply(lambda x: x.get(n, 0)) for n in wordlist})
   ....:
10 loops, best of 3: 42.3 ms per loop

In [40]: %%timeit
   ....: dfN = df["path"].str.split(',').apply(lambda x: pd.Series(Counter(x)))
   ....: pd.DataFrame(dfN, columns=wordlist).fillna(0)
   ....:
1 loops, best of 3: 715 ms per loop

我还对wordlist 中的更多元素进行了测试，得出的结论是：如果你有一个更大的数据框，而wordlist 中的元素数量相对较少，我的方法会更快，如果你有一个大的wordlist使用来自@RomanPekar 的Counter 的方法可能更快（但只有最后一个）。

【讨论】：

这在示例中有效，但在实践中可能是一个糟糕的想法，因为某些单词会被重复计算（例如，单词“cat”中的“at”）。希望问题的修订可以解决这个问题。
@joris ：这也可以应用，但对于我真正的问题，我使用了 Roman Pekar 的方法。谢谢:)
@U2EF1 是的，无论如何，这种方法对我来说似乎效率不高，因为它多次遍历字符串。这就是为什么我建议先拆分字符串。
@RomanPekar 请注意，我的解决方案更快，尽管它对您来说似乎效率不高。而且我个人认为它更简单。
@joris 很高兴知道，可以添加一些测试吗？ :) 我认为如果字数很大，效率可能会降低。并不是我不喜欢这个解决方案，只是不喜欢一遍又一遍地迭代字符串的想法。

【解决方案3】：

类似的东西：

df1 = pd.DataFrame([[path.count(p) for p in wordlist] for path in df['path']],columns=['p1','p2','p3','p4','p5','p6','p7'])

【讨论】：