判断循环

布尔类型

Python 中有一种特殊的数据类型 —— bool（布尔类型），只有两个取值：

• True —— 真，表示条件成立
• False —— 假，表示条件不成立

它们本质上是整数的子类：

print(True == 1)   # True
print(False == 0)  # True
print(int(True))   # 1
print(int(False))  # 0

常见的布尔值来源：

• 直接写 True 或 False
• 比较表达式的结果
• 用内置函数 bool(x) 强制转换

规则（“空是假，非空是真”）：

• 数字：0是假，其余都是真
• 字符串：空串 "" 假，非空为真
• 容器（列表、字典、集合、元组）：空容器是假，非空为真

print(bool(0))      # False
print(bool(123))    # True
print(bool(""))     # False
print(bool("hi"))   # True
print(bool([]))     # False
print(bool([1,2]))  # True

比较运算符

比较运算符用于比较两个值，结果都是布尔值。

运算符	含义	示例
==	等于	3 == 3 → True
!=	不等于	3 != 5 → True
>	大于	5 > 3 → True
<	小于	2 < 4 → True
>=	大于等于	4 >= 4 → True
<=	小于等于	3 <= 5 → True

也支持链式比较（数学写法一样）：

x = 10
print(5 < x < 20)   # True，相当于 5 < x and x < 20
print(5 < x <= 10)  # True

判断语句

if 语句

Python 中的 if 语句用于判断条件的真假。它包含一个逻辑表达式，用于比较数据，并根据比较结果做出判断。

if 语句的语法

if expression:
   # statement(s) to be executed

如果布尔表达式的计算结果为 TRUE，则执行if 块内的语句。如果布尔表达式的计算结果为 FALSE，则执行 if 块结束后的第一组代码。

让我们考虑一个例子，如果客户的购买金额> 1000，则有权享受10％的折扣；如果不是，则不适用任何折扣。以下流程图显示了整个决策过程：

首先，将折扣变量设置为 0，金额变量设置为 1200。然后，使用if 语句检查金额是否大于 1000。如果条件成立，则计算折扣金额。如果适用折扣，则从原始金额中扣除折扣金额。

discount = 0
amount = 1200

# 检查金额价值
if amount > 1000:
   discount = amount * 10 / 100

print("amount = ", amount - discount)

这里的金额是 1200，因此折扣扣除 120。执行代码后，将获得以下输出：

amount = 1080.0

将变量 amount 改为 800，然后再次运行代码。这次，不适用任何折扣。然后，将获得以下输出：

amount = 800

if-else 语句

在实际开发中，你经常需要处理 条件不满足的情况，这时就需要 else。

Python 中的 if-else 语句用于在if 语句中的条件为真时执行一段代码块，在条件为假时执行另一段代码块。

if-else 语句的语法

if boolean_expression:
  # code block to be executed
  # when boolean_expression is true
else:
  # code block to be executed
  # when boolean_expression is false

如果布尔表达式的计算结果为 TRUE，则将执行 if 块内的语句，否则将执行 else 块的语句。

如果 expr 为 True，则执行 stmt1、2、3 块，然后默认流程继续执行 stmt7。但是，如果 expr 为 False，则执行 stmt4、5、6 块，然后默认流程继续执行。

if expr==True:
   stmt1
   stmt2
   stmt3
else:
   stmt4
   stmt5
   stmt6
Stmt7

通过以下示例来理解 if-else语句的用法。这里，变量 age 可以取不同的值。如果表达式 age > 18 为真，则显示“有资格投票”消息，否则显示“没有资格投票”消息。

age=25
print ("age: ", age)
if age >=18:
   print ("eligible to vote")
else:
   print ("not eligible to vote")

执行此代码后，将获得以下输出：

age: 25
eligible to vote

要测试 else 块，将年龄更改为 12，然后再次运行代码。

age: 12
not eligible to vote

if-elif-else 语句

当存在 多种条件分支 时，if-else 不够用，只能用 if-elif-else。

if-elif-else语句允许检查多个表达式是否为 TRUE，并在其中一个条件计算为 TRUE 时立即执行代码块。

与 else 块类似，elif 块也是可选的。但是，一个程序只能包含一个 else 块，而 if 块后面可以有任意数量的 elif 块。

if-elif-else 语句的语法

if expression1:
   statement(s)
elif expression2:
   statement(s)
elif expression3:
   statement(s)
else:
   statement(s)

关键字 elif 是 else if 的缩写。它允许将逻辑排列在第一个 if 语句之后的 elif 语句级联中。如果第一个if语句的计算结果为 false，则后续的elif语句将逐一执行，只要有一个满足条件，就会从级联中退出。

级联中的最后一个是 else 块，当所有前面的 if/elif 条件都失败时，该块就会出现。

假设购买时有不同的折扣等级：

• 超过 10000 的金额，按 20% 计算，
• 5-10000 之间的金额为 10%，
• 如果介于 1 到 5000 之间，则为 5%。
• 金额小于 1000 无折扣

amount = 2500
print('Amount = ',amount)
if amount > 10000:
   discount = amount * 20 / 100
else:
   if amount > 5000:
      discount = amount * 10 / 100
   else:
      if amount > 1000:
         discount = amount * 5 / 100
      else:
         discount = 0

print('Payable amount = ',amount - discount)

设置数量来测试所有可能的情况：800、2500、7500 和 15000。输出将相应变化：

Amount: 800
Payable amount = 800
Amount: 2500
Payable amount = 2375.0
Amount: 7500
Payable amount = 6750.0
Amount: 15000
Payable amount = 12000.0

尽管代码可以完美运行，但如果查看每个 if 和 else 语句中不断增加的缩进级别，如果还有更多条件，就会变得难以管理。

elif 语句使代码易于阅读和理解。以下是使用 if-elif-else 语句实现相同逻辑的 Python 代码：

amount = 2500
print('Amount = ',amount)
if amount > 10000:
   discount = amount * 20 / 100
elif amount > 5000:
   discount = amount * 10 / 100
elif amount > 1000:
   discount = amount * 5 / 100
else:
   discount=0

print('Payable amount = ',amount - discount)

上述代码的输出如下：

Amount: 2500
Payable amount = 2375.0

if 语句嵌套

Python 支持**嵌套的 if 语句，**这意味着我们可以在现有的 if 语句中使用条件 if 和 if-else 语句。

在某些情况下，你可能希望在初始条件解析为 true 后检查其他条件。在这种情况下，可以使用嵌套的 if 结构。

此外，在嵌套的 if 结构中，您可以在一个 if-elif-else 结构中包含另一个 if-elif-else 结构。

嵌套 if 语句的语法

if boolean_expression1:
   statement(s)
   if boolean_expression2:
      statement(s)

num = 36
print ("num = ", num)
if num % 2 == 0:
   if num % 3 == 0:
      print ("Divisible by 3 and 2")
print("....execution ends....")

当运行上述代码时，它将显示以下结果：

num =  36
Divisible by 3 and 2
....execution ends....

如前所述，我们可以在 if 语句中嵌套 if-else 语句。如果 if 条件为真，则执行第一个 if-else 语句，否则，执行 else 块内的语句。

带有 else 条件的嵌套 if 结构的语法

if expression1:
   statement(s)
   if expression2:
      statement(s)
   else
      statement(s)
else:
   if expression3:
      statement(s)
   else:
      statement(s)

num=8
print ("num = ",num)
if num%2==0:
   if num%3==0:
      print ("Divisible by 3 and 2")
   else:
      print ("divisible by 2 not divisible by 3")
else:
   if num%3==0:
      print ("divisible by 3 not divisible by 2")
   else:
      print ("not Divisible by 2 not divisible by 3")

执行上述代码时，将产生以下输出：

num = 8
divisible by 2 not divisible by 3
num = 15
divisible by 3 not divisible by 2
num = 12
Divisible by 3 and 2
num = 5
not Divisible by 2 not divisible by 3

match-case 语句

Python 3.10 发布后，引入了一种名为 match-case 的模式匹配技术，它类似于 C/C++/Java 等语言中的 switch-case 结构。其基本用途是将一个变量与一个或多个值进行比较。与 C/C++ 中的 switch 语句相比，它更类似于 Rust 中的模式匹配。

Python 的 match-case 语句接受一个表达式，并将其值与以一个或多个 case 块形式给出的连续模式进行比较。只有第一个匹配的模式会被执行。它还可以将值中的组件（序列元素或对象属性）提取到变量中。

match-case 语句的语法

match variable_name:
   case 'pattern 1' : statement 1
   case 'pattern 2' : statement 2
   ...
   case 'pattern n' : statement n

下面的代码有一个名为 weekday() 的函数。它接收一个整数参数，将其与所有可能的星期几数字值进行匹配，并返回相应的星期几名称。

def weekday(n):
   match n:
      case 1: return "Monday"
      case 2: return "Tuesday"
      case 3: return "Wednesday"
      case 4: return "Thursday"
      case 5: return "Friday"
      case 6: return "Saturday"
      case 7: return "Sunday"
      case _: return "Invalid day number"
print (weekday(3))
print (weekday(6))
print (weekday(7))

执行时，此代码将产生以下输出：

Wednesday
Saturday
Sunday

函数中最后一个 case 语句以“_”作为比较值。它充当通配符，当所有其他 case 都不成立时，才会执行。

有时，可能需要对多个案例采取类似的操作。为此，可以使用“|”符号表示的“或”运算符来组合多个案例。

下面的代码展示了如何在 match 语句中组合用例。它定义了一个名为 access() 的函数，并有一个字符串参数，表示用户名。对于 admin 或 manager 用户，系统授予完全访问权限；对于 Guest 用户，访问权限受到限制；对于其他用户，则没有访问权限。

def access(user):
   match user:
      case "admin" | "manager": return "Full access"
      case "Guest": return "Limited access"
      case _: return "No access"
print (access("manager"))
print (access("Guest"))
print (access("Ravi"))

运行上述代码后，将显示以下结果：

Full access
Limited access
No access

由于 Python 可以将表达式与任何文字匹配，因此可以使用列表作为案例值。此外，对于列表中可变数量的项目，可以使用“*”运算符将它们解析为序列。

在此代码中，我们在匹配案例语句中使用列表作为参数。

def greeting(details):
   match details:
      case [time, name]:
         return f'Good {time} {name}!'
      case [time, *names]:
         msg=''
         for name in names:
            msg+=f'Good {time} {name}!\n'
         return msg

print (greeting(["Morning", "Ravi"]))
print (greeting(["Afternoon","Guest"]))
print (greeting(["Evening", "Kajal", "Praveen", "Lata"]))

执行时，此代码将产生以下输出：

Good Morning Ravi!
Good Afternoon Guest!
Good Evening Kajal!
Good Evening Praveen!
Good Evening Lata!

通常情况下，Python 会根据字面量匹配表达式。但是，它允许在 case 子句中包含 if 语句，以便对匹配变量进行条件计算。

在下面的例子中，函数参数是金额和期限的列表，并且要计算金额小于或大于 10000 的利息。条件包含在 case 子句中。

def intr(details):
   match details:
      case [amt, duration] if amt<10000:
         return amt*10*duration/100
      case [amt, duration] if amt>=10000:
         return amt*15*duration/100
print ("Interest = ", intr([5000,5]))
print ("Interest = ", intr([15000,3]))

执行时，此代码将产生以下输出 -

Interest = 2500.0
Interest = 6750.0

循环语句

for 循环

Python 中的 for 循环可以遍历任何序列（例如列表、元组或字符串）中的元素。它对序列中的每个元素执行相同的操作。此循环以 for 关键字开头，后跟一个表示序列中当前元素的变量。in 关键字将变量链接到要迭代的序列。循环头末尾使用冒号 (:) ，其下方缩进的代码块将对序列中的每个元素执行一次。

for循环的语法

for iterating_var in sequence:
   statement(s)

这里，iterating_var 是一个变量，每次迭代时，每个序列项的值都会被赋给它。Statements 表示要重复执行的代码块。

循环开始之前，先对序列进行求值。如果是列表，则首先对表达式列表（如果有）进行求值。然后，将序列中的第一个元素（索引 0 处）赋值给 iterating_var 变量。

在每次迭代过程中，语句块都会使用 iterating_var 的当前值执行。之后，将序列中的下一个项赋值给 iterating_var，循环继续，直到整个序列执行完毕。

字符串 for 循环

字符串是 Unicode 字母序列，每个字母都有一个位置索引。由于它是一个序列，因此 可以使用 for 循环遍历其字符。

以下示例比较每个字符并显示它是否不是元音（‘a’、‘e’、‘i’、‘o’、‘u’）。

zen = '''
Beautiful is better than ugly.
Explicit is better than implicit.
Simple is better than complex.
Complex is better than complicated.
'''
for char in zen:
   if char not in 'aeiou':
      print (char, end='')

执行时，此代码将产生以下输出：

Btfl s bttr thn gly.
Explct s bttr thn mplct.
Smpl s bttr thn cmplx.
Cmplx s bttr thn cmplctd.

元组 for 循环

Python 的元组对象也是一个索引序列，因此可以使用 for 循环遍历其项目。

在下面的示例中，for 循环遍历包含整数的元组并返回所有数字的总和。

numbers = (34,54,67,21,78,97,45,44,80,19)
total = 0
for num in numbers:
   total += num
print ("Total =", total)

运行此代码时，它将产生以下输出：

Total = 539

列表 for 循环

Python 的列表对象也是一个索引序列，因此可以使用 for 循环遍历其项目。

在下面的例子中，for 循环遍历包含整数的列表，并仅打印那些可以被 2 整除的整数。

numbers = [34,54,67,21,78,97,45,44,80,19]
total = 0
for num in numbers:
   if num%2 == 0:
      print (num)

当执行此代码时，它将显示以下结果：

34
54
78
44
80

Range 对象 for 循环

Python 的内置 range() 函数返回一个迭代器对象，该对象用于流式传输数字序列。该对象包含从 start 到 stop 的整数，由 step 参数分隔。也可以使用 range 运行 for 循环。

range() 函数具有以下语法：

range(start, stop, step)

• Start - 范围的起始值。可选。默认值为 0
• 停止- 范围上升到停止-1
• 步长- 范围内的整数按步长值递增。选项，默认值为 1。

在这个例子中，我们将看到 range 与 for 循环的使用。

for num in range(5):
   print (num, end=' ')
print()
for num in range(10, 20):
   print (num, end=' ')
print()
for num in range(1, 10, 2):
   print (num, end=' ')

当运行上述代码时，它将产生以下输出：

0 1 2 3 4
10 11 12 13 14 15 16 17 18 19
1 3 5 7 9

字典 for 循环

与列表、元组或字符串不同， Python 中的字典数据类型不是序列，因为其元素没有位置索引。不过，仍然可以使用 for 循环遍历字典。

在字典对象上运行一个简单的 for 循环来遍历其中使用的键。

numbers = {10:"Ten", 20:"Twenty", 30:"Thirty",40:"Forty"}
for x in numbers:
   print (x)

执行时，此代码将产生以下输出：

10
20
30
40

一旦我们能够获取键，就可以通过使用方括号运算符或 get() 方法轻松访问其关联值。

numbers = {10:"Ten", 20:"Twenty", 30:"Thirty",40:"Forty"}
for x in numbers:
   print (x,":",numbers[x])

它将产生以下输出：

10 : Ten
20 : Twenty
30 : Thirty
40 : Forty

dict 类的 items()、keys() 和 values() 方法分别返回视图对象 dict_items、dict_keys 和 dict_values。这些对象是迭代器，因此我们可以对它们运行 for 循环。

dict_items 对象是一个键值元组的列表，可以按如下方式运行 for 循环 -

numbers = {10:"Ten", 20:"Twenty", 30:"Thirty",40:"Forty"}
for x in numbers.items():
   print (x)

它将产生以下输出：

(10, 'Ten')
(20, 'Twenty')
(30, 'Thirty')
(40, 'Forty')

在 for 循环中使用 else 语句

在 Python 中，for 循环可以带一个 else 子句。else 会在循环 正常结束（没有遇到 break）时执行。如果循环被 break 提前退出，else 不会执行。

下面的示例说明了 else 语句与 for 语句的组合，用于搜索从 10 到 20 的素数。

#For loop to iterate between 10 to 20
for num in range(10, 20):  
   #For loop to iterate on the factors 
   for i in range(2,num): 
      #If statement to determine the first factor
      if num%i == 0:      
         #To calculate the second factor
         j=num/i          
         print ("%d equals %d * %d" % (num,i,j))
         #To move to the next number
         break 
      else:                  
         print (num, "is a prime number")
         break

执行上述代码时，将产生以下结果：

10 equals 2 * 5
11 is a prime number
12 equals 2 * 6
13 is a prime number
14 equals 2 * 7
15 equals 3 * 5
16 equals 2 * 8
17 is a prime number
18 equals 2 * 9
19 is a prime number

for-else 循环

Python 支持将可选的 else 代码块与 for 循环关联。如果将 else 代码块与 for 循环一起使用，则该代码块仅在 for 循环正常终止时执行。

当 for 循环完成所有迭代而没有遇到 break 语句时，它会正常终止，这允许我们在满足某个条件时退出循环。

for-else 循环的语法

for variable_name in iterable:
 #stmts in the loop
 .
 .
 .
else:
 #stmts in else clause
 .
 .

以下示例演示了 Python 中 else 语句与 for 语句的组合。直到计数小于 5，才会打印迭代次数。当计数达到 5 时，将执行 else 块中的 print 语句，然后将控制权传递给主程序中的下一个语句。

for count in range(6):
   print ("Iteration no. {}".format(count))
else:
   print ("for loop over. Now in else block")
print ("End of for loop")

执行时，此代码将产生以下输出：

Iteration no. 1
Iteration no. 2
Iteration no. 3
Iteration no. 4
Iteration no. 5
for loop over. Now in else block
End of for loop

如果强制终止循环（通过使用 break 语句），则解释器会忽略 else 语句，因此会跳过其执行。

以下程序显示了在 break 语句的情况下 else 条件如何起作用。

for i in ['T','P']:
   print(i)
   break
else:
   # Loop else statement
   # terminated after 1st iteration due to break statement in for loop
   print("Loop-else statement successfully executed")

执行时，上述程序将生成以下输出：

T

while 循环

Python 中的 while 循环只要指定的布尔表达式为真，就会重复执行目标语句。此循环以 while 关键字开头，后跟布尔表达式和冒号 (:)。然后，开始一段缩进的语句块。

这里，语句可以是单个语句，也可以是具有统一缩进的语句块。条件可以是任意表达式，真值表示任意非零值。一旦表达式变为假，程序控制就会转到循环的下一行。

如果条件未变为 false，循环将继续运行，除非强制停止，否则不会停止。这种循环被称为无限循环或死循环，这在计算机程序中是不可取的。

while 循环语法

while expression:
   statement(s)

在 Python 中，所有在程序结构后以相同数量的字符空格缩进的语句都被视为单个代码块的一部分。Python 使用缩进作为其语句分组的方法。

以下示例说明了 while 循环的工作原理。这里，迭代运行直到 count 的值变为 5。

count=0
while count<5:
   count+=1
   print ("Iteration no. {}".format(count))

print ("End of while loop")

执行时，此代码将产生以下输出：

Iteration no. 1
Iteration no. 2
Iteration no. 3
Iteration no. 4
Iteration no. 5
End of while loop

如果条件永远不会变为 FALSE，则循环将变为无限循环。使用 while 循环时必须谨慎，因为该条件可能永远不会解析为 FALSE 值。这会导致循环永不结束。这种循环称为无限循环。

无限循环在客户端/服务器编程中可能很有用，其中服务器需要连续运行，以便客户端程序可以在需要时与其通信。

让我们举一个例子来了解 Python 中无限循环的工作原理：

var = 1
while var == 1 : # This constructs an infinite loop
   num = int(input("Enter a number :"))
   print ("You entered: ", num)
print ("Good bye!")

执行时，此代码将产生以下输出：

Enter a number :20
You entered: 20
Enter a number :29
You entered: 29
Enter a number :3
You entered: 3
Enter a number :11
You entered: 11
Enter a number :22
You entered: 22
Enter a number :Traceback (most recent call last):
   File "examples\test.py", line 5, in
      num = int(input("Enter a number :"))
KeyboardInterrupt

上面的例子陷入了无限循环，需要使用 CTRL+C 来退出程序。

while-else 循环

Python 支持将 else 语句与 while 循环关联。如果将 else 语句与 while 循环一起使用，则当条件变为 false 时，会在控制转移到主执行线之前执行 else 语句。

以下示例演示了 else 语句与 while 语句的组合。直到计数小于 5，才会打印迭代次数。当计数达到 5 时，将执行 else 块中的 print 语句，然后将控制权传递给主程序中的下一个语句。

count=0
while count<5:
   count+=1
   print ("Iteration no. {}".format(count))
else:
   print ("While loop over. Now in else block")
print ("End of while loop")

运行上述代码时，它将打印以下输出：

Iteration no. 1
Iteration no. 2
Iteration no. 3
Iteration no. 4
Iteration no. 5
While loop over. Now in else block
End of while loop

与 if 语句语法类似，如果 while 子句仅由单个语句组成，则它可以与 while 标题放在同一行。

flag = 0
while (flag): print ("Given flag is really true!")
print ("Good bye!")

嵌套循环

在 Python 中，在循环语句中编写一个或多个循环（称为嵌套循环）时，主循环被视为外循环，而外循环内的循环称为内循环。

可以将任何类型的循环放在任何其他类型的循环内。例如，for 循环可以放在 while 循环内，反之亦然。

包含一个或多个内部 for 循环的 for 循环称为嵌套 for 循环。for 循环用于循环遍历任何序列（例如列表、元组或字符串）中的每个元素，并对序列中的每个元素执行相同的操作。

嵌套 for 循环语法

for iterating_var in sequence:
   for iterating_var in sequence:
      statements(s)
   statements(s)

以下程序使用嵌套 for 循环来迭代月份和日期列表。

months = ["January", "February", "March"]
days = ["Monday", "Tuesday", "Wednesday"]

for x in months:
  for y in days:
    print(x, y)

print("Good bye!")

当执行上述代码时，它会产生以下结果：

January Monday
January Tuesday
January Wednesday
February Monday
February Tuesday
February Wednesday
March Monday
March Tuesday
March Wednesday
Good bye!

具有一个或多个内部 while 循环的 while 循环称为嵌套 while 循环。while 循环用于重复执行一段代码块，执行次数未知，直到指定的布尔表达式变为 TRUE。

嵌套 while 循环语法

while expression:
   while expression:
      statement(s)
   statement(s)

以下程序使用嵌套的 while 循环来查找从 2 到 100 的素数：

i = 2
while(i < 25):
   j = 2
   while(j <= (i/j)):
      if not(i%j): break
      j = j + 1
   if (j > i/j) : print (i, " is prime")
   i = i + 1

print ("Good bye!")

执行时，上述代码产生以下结果：

2 is prime
3 is prime
5 is prime
7 is prime
11 is prime
13 is prime
17 is prime
19 is prime
23 is prime
Good bye!

break 语句

Python 中 break 语句用于终止当前循环并在下一个语句处恢复执行，就像 C 中的传统 break 语句 一样。

Python 中 break 语句最常见的用途是当触发某些外部条件时，需要突然退出循环。break 语句可以在 Python 的 while 循环和for循环中使用。

如果在 Python 中使用嵌套循环，break 语句会停止最内层循环的执行并开始执行块后的下一行代码。

break 语句语法

looping statement:
   condition check:
      break

如果我们在 for 循环中使用 break 语句，它会中断程序的正常流程并在完成迭代之前退出循环。

for letter in 'Python':    
   if letter == 'h':
      break
   print ("Current Letter :", letter)
print ("Good bye!")

执行上述代码时，将产生以下结果：

Current Letter : P
Current Letter : y
Current Letter : t
Good bye!

与 for 循环类似，我们可以使用 break 语句在指定条件变为 TRUE 后跳过 while 循环内的代码。

var = 10                   
while var > 0:              
   print ('Current variable value :', var)
   var = var -1
   if var == 5:
      break

print ("Good bye!")

执行上述代码后，将产生以下结果：

Current variable value : 10
Current variable value : 9
Current variable value : 8
Current variable value : 7
Current variable value : 6
Good bye!

在嵌套循环中，一个循环定义在另一个循环内部。包围另一个循环的循环（即内循环）称为外循环。

当我们使用带有嵌套循环的 break 语句时，它的行为如下：

• 当内循环中使用 break 语句时，只会跳过内循环，程序将继续执行内循环之后的语句
• 并且，当在外循环中使用 break 语句时，外循环和内循环都将被跳过，程序将继续执行外循环的后续语句。

以下程序演示了如何在 for 循环中调用 break来遍历列表。程序会在列表中搜索指定的数字。如果找到，则循环终止并显示“found”消息。

no = 33
numbers = [11,33,55,39,55,75,37,21,23,41,13]
for num in numbers:
   if num == no:
      print ('number found in list')
      break
else:
   print ('number not found in list')

上述程序将产生以下输出：

number found in list

continue 语句

Python 中 continue 语句用于跳过程序块的执行，并将控制权返回到当前循环的开头以开始下一次迭代。遇到 continue 语句时，循环将开始下一次迭代，而不执行当前迭代中的其余语句。

continue 语句与 break 语句正好相反，它跳过当前循环中剩余的语句，并开始下一次迭代。

continue 语句语法

looping statement:
   condition check:
      continue

在 Python 中，continue 语句可以与 for 循环一起使用。在 for 循环中，应该包含一个 if 语句来检查特定条件。如果条件为 TRUE，则 continue 语句将跳过当前迭代并继续进行循环的下一次迭代。

for letter in 'Python':
   if letter == 'h':
      continue
   print ('Current Letter :', letter)
print ("Good bye!")

执行上述代码时，将产生以下输出：

Current Letter : P
Current Letter : y
Current Letter : t
Current Letter : o
Current Letter : n
Good bye!

continue 语句可以与 while 循环一起使用，使用方法一致。

以下代码使用 continue 函数来查找给定数字的质因数。为了找到质因数，我们需要从 2 开始依次除以给定数字，然后递增除数，并重复相同的过程，直到输入减为 1。

num = 60
print ("Prime factors for: ", num)
d=2
while num > 1:
   if num%d==0:
      print (d)
      num=num/d
      continue
   d=d+1

执行时，此代码将产生以下输出：

Prime factors for: 60
2
2
3
5

pass 语句

Python 中 pass 语句用于语法上需要某个语句但不希望执行任何命令或代码的情况。它为 null，表示执行时不会发生任何事情。这在稍后添加代码片段，但需要占位符来确保程序正常运行的情况下也很有用。

例如，在尚未编写实现的函数或类定义中，可以使用 pass 语句来避免 SyntaxError。此外，它还可以在 for 和 while 循环等控制流语句中用作占位符。

以下代码展示了如何在 Python 中使用 pass 语句：

for letter in 'Python':
   if letter == 'h':
      pass
      print ('This is pass block')
   print ('Current Letter :', letter)
print ("Good bye!")

执行上述代码时，将产生以下输出：

Current Letter : P
Current Letter : y
Current Letter : t
This is pass block
Current Letter : h
Current Letter : o
Current Letter : n
Good bye!

使用 Python 中的 pass 语句创建无限循环非常简单。

while True: pass  
# Type Ctrl-C to stop         

由于循环体只是一个空语句，因此 Python 会卡在这个循环中。

Python 3.X 允许使用省略号（编码为三个连续的点 ...）代替 pass 语句。两者都用作稍后要编写的代码的占位符。

例如，如果我们创建一个不执行任何操作的函数，特别是对于稍后要填充的代码，那么我们可以使用 ...

def func1():
   # Alternative to pass
   ...                   

# Works on same line too
def func2(): ...          
 # Does nothing if called
func1()                  
func2()