python for循环优化_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倍），这是因为他返回的是生成器对象，并没有计算出结果，所以这个不算。

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

测试开始：

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倍。

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