前言：对于我这种追求极致的人来说，效率很重要。
前面看到网上关于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倍），这是因为他返回的是生成器对象，并没有计算出结果，所以这个不算。
以上测试，只是反映实际情况一种。并不能说这个是公理。仅仅给大家提供参考。博主不才。
测试开始：
importtime
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 ini:
each+= 1lt_1.append(each)
t2=time.time()print(t2 -t)
lt_2= [lambda x: x+1 for x ini]
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，返回的是. at 0x10e154510>，不会直接返回值：所以，更新下测试代码。
#-------------------------------
i = list(range(1000000))
t=time.time()
lt_1=[]for each ini:
each+= 1lt_1.append(each)
t2=time.time()print(t2 -t)defggwp(x):return x+1lt_2= [ggwp(x) for x ini]
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 ini:
lt_1.append(str(each))
t2=time.time()#print(lt_1)
print(t2 -t)defggwp(x):returnstr(x)
lt_2= [ggwp for x ini]
t3=time.time()#print(lt_2)
print(t3 -t2)
lt_3= list(map(lambdax: 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类似，。这个不符合要求。
修正后：
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
0.3309590816497803
0.21875500679016113
0.2042989730834961结果：map总体比列表解析式快一点。列表解析式大概比for循环快1.5倍。
----------------------------------------------------------------
