python升序数判断_Python判断列表是否已排序的各种方法及其性能分析

最新推荐文章于 2024-04-29 05:42:46 发布

weixin_39876595

最新推荐文章于 2024-04-29 05:42:46 发布

阅读量1.2k

点赞数

文章标签： python升序数判断

Test 1: HeadUnorderedList, list len: 200

IsListSorted_fastd(): False =>Time Elasped: 0.757 msec, repeated 1000 time(s).

IsListSorted_fastk(): False =>Time Elasped: 1.091 msec, repeated 1000 time(s).

IsListSorted_forloop(): False =>Time Elasped: 2.080 msec, repeated 1000 time(s).

IsListSorted_guess(): False =>Time Elasped: 2.123 msec, repeated 1000 time(s).

IsListSorted_allxran(): False =>Time Elasped: 2.255 msec, repeated 1000 time(s).

IsListSorted_allenumd(): False =>Time Elasped: 2.672 msec, repeated 1000 time(s).

IsListSorted_allenumo(): False =>Time Elasped: 3.021 msec, repeated 1000 time(s).

IsListSorted_allenumk(): False =>Time Elasped: 3.207 msec, repeated 1000 time(s).

IsListSorted_itermap(): False =>Time Elasped: 5.845 msec, repeated 1000 time(s).

IsListSorted_allzip(): False =>Time Elasped: 7.793 msec, repeated 1000 time(s).

IsListSorted_iterzip(): False =>Time Elasped: 9.667 msec, repeated 1000 time(s).

IsListSorted_iterzipf(): False =>Time Elasped: 9.969 msec, repeated 1000 time(s).

IsListSorted_numpy(): False =>Time Elasped: 16.203 msec, repeated 1000 time(s).

IsListSorted_sorted(): False =>Time Elasped: 45.742 msec, repeated 1000 time(s).

IsListSorted_reduce(): False =>Time Elasped: 145.447 msec, repeated 1000 time(s).

Test 1: HeadUnorderedList, list len: 200000

IsListSorted_fastd(): False =>Time Elasped: 0.717 msec, repeated 1000 time(s).

IsListSorted_fastk(): False =>Time Elasped: 0.876 msec, repeated 1000 time(s).

IsListSorted_allxran(): False =>Time Elasped: 2.104 msec, repeated 1000 time(s).

IsListSorted_itermap(): False =>Time Elasped: 6.062 msec, repeated 1000 time(s).

IsListSorted_iterzip(): False =>Time Elasped: 7.244 msec, repeated 1000 time(s).

IsListSorted_iterzipf(): False =>Time Elasped: 8.491 msec, repeated 1000 time(s).

IsListSorted_numpy(): False =>Time Elasped: 801.916 msec, repeated 1000 time(s).

IsListSorted_forloop(): False =>Time Elasped: 2924.755 msec, repeated 1000 time(s).

IsListSorted_guess(): False =>Time Elasped: 2991.756 msec, repeated 1000 time(s).

IsListSorted_allenumo(): False =>Time Elasped: 3025.864 msec, repeated 1000 time(s).

IsListSorted_allenumk(): False =>Time Elasped: 3062.792 msec, repeated 1000 time(s).

IsListSorted_allenumd(): False =>Time Elasped: 3190.896 msec, repeated 1000 time(s).

IsListSorted_allzip(): False =>Time Elasped: 6586.183 msec, repeated 1000 time(s).

IsListSorted_sorted(): False =>Time Elasped: 119974.955 msec, repeated 1000 time(s).

IsListSorted_reduce(): False =>Time Elasped: 154747.659 msec, repeated 1000 time(s).

可见，对于前段乱序的列表，无论其长短_fastd()和_fastk()的表现均为最佳。对于未排序列表，_sorted()需要进行排序，故性能非常差。然而，_reduce()性能最差。

实际上除_guess()和_sorted()外，其他函数都按升序检查列表。为安全起见，可仿照_guess()实现，先猜测排序方式，再进一步检查。

因为短列表耗时差异大多可以忽略，后续测试将不再包含短列表(但作者确实测试过)，仅关注长列表。除非特别说明，列表长度为10万级，重复计时1000次。

3.2 列表中段乱序

测试代码及结果如下：

def TestMiddUnorderedList():

TEST_NAME = 'MiddUnorderedList'; scale = int(1e5)

List = range(scale) + random.sample(xrange(scale), scale) + range(scale)

print 'Test 2: %s, list len: %d' %(TEST_NAME, len(List))

IsListSorted_numpy(numpy.array(List)) # 1572.295 msec

IsListSorted_guess(List) # 14540.637 msec

IsListSorted_itermap(List) # 21013.096 msec

IsListSorted_fastk(List) # 23840.582 msec

IsListSorted_allxran(List) # 31014.215 msec

IsListSorted_iterzip(List) # 33386.059 msec

IsListSorted_forloop(List) # 34228.006 msec

IsListSorted_allenumk(List) # 34416.802 msec

IsListSorted_allzip(List) # 42370.528 msec

IsListSorted_sorted(List) # 142592.756 msec

IsListSorted_reduce(List) # 187514.967 msec

ReportTimer()

为节省篇幅，已根据运行输出调整函数的调用顺序。下文也作如此处理。

3.3 列表后段乱序

测试代码及结果如下：

def TestTailUnorderedList():

TEST_NAME = 'TailUnorderedList'; scale = int(1e5)

List = range(scale, 0, -1) + random.sample(xrange(scale), scale)

print 'Test 3: %s, list len: %d' %(TEST_NAME, len(List))

IsListSorted_numpy(numpy.array(List), key=lambda dif: dif <= 0) # 980.789 msec

IsListSorted_guess(List) # 13273.862 msec

IsListSorted_itermap(List, key=lambda x, y: x >= y) # 21603.315 msec

IsListSorted_fastk(List, key=lambda x, y: x >= y) # 24183.548 msec

IsListSorted_allxran(List, key=lambda x, y: x >= y) # 32850.254 msec

IsListSorted_forloop(List, key=lambda x, y: x >= y) # 33918.848 msec

IsListSorted_iterzip(List, key=lambda x, y: x >= y) # 34505.809 msec

IsListSorted_allenumk(List, key=lambda x, y: x >= y) # 35631.625 msec

IsListSorted_allzip(List, key=lambda x, y: x >= y) # 40076.330 msec

ReportTimer()

3.4 列表完全乱序

测试代码及结果如下：

def TestUnorderedList():

TEST_NAME = 'UnorderedList'; scale = int(1e5)

List = random.sample(xrange(scale), scale)

print 'Test 4: %s, list len: %d' %(TEST_NAME, len(List))

IsListSorted_fastk(List) # 0.856 msec

IsListSorted_allxran(List) # 3.438 msec

IsListSorted_iterzip(List) # 7.233 msec

IsListSorted_itermap(List) # 7.595 msec

IsListSorted_numpy(numpy.array(List)) # 207.222 msec

IsListSorted_allenumk(List) # 953.423 msec

IsListSorted_guess(List) # 1023.575 msec

IsListSorted_forloop(List) # 1076.986 msec

IsListSorted_allzip(List) # 2062.821 msec

ReportTimer()

3.5 列表元素相同

测试代码及结果如下：

```python def TestSameElemList(): TEST_NAME = 'SameElemList'; scale = int(1e5) List = [5]*scale print 'Test 5: %s, list len: %d' %(TEST_NAME, len(List)) IsListSorted_numpy(numpy.array(List)) # 209.324 msec IsListSorted_sorted(List) # 2760.139 msec IsListSorted_guess(List) # 5843.942 msec IsListSorted_itermap(List) # 20609.704 msec IsListSorted_fastk(List) # 23035.760 msec IsListSorted_forloop(List) # 29043.206 msec IsListSorted_allenumk(List) # 29553.716 msec IsListSorted_allxran(List) # 30348.549 msec IsListSorted_iterzip(List) # 32806.217 msec ReportTimer()

3.6 列表升序

测试代码及结果如下：

def TestAscendingList():

TEST_NAME = 'AscendingList'; scale = int(1e5)

List = range(scale)

print 'Test 6: %s, list len: %d' %(TEST_NAME, len(List))

IsListSorted_numpy(numpy.array(List)) # 209.217 msec

IsListSorted_sorted(List) # 2845.166 msec

IsListSorted_fastd(List) # 5977.520 msec

IsListSorted_guess(List) # 10408.204 msec

IsListSorted_allenumd(List) # 15812.754 msec

IsListSorted_itermap(List) # 21244.476 msec

IsListSorted_fastk(List) # 23900.196 msec

IsListSorted_allenumo(List) # 28607.724 msec

IsListSorted_forloop(List) # 30075.538 msec

IsListSorted_allenumk(List) # 30274.017 msec

IsListSorted_allxran(List) # 31126.404 msec

IsListSorted_reduce(List) # 32940.108 msec

IsListSorted_iterzip(List) # 34188.312 msec

IsListSorted_iterzipf(List) # 34425.097 msec

IsListSorted_allzip(List) # 37967.447 msec

ReportTimer()

可见，列表已排序时，_sorted()的性能较占优势。

3.7 列表降序

剔除不支持降序的函数，测试代码及结果如下：

def TestDescendingList():

TEST_NAME = 'DescendingList'; scale = int(1e2)

List = range(scale, 0, -1)

print 'Test 7: %s, list len: %d' %(TEST_NAME, len(List))

IsListSorted_numpy(numpy.array(List), key=lambda dif: dif <= 0) # 209.318 msec

IsListSorted_sorted(List) # 5707.067 msec

IsListSorted_guess(List) # 10549.928 msec

IsListSorted_itermap(List, key=lambda x, y: x >= y) # 21529.547 msec

IsListSorted_fastk(List, key=lambda x, y: x >= y) # 24264.465 msec

import operator; IsListSorted_allenumo(List, oCmp=operator.ge) # 28093.035 msec

IsListSorted_forloop(List, key=lambda x, y: x >= y) # 30745.943 msec

IsListSorted_allenumk(List, key=lambda x, y: x >= y) # 32696.205 msec

IsListSorted_allxran(List, key=lambda x, y: x >= y) # 33431.473 msec

IsListSorted_allzip(List, key=lambda x, y: x >= y) # 34837.019 msec

IsListSorted_iterzip(List, key=lambda x, y: x >= y) # 35237.475 msec

IsListSorted_reduce(List, key=lambda x, y: x >= y) # 37035.270 msec

ReportTimer()

3.8 迭代器测试

参数为列表的函数，需要先将列表��过iter()函数转换为迭代器。注意，当iterable参数为iterator时，只能计时一次，因为该次执行将用尽迭代器。

测试代码如下：

def TestIter():

TEST_NAME = 'Iter'; scale = int(1e7)

List = range(scale) #升序

# List = random.sample(xrange(scale), scale) #乱序

print 'Test 8: %s, list len: %d' %(TEST_NAME, len(List))

iterL = iter(List); IsListSorted_guess(list(iterL))

iterL = iter(List); IsListSorted_sorted(iterL)

iterL = iter(List); IsListSorted_itermap(iterL)

iterL = iter(List); IsListSorted_iterzipf(iterL)

iterL = iter(List); IsListSorted_iterzip(iterL)

iterL = iter(List); IsListSorted_reduce(iterL)

iterL = iter(List); IsListSorted_fastd(iterL)

iterL = iter(List); IsListSorted_fastk(iterL, key=lambda x, y: x >= y)

ReportTimer()

运行结果如下：

Test 8: Iter, list len: 10000000 ---升序

IsListSorted_fastd(): True =>Time Elasped: 611.028 msec, repeated 1 time(s).

IsListSorted_sorted(): False =>Time Elasped: 721.751 msec, repeated 1 time(s).

IsListSorted_guess(): True =>Time Elasped: 1142.065 msec, repeated 1 time(s).

IsListSorted_itermap(): True =>Time Elasped: 2097.696 msec, repeated 1 time(s).

IsListSorted_fastk(): True =>Time Elasped: 2337.233 msec, repeated 1 time(s).

IsListSorted_reduce(): True =>Time Elasped: 3307.361 msec, repeated 1 time(s).

IsListSorted_iterzipf(): True =>Time Elasped: 3354.034 msec, repeated 1 time(s).

IsListSorted_iterzip(): True =>Time Elasped: 3442.520 msec, repeated 1 time(s).

Test 8: Iter, list len: 10000000 ---乱序

IsListSorted_fastk(): False =>Time Elasped: 0.004 msec, repeated 1 time(s).

IsListSorted_fastd(): False =>Time Elasped: 0.010 msec, repeated 1 time(s).

IsListSorted_iterzip(): False =>Time Elasped: 0.015 msec, repeated 1 time(s).

IsListSorted_itermap(): False =>Time Elasped: 0.055 msec, repeated 1 time(s).

IsListSorted_iterzipf(): False =>Time Elasped: 0.062 msec, repeated 1 time(s).

IsListSorted_guess(): False =>Time Elasped: 736.810 msec, repeated 1 time(s).

IsListSorted_reduce(): False =>Time Elasped: 8919.611 msec, repeated 1 time(s).

IsListSorted_sorted(): False =>Time Elasped: 12273.018 msec, repeated 1 time(s).

其中，_itermap()、_iterzip()、_iterzipf()、_reduce()、_fastd()、_fastk()可直接判断迭代器是否已排序。其他函数需将迭代器转换为列表后才能处理。_sorted()虽然接受迭代器参数，但sorted()返回列表，故无法正确判断迭代器顺序。

3.9 随机采样测试

综合以上测试，可知_fastk()和_numpy()性能较为突出，而且_rand()内置numpy方式。因此，以_fastk()和_numpy()为参照对象，测试代码如下(计时1次)：

def TestRandList():

scale = int(1e6)

List = random.sample(xrange(scale), scale) + range(scale)

print 'Test 1: %s, list len: %d' %('HeadUnorderedList', len(List))

IsListSorted_fastk(List)

IsListSorted_numpy(numpy.array(List))