如何以最佳方式计算python列表中的元素

Question

这与here 几乎是同一个问题，只是我问的是排序结果的最有效解决方案。

我有一个列表（0到12之间随机大约10个整数），例如：

the_list = [5, 7, 6, 5, 5, 4, 4, 7, 5, 4]

我想创建一个函数，它返回按第一个元素排序的元组（项目、计数）列表，例如

output = [(4, 3), (5, 4), (6, 1), (7, 2)]

到目前为止我用过：

def dupli(the_list):
    return [(item, the_list.count(item)) for item in sorted(set(the_list))]

但是我调用这个函数几乎是一百万的时间，我需要尽可能快地完成它（python）。因此我的问题是：如何减少此功能的使用时间？ （内存呢？）

我玩了一会儿，但没有什么明显的发现：

from timeit import Timer as T
number=10000
setup = "the_list=[5, 7, 6, 5, 5, 4, 4, 7, 5, 4]"

stmt = "[(item, the_list.count(item)) for item in sorted(set(the_list))]"
T(stmt=stmt, setup=setup).timeit(number=number)

Out[230]: 0.058799982070922852

stmt = "L = []; \nfor item in sorted(set(the_list)): \n    L.append((item, the_list.count(item)))"
T(stmt=stmt, setup=setup).timeit(number=number)

Out[233]: 0.065041065216064453

stmt = "[(item, the_list.count(item)) for item in set(sorted(the_list))]"
T(stmt=stmt, setup=setup).timeit(number=number)

Out[236]: 0.098351955413818359

谢谢
克里斯托夫

Answer 1

更改排序位置可节省约 20%。

改变这个：

def dupli(the_list):
    return [(item, the_list.count(item)) for item in sorted(set(the_list))]

到这里：

def dupli(the_list):
    count = the_list.count # this optimization added courtesy of Sven's comment
    result = [(item, count(item)) for item in set(the_list)]
    result.sort()
    return result

这更快的原因是sorted 迭代器必须创建一个临时列表，而对结果进行排序。

编辑： 这是另一种比原来快 35% 的方法：

def dupli(the_list):
    counts = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
    for n in the_list:
        counts[n] += 1
    return [(i, counts[i]) for i in (0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12) if counts[i]]

注意：您可能希望随机化 the_list 的值。我的最终版本 dupli 使用其他随机数据集（import random; the_list=[random.randint(0,12) for i in xrange(10)]）测试得更快

Answer 2

我会尝试：

from collections import defaultdict
output = defaultdict(lambda: 0)
for item in the_list: output[item] += 1
return sorted(output.items())

Answer 3

利用“0 到 12 之间”的资格：

>>> the_list = [5, 7, 6, 5, 5, 4, 4, 7, 5, 4]
>>> answer1 = [0] * 13
>>> for i in the_list:
...    answer1[i] += 1
...
>>> answer1
[0, 0, 0, 0, 3, 4, 1, 2, 0, 0, 0, 0, 0]
>>> # You might be able to use that as-is:
...
>>> for i, v in enumerate(answer1):
...     if v: print i, v
...
4 3
5 4
6 1
7 2
>>> # Otherwise you can build the list that you specified:
...
>>> answer2 = [(i, v) for i, v in enumerate(answer1) if v]
>>> answer2
[(4, 3), (5, 4), (6, 1), (7, 2)]
>>>

Answer 4

编写自己的函数来计算一次遍历列表中的数字可能会更快。您正在为集合中的每个数字调用 count 函数，并且每个调用都需要遍历列表。

counts = {}
for n in the_list:
    if n not in counts:
        counts[n] = 0
    counts[n] += 1
sorted(counts.items())

Answer 5

这在空间和速度方面似乎相当理想：

def dupli2(list_):                                    
    dict_ = {}                                       
    for item in list_:                               
        dict_[item] = dict_.get(item, 0) + 1         
    return sorted(dict_.items())                    

或者这个：

def dupli3(list_):                                            
    last = None                                               
    list_ = sorted(list_)                                     

    i = 0                                                     
    for item in list_:                                        
        if item != last and last is not None:                 
            yield last, i                                     
            i = 0                                             
        i += 1                                                
        last = item                                           

    yield last, i 

但不确定速度。为此，我建议您使用 C 或使用 Psyco ;)

使用 Psyco：

In [33]: %timeit list(dupli3(test.the_list))
100000 loops, best of 3: 6.46 us per loop

In [34]: %timeit list(dupli2(test.the_list))
100000 loops, best of 3: 2.37 us per loop

In [35]: %timeit list(dupli(test.the_list))
100000 loops, best of 3: 2.7 us per loop

Answer 6

itertools.groupby 非常适合：

>>> from itertools import groupby
>>> the_list = [5, 7, 6, 5, 5, 4, 4, 7, 5, 4]
>>> gb = groupby(sorted(the_list))
>>> print [(i,len(list(j))) for i,j in gb]
[(4, 3), (5, 4), (6, 1), (7, 2)]