[已解决]为什么这两个循环用时相差这么多？

冬雪雪冬

很无聊试了一下for循环和while循环的耗时情况，做了一个100000000次的循环，for循环内部为空（pass），while循环也仅有自加语句。
一个用时4秒多，一个用时11秒多。我理解虽然for循环里没有东西，但生成range也需花费时间的，难道range函数是用C语言编写的？
看来如果使用大循环还是for更高效些。

1. import time
   
2. time1 = time.time()
   
3. print('Starting...')
   
4. for i in range(100000000):
   
5.     pass
   
6. print('Finish.')
   
7. print('Time:',time.time() - time1)
   
8. 
   
9. 
   
10. time2 = time.time()
    
11. i = 0
    
12. print('Starting...')
    
13. while i <100000000:
    
14.     i += 1
    
15. print('Finish.')
    
16. print('Time:',time.time() - time2)

复制代码

输出：

1. Starting...
   
2. Finish.
   
3. Time: 4.221801042556763
   
4. Starting...
   
5. Finish.
   
6. Time: 11.12781310081482

复制代码

最佳答案

月排行榜 / 总排行榜

jerryxjr1220

2016-11-3 11:14:14

对于这个问题，我换了一个角度思考，同时对比了几种方案。
方案0：for循环

1. import time
   
2. start = time.time()
   
3. for i in range(100000000):
   
4.         pass
   
5. print (time.time()-start)

复制代码

结果：
5.08899998665

方案1：for循环（同时也进行自相加计算，与while执行相同的运算）

1. import time
   
2. start = time.time()
   
3. j = 0
   
4. for i in range(100000000):
   
5.         j += 1
   
6. print (time.time()-start)

复制代码

结果：
9.80500006676

方案2：while循环（判断和自相加运算）

1. import time
   
2. start = time.time()
   
3. j = 0
   
4. while j<100000000:
   
5.         j += 1
   
6. print (time.time()-start)

复制代码

结果：
7.43400001526

方案3：多线程while循环（排除判断，仅保留自相加运算）
【#方案3因为是去除了判断，所以用了2个线程：一个线程控制while循环；另一个线程控制计时】

1. from threading import Thread
   
2. import time
   
3. 
   
4. def running():
   
5.     global count
   
6.     count = 0
   
7.     while True:
   
8.         count += 1
   
9. 
   
10. def timedelay(sec=6.5):
    
11.     time.sleep(sec)
    
12.     print count
    
13. 
    
14. t1 = Thread(target=running,args=())
    
15. t2 = Thread(target=timedelay,args=())
    
16. 
    
17. t1.start()
    
18. t2.start()

复制代码

结果：
100466769
# 经过多次测试后，大约在6.5秒的时候，自相加接近100000000。

结论：
对比方案0和1：        自相加几乎要多增加1倍的运算时间
对比方案1和2：        都有自相加的情况下，while循环（加判断）比for循环用时要短。
对比方案2和3：        若while循环没有判断，仅保留自相加的情况下，要比既有自相加又有判断的while循环运算时间短。

综合运算速度快慢比较，由快到慢依次是：
空for循环 < 仅保留自相加的while循环 < 既有自相加又有判断的while循环 < 带自相加的for循环

跳转到最佳答案楼层

～风介～

个人感觉这个比较的例子不科学啊~ @小甲鱼

怎么还是菜鸟

1. import time as t
   
2. t1 = t.time()
   
3. print("开始。。。")
   
4. for i in range(100000000):
   
5.     pass
   
6. print("结束")
   
7. print("运行时间：",t.time()-t1)
   
8. 
   
9. 输出
   
10. 开始。。。
    
11. 结束
    
12. 运行时间： 30.499744415283203
    
13. 
    
14. 我的好慢，难道我的电脑太垃圾
    

复制代码

jerryxjr1220

range语句是个生成器，每次调用生成下一个值。while语句你执行时用了判断，等于执行了1亿次的比较，当然时间长了。自相加的耗时和range的生成速度相当。

xinshouxuexi

学习了

jerryxjr1220

对于这个问题，我换了一个角度思考，同时对比了几种方案。
方案0：for循环

1. import time
   
2. start = time.time()
   
3. for i in range(100000000):
   
4.         pass
   
5. print (time.time()-start)

复制代码

结果：
5.08899998665

方案1：for循环（同时也进行自相加计算，与while执行相同的运算）

1. import time
   
2. start = time.time()
   
3. j = 0
   
4. for i in range(100000000):
   
5.         j += 1
   
6. print (time.time()-start)

复制代码

结果：
9.80500006676

方案2：while循环（判断和自相加运算）

1. import time
   
2. start = time.time()
   
3. j = 0
   
4. while j<100000000:
   
5.         j += 1
   
6. print (time.time()-start)

复制代码

结果：
7.43400001526

方案3：多线程while循环（排除判断，仅保留自相加运算）
【#方案3因为是去除了判断，所以用了2个线程：一个线程控制while循环；另一个线程控制计时】

1. from threading import Thread
   
2. import time
   
3. 
   
4. def running():
   
5.     global count
   
6.     count = 0
   
7.     while True:
   
8.         count += 1
   
9. 
   
10. def timedelay(sec=6.5):
    
11.     time.sleep(sec)
    
12.     print count
    
13. 
    
14. t1 = Thread(target=running,args=())
    
15. t2 = Thread(target=timedelay,args=())
    
16. 
    
17. t1.start()
    
18. t2.start()

复制代码

结果：
100466769
# 经过多次测试后，大约在6.5秒的时候，自相加接近100000000。

结论：
对比方案0和1：        自相加几乎要多增加1倍的运算时间
对比方案1和2：        都有自相加的情况下，while循环（加判断）比for循环用时要短。
对比方案2和3：        若while循环没有判断，仅保留自相加的情况下，要比既有自相加又有判断的while循环运算时间短。

综合运算速度快慢比较，由快到慢依次是：
空for循环 < 仅保留自相加的while循环 < 既有自相加又有判断的while循环 < 带自相加的for循环

冬雪雪冬

jerryxjr1220 发表于 2016-11-3 11:14
对于这个问题，我换了一个角度思考，同时对比了几种方案。
方案0：for循环

比较的很详细。

jerryxjr1220

@冬雪雪冬
鉴于以上测试的结论，其实while循环的运行速度要快过于for循环（同等条件下）

冬雪雪冬

jerryxjr1220 发表于 2016-11-3 11:19
@冬雪雪冬
鉴于以上测试的结论，其实while循环的运行速度要快过于for循环（同等条件下）

for循环一般不用自加，还是快于带自加的while

jerryxjr1220

冬雪雪冬 发表于 2016-11-3 11:26
for循环一般不用自加，还是快于带自加的while

while循环中的自相加一般都是有具体意义的，比如是为了取得某个结果而计数等等，如果仅需要循环的话，可以直接 while True更快，而对于次数确定的循环，应该用for循环

冬雪雪冬

jerryxjr1220 发表于 2016-11-3 11:30
while循环中的自相加一般都是有具体意义的，比如是为了取得某个结果而计数等等，如果仅需要循环的话，可 ...

是的，能够确定次数的循环和对可迭代对象和迭代器的迭代用for更合适。

xinshouxuexi

大神说的对啊！