Does Python have anything in the fashion of a "redo" statement that exists in some languages?
(The "redo" statement is a statement that (just like "break" or "continue") affects looping behaviour - it jumps at the beginning of innermost loop and starts executing it again.)
No, Python doesn't have direct support for redo
. One option would something faintly terrible involving nested loops like:
for x in mylist:
while True:
...
if shouldredo:
continue # continue becomes equivalent to redo
...
if shouldcontinue:
break # break now equivalent to continue on outer "real" loop
...
break # Terminate inner loop any time we don't redo
but this mean that break
ing the outer loop is impossible within the "redo
-able" block without resorting to exceptions, flag variables, or packaging the whole thing up as a function.
Alternatively, you use a straight while
loop that replicates what for
loops do for you, explicitly creating and advancing the iterator. It has its own issues (continue
is effectively redo
by default, you have to explicitly advance the iterator for a "real" continue
), but they're not terrible (as long as you comment uses of continue
to make it clear you intend redo
vs. continue
, to avoid confusing maintainers). To allow redo
and the other loop operations, you'd do something like:
# Create guaranteed unique sentinel (can't use None since iterator might produce None)
sentinel = object()
iterobj = iter(mylist) # Explicitly get iterator from iterable (for does this implicitly)
x = next(iterobj, sentinel) # Get next object or sentinel
while x is not sentinel: # Keep going until we exhaust iterator
...
if shouldredo:
continue
...
if shouldcontinue:
x = next(iterobj, sentinel) # Explicitly advance loop for continue case
continue
...
if shouldbreak:
break
...
# Advance loop
x = next(iterobj, sentinel)
The above could also be done with a try
/except StopIteration:
instead of two-arg next
with a sentinel
, but wrapping the whole loop with it risks other sources of StopIteration
being caught, and doing it at a limited scope properly for both inner and outer next
calls would be extremely ugly (much worse than the sentinel
based approach).