问题：在Python中使用“ continue”语句的示例？

`continue`语句从循环的下一个迭代继续。

The definition of the `continue` statement is:

The `continue` statement continues with the next iteration of the loop.

I can’t find any good examples of code.

Could someone suggest some simple cases where `continue` is necessary?

回答 0

``````for letter in 'Django':
if letter == 'D':
continue
printf("Current Letter: {letter}")``````

``````Current Letter: j
Current Letter: a
Current Letter: n
Current Letter: g
Current Letter: o``````

Here’s a simple example:

``````for letter in 'Django':
if letter == 'D':
continue
print("Current Letter: " + letter)
``````

Output will be:

``````Current Letter: j
Current Letter: a
Current Letter: n
Current Letter: g
Current Letter: o
``````

It continues to the next iteration of the loop.

回答 1

``````for x, y in zip(a, b):
if x > y:
z = calculate_z(x, y)
if y - z < x:
y = min(y, z)
if x ** 2 - y ** 2 > 0:
lots()
of()
code()
here()``````

``````for x, y in zip(a, b):
if x <= y:
continue
z = calculate_z(x, y)
if y - z >= x:
continue
y = min(y, z)
if x ** 2 - y ** 2 <= 0:
continue
lots()
of()
code()
here()``````

I like to use continue in loops where there are a lot of contitions to be fulfilled before you get “down to business”. So instead of code like this:

``````for x, y in zip(a, b):
if x > y:
z = calculate_z(x, y)
if y - z < x:
y = min(y, z)
if x ** 2 - y ** 2 > 0:
lots()
of()
code()
here()
``````

I get code like this:

``````for x, y in zip(a, b):
if x <= y:
continue
z = calculate_z(x, y)
if y - z >= x:
continue
y = min(y, z)
if x ** 2 - y ** 2 <= 0:
continue
lots()
of()
code()
here()
``````

By doing it this way I avoid very deeply nested code. Also, it is easy to optimize the loop by eliminating the most frequently occurring cases first, so that I only have to deal with the infrequent but important cases (e.g. divisor is 0) when there is no other showstopper.

回答 2

Usually the situation where continue is necessary/useful, is when you want to skip the remaining code in the loop and continue iteration.

I don’t really believe it’s necessary, since you can always use if statements to provide the same logic, but it might be useful to increase readability of code.

回答 3

``````import random

for i in range(20):
x = random.randint(-5,5)
if x == 0: continue
print 1/x  ``````

``````import random

for i in range(20):
x = random.randint(-5,5)
if x == 0: continue
print 1/x
``````

continue is an extremely important control statement. The above code indicates a typical application, where the result of a division by zero can be avoided. I use it often when I need to store the output from programs, but dont want to store the output if the program has crashed. Note, to test the above example, replace the last statement with print 1/float(x), or you’ll get zeros whenever there’s a fraction, since randint returns an integer. I omitted it for clarity.

回答 4

``````if precondition_fails(message): continue

''' main code here '''``````

Suppose you need a check before the main code:

``````if precondition_fails(message): continue

''' main code here '''
``````

Note you can do this after the main code was written without changing that code in anyway. If you diff the code, only the added line with “continue” will be highlighted since there are no spacing changes to the main code.

Imagine if you have to do a breakfix of production code, which turns out to simply be adding a line with continue. It’s easy to see that’s the only change when you review the code. If you start wrapping the main code in if/else, diff will highlight the newly indented code, unless you ignore spacing changes, which is dangerous particularly in Python. I think unless you’ve been in the situation where you have to roll out code on short notice, you might not fully appreciate this.

回答 5

``````def filter_out_colors(elements):
colors = ['red', 'green']
result = []
for element in elements:
if element in colors:
continue # skip the element
# You can do whatever here
result.append(element)
return result

>>> filter_out_colors(['lemon', 'orange', 'red', 'pear'])
['lemon', 'orange', 'pear']``````
``````def filter_out_colors(elements):
colors = ['red', 'green']
result = []
for element in elements:
if element in colors:
continue # skip the element
# You can do whatever here
result.append(element)
return result

>>> filter_out_colors(['lemon', 'orange', 'red', 'pear'])
['lemon', 'orange', 'pear']
``````

回答 6

``````for x in range(0, 101):
if x % 3 ==0 or x % 5 == 0:
continue
#no more code is executed, we go to the next number
print x``````

Let’s say we want to print all numbers which are not multiples of 3 and 5

``````for x in range(0, 101):
if x % 3 ==0 or x % 5 == 0:
continue
#no more code is executed, we go to the next number
print x
``````

回答 7

``````# List of times at which git commits were done.
# Formatted in hour, minutes in tuples.
# Note the last one has some fantasy.
commit_times = [(8,20), (9,30), (11, 45), (15, 50), (17, 45), (27, 132)]

for time in commit_times:
hour = time[0]
minutes = time[1]

# If the hour is not between 0 and 24
# and the minutes not between 0 and 59 then we know something is wrong.
# Then we don't want to use this value,
# we skip directly to the next iteration in the loop.
if not (0 <= hour <= 24 and 0 <= minutes <= 59):
continue

# From here you know the time format in the tuples is reliable.
# Apply some logic based on time.
print("Someone commited at {h}:{m}".format(h=hour, m=minutes))``````

``````Someone commited at 8:20
Someone commited at 9:30
Someone commited at 11:45
Someone commited at 15:50
Someone commited at 17:45``````

It is not absolutely necessary since it can be done with IFs but it’s more readable and also less expensive in run time.

I use it in order to skip an iteration in a loop if the data does not meet some requirements:

``````# List of times at which git commits were done.
# Formatted in hour, minutes in tuples.
# Note the last one has some fantasy.
commit_times = [(8,20), (9,30), (11, 45), (15, 50), (17, 45), (27, 132)]

for time in commit_times:
hour = time[0]
minutes = time[1]

# If the hour is not between 0 and 24
# and the minutes not between 0 and 59 then we know something is wrong.
# Then we don't want to use this value,
# we skip directly to the next iteration in the loop.
if not (0 <= hour <= 24 and 0 <= minutes <= 59):
continue

# From here you know the time format in the tuples is reliable.
# Apply some logic based on time.
print("Someone commited at {h}:{m}".format(h=hour, m=minutes))
``````

Output:

``````Someone commited at 8:20
Someone commited at 9:30
Someone commited at 11:45
Someone commited at 15:50
Someone commited at 17:45
``````

As you can see, the wrong value did not make it after the `continue` statement.

回答 8

``````my_var = 1
for items in range(0,100):
if my_var < 10:
continue
elif my_var == 10:
print("hit")
elif my_var > 10:
print("passed")
my_var = my_var + 1``````

For example if you want to do diferent things depending on the value of a variable:

``````my_var = 1
for items in range(0,100):
if my_var < 10:
continue
elif my_var == 10:
print("hit")
elif my_var > 10:
print("passed")
my_var = my_var + 1
``````

In the example above if I use `break` the interpreter will skip the loop. But with `continue`it only skips the if-elif statements and go directly to the next item of the loop.

回答 9

`continue` 只需跳过循环中的其余代码，直到下一次迭代

`continue` simply skips the rest of the code in the loop until next iteration