python 几个循环的效率测试

前言：对于我这种追求极致的人来说，效率很重要。

前面看到网上关于python循环的测评，到自己在项目中的应用，发现，并不是这么回事。所以，写下次博文，一次性了解这个问题。

语言版本：python3.6

平台：mac10.12.6

IDE：pycharm community 2018.2

关于循环的介绍：

1. for循环

　　我们最开始使用的循环。for循环的对象是可迭代对象。这里不详述。

2. 列表解析式

　　与之类似，字典解析式，集合解析式等。

3. map循环

　　与之类似有reduce，filter。这里不详述。

最终测试结果：

　map比列表解析式快一点点，

　列表解析式，大概比普通for循环快1.5倍。

　符合预期。（擦了一把汗！）

ps：有同学测试，说map速度远远大与列表推导式（大概快10000倍），这是因为他返回的是生成器对象，并没有计算出结果，所以这个不算。

以上测试，只是反映实际情况一种。并不能说这个是公理。仅仅给大家提供参考。博主不才。

测试开始：

import time

i = list(range(1000000)) # 生成测试序列

首先测试将数字转换成字符串:

i = list(range(1000000))
t = time.time()

lt_1 = []
for each in i:
    lt_1.append(str(each))
t2 = time.time()
print(t2 - t)
lt_2 = [lambda x: str(x) for x in i]
t3 = time.time()
print(t3 - t2)
lt_3 = list(map(lambda x: str(x), i))
t4 = time.time()
print(t4 - t3)

　　结果：

0.5911688804626465
1.0817310810089111
0.7083189487457275

0.4922349452972412
1.0927751064300537
0.4922208786010742

0.5165529251098633
1.100153923034668
0.5037112236022949

结果很意外，对吧，直接采用for循环，效率比列表解析式高一倍。和网络上的教程有出入。

说明：python3 map返回的是生成器（python2 map返回列表），需要使用list来驱动他得出结果。

接下来测试计算：

i = list(range(1000000))
t = time.time()

lt_1 = []

for each in i:

    each += 1

    lt_1.append(each)

t2 = time.time()

print(t2 - t)

lt_2 = [lambda x: x+1 for x in i]

t3 = time.time()

print(t3 - t2)

lt_3 = list(map(lambda x: x+1, i))

t4 = time.time()

print(t4 - t3)

结果：

0.349423885345459
1.0195939540863037
0.21120715141296387

0.4159379005432129
1.1701478958129883
0.21973800659179688

0.32332897186279297
1.2796630859375
0.36236000061035156

这里能看到，map显著比for循环高，for循环比列表解析式快，这个貌似还是有些出入。

ps：对每次结果不同的解释：由于系统本身还在运行其他程序。所以，在调用python时，不可避免需要等待其他程序结束。所以会出现第三次结果的情况。

我测试了很多遍，基本结论是，map比for循环大概快1.5倍。

但是，当我把结果打印出来时，发现，列表解析式内使用lamba，返回的是<function <listcomp>.<lambda> at 0x10e154510>，不会直接返回值：所以，更新下测试代码。

# -------------------------------

i = list(range(1000000))

t = time.time()

lt_1 = []

for each in i:

    each += 1

    lt_1.append(each)

t2 = time.time()

print(t2 - t)

def ggwp(x):

    return x+1

lt_2 = [ggwp(x) for x in i]

t3 = time.time()

print(t3 - t2)

lt_3 = list(map(lambda x: x+1, i))

t4 = time.time()

print(t4 - t3)

结果：

0.32393980026245117
0.2332770824432373
0.2076709270477295

0.3169240951538086
0.23195600509643555
0.20856499671936035

0.2955038547515869
0.23477792739868164
0.20820212364196777

所以，最终结果是：map速度最快，其次是列表解析式，最后是for循环。

同样更新第一个实验的测试代码：

i = list(range(1000000))

t = time.time()

lt_1 = []

for each in i:

    lt_1.append(str(each))

t2 = time.time()

# print(lt_1)

print(t2 - t)

def ggwp(x):

    return str(x)

lt_2 = [ggwp for x in i]

t3 = time.time()

# print(lt_2)

print(t3 - t2)

lt_3 = list(map(lambda x: str(x), i))

t4 = time.time()

# print(lt_3)

print(t4 - t3)

0.5370810031890869
0.08401012420654297
0.5191819667816162

发现，这个列表解析式，效率明显高于其他2个。于是，再次修改代码。

import time
# -------------------------------
i = list(range(1000000))
t = time.time()
lt_1 = []
for each in i:
    lt_1.append(str(each))
t2 = time.time()
# print(lt_1)
print(t2 - t)
def ggwp(x):
    return str(x)
lt_2 = [ggwp for x in i]
t3 = time.time()
# print(lt_2)
print(t3 - t2)
# lt_3 = list(map(lambda x: str(x), i))
lt_3 = list(map(ggwp, i))
t4 = time.time()
# print(lt_3)
print(t4 - t3)

0.480226993560791
0.06554508209228516
0.5108628273010254

是不是很神奇？WHY？为什么列表解析式的效率一下子提高这么多？

找到原因，因为红色的ggwp，只写了函数名。和之前的lambda类似，<function ggwp at 0x10e255488>。这个不符合要求。

修正后：

lt_2 = [ggwp(x) for x in i]

0.4904050827026367
0.5147149562835693
0.49653005599975586

0.5053339004516602
0.502392053604126
0.49272894859313965

0.49378418922424316
0.4825170040130615
0.5087540149688721

发现，速度差不多。基本相同。

再来测试乘法运算:

i = list(range(1000000))
t = time.time()
lt_1 = []
for each in i:
    each = each*each
    lt_1.append(each)
# print(lt_1)
t2 = time.time()
print(t2 - t)
def ggwp(x):
    return x*x
lt_2 = [ggwp(x) for x in i]
# print(lt_2)
t3 = time.time()
print(t3 - t2)
lt_3 = list(map(lambda x: x*x, i))
# print(lt_3)
t4 = time.time()
print(t4 - t3)

0.5563499927520752
0.3827509880065918
0.3217048645019531

0.3309590816497803
0.21875500679016113
0.2042989730834961

结果：map总体比列表解析式快一点。列表解析式大概比for循环快1.5倍。

----------------------------------------------------------------