blocks|key|1772877|text|简单地看一下字节码，While-循环有30行，for-循环有26行。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1772878|最后，不要真的认为这有多重要，但我个人更喜欢for-循环版本，因为它更容易阅读。|1772879|http://mergely.com/9P1cfnTr/|offset|length|1772880|我使用的代码：|1772881|def+fun(i):
++++i+=+i+%2B+1
++++return+i

def+test1():
++++i+=+0
++++result+=+1
++++while+result+!=+0+and+i+<+50:
++++++++result+=+fun(i)
++++++++print(i,+result)
++++++++i+%2B=+1

def+test2():
++++for+i+in+range(50):
++++++++result+=+fun(i)
++++++++print(i,+result)
++++++++if+result+==+0:+
++++++++++++break|code-block|syntax|javascript|1772882|entityMap|0|LINK|mutability|MUTABLE|url^0|0|0|0|S|0|0|0|0^^$0|@$1|2|3|4|5|6|7|V|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|W|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|X|8|@]|9|@$F|Y|G|Z|1|10]]|A|$]]|$1|H|3|I|5|6|7|11|8|@]|9|@]|A|$]]|$1|J|3|K|5|L|7|12|8|@]|9|@]|A|$M|N]]|$1|O|3|-4|5|6|7|13|8|@]|9|@]|A|$]]]|P|$Q|$5|R|S|T|A|$U|E]]]]

Looking purely at the bytecode, While-loop got 30 lines and the for-loop got 26 lines.

In the end, don't really think it matters that much but I personally prefer the for-loop version as it's easier to read.

<a href="http://mergely.com/9P1cfnTr/" rel="nofollow noreferrer">http://mergely.com/9P1cfnTr/</a> 

Code I used:

<pre><code>def fun(i):
 i = i + 1
 return i

def test1():
 i = 0
 result = 1
 while result != 0 and i &lt; 50:
 result = fun(i)
 print(i, result)
 i += 1

def test2():
 for i in range(50):
 result = fun(i)
 print(i, result)
 if result == 0: 
 break
</code></pre>

blocks|key|431923|text|在表现上有很小的差别。由于while循环在每次迭代中执行额外的布尔检查，所以它会稍微慢一些。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|431924|但是，对于大多数您想要评估的函数，有一种替代方法是首先使用循环，这比使用循环要快得多。见下面所附的例子。而且我确信还有更多的最佳实现。|431925|import+time

def+fun(step):
++++return+step+==+50000000

t1+=+time.time()
for+i+in+range(500000000):
++++result+=+fun(i)
#++++print(i,+result)
++++if+result+==+1:+
++++++++break
print("time+elapsed",+time.time()+-+t1)

t2+=+time.time()
i+=+0
result+=+0
while+result+!=+1+and+i+<+50000000:
++++result+=+fun(i)
#++++print(i,+result)
++++i+%2B=+1

print("and+here",+time.time()+-+t2)

import+numpy+as+np

t3+=+time.time()

foo+=+np.arange(500000000)
i+=+np.where(foo+==+50000000)
print("Alternative",+time.time()-t3)|code-block|syntax|javascript|431926|时间已过11.082087516784668
这里是14.429940938949585
备选方案1.4022133350372314|blockquote|431927|但是，如果您想/必须使用一个循环，那么for-循环通常是更多的Pythonic方式，正如在这个对相关问题的正确回答中所解释的那样。|offset|length|431928|编辑:+Chris+Rands下面的答案是从C代码的角度来解释的，并且使用了一个更精确的(尽管在我强迫这个例子是这样的宏级别上)计时模块。也要读他的答案。|431929|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/a/920692/5212031^0|0|0|0|0|18|E|0|0|0^^$0|@$1|2|3|4|5|6|7|Z|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|10|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|11|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|K|7|12|8|@]|9|@]|A|$]]|$1|L|3|M|5|6|7|13|8|@]|9|@$N|14|O|15|1|16]]|A|$]]|$1|P|3|Q|5|6|7|17|8|@]|9|@]|A|$]]|$1|R|3|-4|5|6|7|18|8|@]|9|@]|A|$]]]|S|$T|$5|U|V|W|A|$X|Y]]]]

There is a minute difference in performance. As the while loop performs an extra boolean check at every iteration, it is slightly slower. 

However, for most functions you would like to assess, there is an alternative to using a loop in the first place, which is way faster. See example attached below. And I am certain there are more optimal implementations..

<pre><code>import time

def fun(step):
 return step == 50000000

t1 = time.time()
for i in range(500000000):
 result = fun(i)
# print(i, result)
 if result == 1: 
 break
print("time elapsed", time.time() - t1)

t2 = time.time()
i = 0
result = 0
while result != 1 and i &lt; 50000000:
 result = fun(i)
# print(i, result)
 i += 1

print("and here", time.time() - t2)

import numpy as np

t3 = time.time()

foo = np.arange(500000000)
i = np.where(foo == 50000000)
print("Alternative", time.time()-t3)
</code></pre>

<blockquote>
 <blockquote>
 time elapsed 11.082087516784668
 
 and here 14.429940938949585
 
 Alternative 1.4022133350372314
 </blockquote>
</blockquote>

If you want to/have to use a loop however, the for-loop is in general the more Pythonic way to go, as is explained <a href="https://stackoverflow.com/a/920692/5212031">in this nice answer to a related question</a>

EDIT: Chris Rands's answer below explains it from the C-code point of view, and uses a more accurate (although on such macro-levels as I forced this example to be, that would not really matter) timing module. Do read his answer as well.

blocks|key|1728483|text|for循环的性能略高于while，因为在C中实现。，同时对%2B=操作进行解释，并要求创建/销毁更多操作和对象。您可以使用模块来说明性能差异，例如：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1728484|from+timeit+import+timeit

def+for_func():
++++for+i+in+range(10000):
++++++++result+=+int(i)
++++++++if+result+==+-1:+
++++++++++++break

def+while_func():
++++i+=+0
++++result+=+1
++++while+result+!=+-1+and+i+<+10000:
++++++++result+=+int(i)
++++++++i+%2B=+1


print(timeit(lambda:+for_func(),+number+=+1000))
#+1.03937101364
print(timeit(lambda:+while_func(),+number+=+1000))
#+1.21670079231+|code-block|syntax|javascript|1728485|for循环可以说是在绝大多数情况下，当您希望在可迭代对象上迭代时，要使用更多Pythonic语言。。此外，引用Python+wiki：“因为Python中的for循环非常强大，但是很少使用，除非需要用户的输入”。使用break语句本身没有什么非Pythonic的。|1728486|可读性主要是主观的，我认为for循环的可读性也更强，但它可能取决于您以前的编程背景和经验。|1728487|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/a/869295/6260170|1|https://stackoverflow.com/a/869347/6260170|2|https://docs.python.org/3/library/timeit.html|3|https://stackoverflow.com/a/920692/6260170|4|https://wiki.python.org/moin/WhileLoop^0|0|3|B|5|T|2|J|6|0|1A|4|1|1N|2|2|0|0|0|3|30|5|9|14|3|1J|B|4|0|D|3|0^^$0|@$1|2|3|4|5|6|7|14|8|@$9|15|A|16|B|C]|$9|17|A|18|B|C]|$9|19|A|1A|B|C]]|D|@$9|1B|A|1C|1|1D]|$9|1E|A|1F|1|1G]|$9|1H|A|1I|1|1J]]|E|$]]|$1|F|3|G|5|H|7|1K|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|1L|8|@$9|1M|A|1N|B|C]|$9|1O|A|1P|B|C]]|D|@$9|1Q|A|1R|1|1S]|$9|1T|A|1U|1|1V]]|E|$]]|$1|M|3|N|5|6|7|1W|8|@$9|1X|A|1Y|B|C]]|D|@]|E|$]]|$1|O|3|-4|5|6|7|1Z|8|@]|D|@]|E|$]]]|P|$Q|$5|R|S|T|E|$U|V]]|W|$5|R|S|T|E|$U|X]]|Y|$5|R|S|T|E|$U|Z]]|10|$5|R|S|T|E|$U|11]]|12|$5|R|S|T|E|$U|13]]]]

The <code>for</code> loop is slightly more performant than the <code>while</code> because <a href="https://stackoverflow.com/a/869295/6260170"><code>range()</code> is implemented in C</a>, meanwhile the <code>+=</code> operation is interpreted and requires <a href="https://stackoverflow.com/a/869347/6260170">more operations</a> and object creation/ destruction. You can illustrate the performance difference using the <a href="https://docs.python.org/3/library/timeit.html" rel="noreferrer"><code>timeit</code> module</a>, for example:

<pre><code>from timeit import timeit

def for_func():
 for i in range(10000):
 result = int(i)
 if result == -1: 
 break

def while_func():
 i = 0
 result = 1
 while result != -1 and i &lt; 10000:
 result = int(i)
 i += 1


print(timeit(lambda: for_func(), number = 1000))
# 1.03937101364
print(timeit(lambda: while_func(), number = 1000))
# 1.21670079231 
</code></pre>

The <code>for</code> loop is arguably <a href="https://stackoverflow.com/a/920692/6260170">more Pythonic in the vast majority of cases when you wish to iterate over an iterable object</a>. Furthermore, to quote the <a href="https://wiki.python.org/moin/WhileLoop" rel="noreferrer">Python wiki</a>: "As the for loop in Python is so powerful, while is rarely used except in cases where a user's input is required". There is nothing un-Pythonic about using a <code>break</code> statement per se.

Readability is mostly subjective, I would say the <code>for</code> loop is more readable too, but it probably depends on your previous programming background and experience.

blocks|key|1728513|text|最好的方法是根本不显式地循环。救援的迭代工具：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1728514|from+itertools+import+takewhile
it+=+((x,+f(x))+for+x+in+range(50))+#+first+you+define+the+resulting+view
it+=+takewhile(lambda+y:+y[1]+!=+0,+it)+#+define+when+to+stop+iterating
list(map(print,+it))+#+if+you+want+to+print+it|code-block|syntax|javascript|1728515|它比循环要快得多|unordered-list-item|1728516|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|M|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|I|7|N|8|@]|9|@]|A|$]]|$1|J|3|-4|5|6|7|O|8|@]|9|@]|A|$]]]|K|$]]

best way would be not to loop explicitly at all. itertools for the rescue:

<pre><code>from itertools import takewhile
it = ((x, f(x)) for x in range(50)) # first you define the resulting view
it = takewhile(lambda y: y[1] != 0, it) # define when to stop iterating
list(map(print, it)) # if you want to print it
</code></pre>

+ it would be a lot a lot faster than looping

blocks|key|432079|text|你根本不需要休息声明..。for循环将自动终止。你所需要的就是：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|432080|for+i+in+range(50):
++++result+=+fun(i)
++++print(i,+result)|code-block|syntax|javascript|432081|这，永远是可读性更强的imho。|432082|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

You do NOT need the break statement at all... for loops will terminate automatically. All you need is:

<pre><code>for i in range(50):
 result = fun(i)
 print(i, result)
</code></pre>

This, will always be more readable imho.

blocks|key|1773189|text|我非常肯定，当您比较和和用于循环时，您不应该关心性能，所以主要的问题是可读性。|type|unstyled|depth|inlineStyleRanges|offset|length|style|BOLD|entityRanges|data|1773190|首先，当然|1773191|for+i+in+range(50):
++++result+=+fun(i)
++++print(i,+result)
++++if+result+==+0:+
++++++++break|code-block|syntax|javascript|1773192|比|1773193|i+=+0
result+=+1
while+result+!=+0+and+i+<+50:
++++result+=+fun(i)
++++print(i,+result)
++++i+%2B=+1|1773194|因为在阅读简单循环时，不需要记住一些类似C的变量。|1773195|@quidkid的解决方案相当优雅，但有一点很好|1773196|it+=+takewhile(lambda+y:+y[1]+!=+0,+((x,+f(x))+for+x+in+range(50)))|1773197|只在非常简单的示例上工作，并且会丢失可读性，因为您需要添加一些附加功能。|1773198|正如我所看到的，代码中的主要问题是您的函数不是纯的，所以也许您应该这样做：|1773199|def+some_generator():
++++for+i+in+range(50):
++++++++result+=+fun(i)
++++++++yield+result,+i
++++++++if+result+==+0:
++++++++++++return+

for+x+in+some_generator():
++++print+x
++++do_something_else_with(x[1])|1773200|entityMap^0|A|1|C|2|0|0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|14|8|@$9|15|A|16|B|C]|$9|17|A|18|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|19|8|@]|D|@]|E|$]]|$1|H|3|I|5|J|7|1A|8|@]|D|@]|E|$K|L]]|$1|M|3|N|5|6|7|1B|8|@]|D|@]|E|$]]|$1|O|3|P|5|J|7|1C|8|@]|D|@]|E|$K|L]]|$1|Q|3|R|5|6|7|1D|8|@]|D|@]|E|$]]|$1|S|3|T|5|6|7|1E|8|@]|D|@]|E|$]]|$1|U|3|V|5|J|7|1F|8|@]|D|@]|E|$K|L]]|$1|W|3|X|5|6|7|1G|8|@]|D|@]|E|$]]|$1|Y|3|Z|5|6|7|1H|8|@]|D|@]|E|$]]|$1|10|3|11|5|J|7|1I|8|@]|D|@]|E|$K|L]]|$1|12|3|-4|5|6|7|1J|8|@]|D|@]|E|$]]]|13|$]]

I'm pretty sure you should not care about performance when you are comparing while and for loops, so the main question is about readability.

first of all, of course 

<pre><code>for i in range(50):
 result = fun(i)
 print(i, result)
 if result == 0: 
 break
</code></pre>

is much better than

<pre><code>i = 0
result = 1
while result != 0 and i &lt; 50:
 result = fun(i)
 print(i, result)
 i += 1
</code></pre>

because you don't need to keep some C-like variables in mind when you are reading simple loop

@quidkid's solution is pretty elegant, but it is a good point that 

<pre><code>it = takewhile(lambda y: y[1] != 0, ((x, f(x)) for x in range(50)))
</code></pre>

works only on quite simple examples and will lost readability as you will require to add some additional functionality

As i can see, the main problem in your code is that your function is not pure, so maybe you should do something like this:

<pre><code>def some_generator():
 for i in range(50):
 result = fun(i)
 yield result, i
 if result == 0:
 return 

for x in some_generator():
 print x
 do_something_else_with(x[1])
</code></pre>

blocks|key|1728630|text|采用函数方法，创建一个执行操作并返回终止谓词值的本地闭包。然后遍历输入，直到完成为止。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1728631|def+action(i):
++++result+=+fun(i)
++++print(i,+result)
++++return+result+==+0

list(itertools.takewhile(action,+range(50)))++#+non-pythonic+wasted+list|code-block|syntax|javascript|1728632|终止一系列操作的另一种方法是：|1728633|terminated+=+reduce(lambda+done,+i:+done+or+action(i),+range(50),+False)++#+extra+unnecessary+iterations|1728634|看来我们回到了break语句|offset|length|style|CODE|1728635|for+i+in+range(50):
++++if+action(i):
++++++++break|1728636|entityMap^0|0|0|0|0|7|5|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|V|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|W|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|X|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|Y|8|@$M|Z|N|10|O|P]]|9|@]|A|$]]|$1|Q|3|R|5|D|7|11|8|@]|9|@]|A|$E|F]]|$1|S|3|-4|5|6|7|12|8|@]|9|@]|A|$]]]|T|$]]

Taking the functional approach, create a local closure that performs the action and returns the termination predicate's value. Then iterate over the inputs until done.

<pre><code>def action(i):
 result = fun(i)
 print(i, result)
 return result == 0

list(itertools.takewhile(action, range(50))) # non-pythonic wasted list
</code></pre>

Another way of terminating a sequence of actions is:

<pre><code>terminated = reduce(lambda done, i: done or action(i), range(50), False) # extra unnecessary iterations
</code></pre>

Looks like we are back to the <code>break</code> statement for pythonicness

<pre><code>for i in range(50):
 if action(i):
 break
</code></pre>

blocks|key|432155|text|如果效率是你想要的，那么就使用生成器函数。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|432156|In+[1]:+def+get_result():++++++++++++++++++++++++++++
++++...:+++++for+i+in+xrange(50):++++++++++++++++++++++++++++
++++...:+++++++++result+=+fun(i)
++++...:+++++++++yield+result,+i
++++...:+++++++++if+result+==+0:
++++...:+++++++++++++break
++++...:+++++++++

In+[2]:+generator_func+=+get_result()

In+[3]:+for+result,+i+in+generator_func:
++++...:+++++print+result,+i
++++...:+++|code-block|syntax|javascript|432157|ipython中%25timeit的结果|432158|最慢的跑速度是最快跑的6.15倍。这可能意味着正在缓存一个中间结果。10000个循环，每个循环最佳3:+30.9s|blockquote|432159|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|N|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|O|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|P|8|@]|9|@]|A|$]]|$1|I|3|J|5|K|7|Q|8|@]|9|@]|A|$]]|$1|L|3|-4|5|6|7|R|8|@]|9|@]|A|$]]]|M|$]]

If efficiency is what you are looking for then use generator functions

<pre><code>In [1]: def get_result(): 
 ...: for i in xrange(50): 
 ...: result = fun(i)
 ...: yield result, i
 ...: if result == 0:
 ...: break
 ...: 

In [2]: generator_func = get_result()

In [3]: for result, i in generator_func:
 ...: print result, i
 ...: 
</code></pre>

The result of %timeit in ipython

<blockquote>
 The slowest run took 6.15 times longer than the fastest. This could
 mean that an intermediate result is being cached. 10000 loops, best of
 3: 30.9 µs per loop
</blockquote>

In Python I can implement a loop with step counter and a stop condition as a classical case of for loop :

<pre><code>for i in range(50):
 result = fun(i)
 print(i, result)
 if result == 0: 
 break
</code></pre>

where <code>fun(x)</code> is some arbitrary function from integers to integers. 

I always in doubts if that is the best way to code it (Pythonically, and in terms of readability and efficiency) or is it better to run it as a while loop:

<pre><code>i = 0
result = 1
while result != 0 and i &lt; 50:
 result = fun(i)
 print(i, result)
 i += 1
</code></pre>

which approach is better? In particular - I'm concerned about the usage of <code>break</code> statement which doesn't feel right.

End loop with counter and condition

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

在Python中，我可以实现一个带有步骤计数器和停止条件的循环，作为for循环的一个经典情况：for i in range(50):    result = fun(i)    print(i, result)    if result == 0:         break其中fun(x)是从整数到整数的任意函数。我...

问带计数器和条件的端环
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问带计数器和条件的端环EN