什么时候应该使用 for 循环或 while 循环？

Question

I am confused about when using a while-loop or for-loop is better? I am particularly worried about producing optimized answers to coding questions. I find myself solving problems just to find out a while-loop would've been faster but am confused about what leads people to choose to use it instead of a for-loop, like what criteria should I be looking for? Here's an example of a coding question I answered which checks if a string of parentheses is balanced.

def parenCheck(str):
    stack = Stack()
    for x in str:
        if x == '(':
            stack.push(x)
        else:
            if stack.isEmpty():
                return False
            else:
                stack.pop()
    return stack.isEmpty()

Here is the answer I saw for it , which I know is faster because it doesnt use a for-loop:

def parChecker(symbolString):
    s = Stack()
    balanced = True
    index = 0
    while index < len(symbolString) and balanced:
        symbol = symbolString[index]
        if symbol == "(":
            s.push(symbol)
        else:
            if s.isEmpty():
                balanced = False
            else:
                s.pop()

        index = index + 1

    if balanced and s.isEmpty():
        return True
    else:
        return False

Answer 1

This cannot be decided by your code that while loop worked faster than for loop. As of your question on when to use while and for loop, it is decided on the basis of whether we know the number of iterations. If number of iterations is known, for loop is preferred, whereas while loop is preferred when the iterations are indefinite.

for (int i : mynumber_list)

Iterator it  = mynumber_list.iterator()
while (it.hasNext())

As can be seen from above, for loop is more readable, simple, and easy in traversing. Moreover, iterator.hasNext() has a very high probability of entering into an infinite loop

while can also be useful for user choice input questions, like keep executing the program until the user presses any other key except y. This is difficult to achieve with for loop.

Answer 2

For the same number of iterations, and content, my guess is that a for loop and wihile have practically the same speed. But I haven't tested that - mostly I answer numpy questions where we try to avoid either loop (preferring iterations in compiled code).

Your examples show the basic case where for results in cleaner, if not faster, code:

for x in an_iterator:
    <do something>

versus

i = 0
while i < len(an_iterator):
     x = an_iterator[x]
     <do something>
     i += 1

If you must have an index as well, you can use:

 for i, x in enumerate(an_iterator):
      ....

That ability to iterate directly on things like lists and dictionaries was the main neat feature that caught my attention when I first saw Python in the 1990.

A common subcase of a for loop accumulates values, so common, that Python provides the popular list comprehension , and extended the syntax to generator expressions and dictionary comprehensions.

while still has its uses. Other languages have do while and do until variants, which attempt to streamline stepping the variable and testing. Python has just the one version with separate steps. The new walrus operator has the potential of cleaning that up:

https://docs.python.org/3/whatsnew/3.8.html#assignment-expressions
while (block := f.read(256)) != '':
    process(block)

while is most useful when the steps aren't regular, or from a well defined iterator. for can break and continue , but otherwise the sequence is fixed (at the start of iteration).

In addition to enumerate , zip lets us iterate on several things at once.

The convenience of list comprehensions encourages us to decompose a complicated task into a sequence of comprehensions. And to make that even more convenient (and faster/memory efficient) Python provides generators and all sort so itertools . In Python 3, range and dictionary keys/items/values all became generator like expressions.