Linux 5.4.0-74-generic
Python 3.9.5 @ GCC 7.3.0
Latest build date 2021.06.05

语句

语句（statement）可以分为两种：简单语句和复合语句。简单语句只能在一个逻辑行内完成，而复合语句由简单语句和复合语句构成，可以跨越多个逻辑行。

语句分类

简单语句	复合语句
表达式	if 语句
赋值语句	while 语句
增强赋值语句	for 语句
assert 语句	try 语句
pass 语句	with 语句
del 语句	def 函数定义 (不包括函数体)
return 语句	class 类定义 (不包括类体)
yield 语句	async def 协程函数定义
raise 语句	async for 语句
break 语句	async with 语句
continue 语句	simple_stmt; 简单语句序列
import 语句	复合语句（即复合语句嵌套复合语句）
global 语句
nonlocal 语句

`if` 语句

if语句的完整形式如下（注意不要少写了冒号:）：

if condition_1:
    statement_1
elif condition_2:
    statement_2
else:
    statement_3

elif是else if的缩写，使用缩写是为了避免过度缩进。可以有多个elif。

# example
age = 3
if age >= 18:
    print('adult')
elif age >= 6:
    print('teenager')
else:
    print('kid')

kid

if判断条件还可以简写，例如：阿

age = 3
if age:
    print('True')

True

在Python中，False、0、''、[]、()、{}都视作False，否则为True。注意，负值也是被判断为真。

`assert` 断言

断言语句用来检查条件是否满足，如果不满足，就引发 AssertionError 异常（并可提供错误消息）。语法如下：

assert condition

等价于

if not condition:
    crash program

例子：

age = 3
assert age >= 12, 'Children under the age of 12 are not allowed'

---------------------------------------------------------------------------AssertionError                            Traceback (most recent call last)<ipython-input-1-6fe548f20b1c> in <module>
      1 age = 3
----> 2 assert age >= 12, 'Children under the age of 12 are not allowed'
AssertionError: Children under the age of 12 are not allowed

循环

Python的循环有两种:

for 循环
while 循环

`for` 语句

for 循环，依次迭代可迭代对象中的每个元素，可包含 else 子句，else 子句在迭代结束时执行。

# 依次迭代 names 序列的每个元素, 将元素赋值给变量 name
# 然后执行代码块中的语句
names = ['Michael', 'Bob', 'Tracy']
for name in names:
    print(name)

Michael
Bob
Tracy

有些语言迭代序列之只能通过索引完成，例如以下java代码：

for (i=0; i<list.length; i++) {
    n = list[i];
}

可以看出，Python的for循环抽象程度要高于Java的for循环，因为Python的for循环不关心多迭代的对象是否支持索引，只要该对象为可迭代对象即可。

可以通过如下代码判断一个对象是否为可迭代对象：

from collections import Iterable

isinstance('abc', Iterable)

True

如果在迭代对象的同时也想迭代对象元素的索引，可以使用enumerate函数：

for i, value in enumerate(['A', 'B', 'C']):
    print(i, value)

0 A
1 B
2 C

`while` 语句

while 语句用于在指定条件为真时反复地执行（循环），条件不满足时退出循环。可包含 else 子句，else 子句在执行条件为 false 时执行。

比如要计算100以内所有奇数之和，可以用while循环实现：

sum = 0
n = 99
# 在循环内部变量 n 不断自减
# 直到变为 n=0 时，不再满足while条件，循环退出
while n > 0:
    sum = sum + n
    n = n - 2
print(sum)

break

在循环中，break语句可以提前退出循环。例如

注意

break语句只能用于循环中。

i = 1
while i < 100:
    i = i + 1
    print("结束循环")
    break
    print(i)

结束循环

break的作用是退出当前循环，print(i)语句不会执行。

要注意的是，break只是中断当前层的循环，不会中断上一层的循环。

for i in range(3):
    for j in ["a", "b", "c"]:
        print(j)
        break

a
a
a

内层循环打印出一个j值之后，被break语句中断，但外层循环并没有中断，所以代码执行的结果是打印了三次a。

continue

continue语句：跳过当前层的当前循环，直接开始下一次循环。

注意

continue 语句只能用于循环中。

n = 0
while n < 10:
    n = n + 1
    print(n, end=" ")

1 2 3 4 5 6 7 8 9 10

上面的程序可以打印出1～10。但是，如果我们想只打印奇数，可以用continue语句跳过某些循环：

n = 0
while n < 10:
    n += 1
    if n % 2 == 0:  # 如果n是偶数，执行continue语句
        continue    # continue语句会直接继续下一轮循环，后续的print语句不会执行
    print(n, end=" ")

1 3 5 7 9

执行上面的代码可以看到，打印的不再是1～10，而是1，3，5，7，9。

循环中的`else`子句

else子句不仅可以用在if语句，还可以用在循环语句。循环语句中的else子句在for循环迭代完成时，或者while循环执行条件为 false 时执行，但循环被 break 中止的情况下不会执行。

# for循环
i = 1
for i in range(1, 10, 2):
    print(i, end=" ")
else:
    print("i =", i)

1 3 5 7 9 i = 9

# while循环
i = 1
while i < 5:
    print(i, end=" ")
    i += 1
else:
    print("i =", i)

1 2 3 4 i = 5

当循环被break语句中断，此时else子句不会执行：

i = 1
for i in range(1, 10, 2):
    break
    print(i, end=" ")
else:
    print("i =", i)

i = 1
while i < 5:
    break
    print(i, end=" ")
    i += 1
else:
    print("i =", i)

总结

break、continue语句通常都配合if语句使用。

要特别注意，不要滥用break和continue语句。break和continue会造成代码执行逻辑分叉过多，容易出错。大多数循环并不需要用到break和continue语句，上面的两个例子，都可以通过改写循环条件或者修改循环逻辑，去掉break和continue语句。

pass 语句

pass 语句什么也不做。它用于那些语法上必须要有语句，但程序什么也不做的场合，例如:

# 死循环
while True:
    pass  # Busy-wait for keyboard interrupt (Ctrl+C)

# 创建最小结构的类:
class MyEmptyClass:
    pass

# 空函数
def fun:
    pass

如果你有其他编程语言基础，你可能会疑惑Python为什么要有pass语句。

一方面，这是为了语法的完备性。例如，要像下面这样定义一个空函数是不行的：

def fun():

fun()

IndentationError: expected an indented block

def fun():
    # TODO
fun

IndentationError: expected an indented block

也就是说，缩进代码块中必须包含有语法意义的内容。这是因为 Python 在定义函数时，必须包含函数体，即同时包含声明和定义两种语义，不像C语言可以只使用声明的语义，即写成void fun(); 。同时，又因为Python通过缩进来划分代码块，所以Python无法像C语言一样使用{}定义出空函数，即写成void fun(){}。

上面两种定义空函数的方式都会报IndentationError: expected an indented block错误。因为什么都不写（即使有缩进），实际上就是空行，空行并不是Python语法的一部分。同理，注释也不是有效的语法。

因此，从语法完整性的角度来看，pass语句是必须的设计要素。

另一方面，对于Python程序员来说，可以利用pass语句作为一种占位符，等于是说”这里先预留位置，回头再补上具体的代码实现”。但是，这个功能也通过# TODO来实现，因此实现语法完备性是 pass 语句的主要作用。

return 语句

return 语句结束函数的执行并返回一个值。如果没有指定值，将返回 None 。示例：

注意

return 语句只能用于函数中。

def func1():
    return 4, 2

def func2():
    return 

print(func1())
print(func2())

(4, 2)
None

del 语句

del 语句用于解除名字和对象的关联以及将数据结构（映射或序列）的一部分（如（位置、切片或存储槽）删除。不能直接使用它来删除对象，因为对象只能通过垃圾收集来删除。

del x          # 解除变量与值的关联
del seq[42]    # 删除序列中的一个元素
del seq[42:]   # 删除序列中的一个切片
del map['foo'] # 删除映射中的一项

暂未提到的语句

还有一些Python语句在这里没有被提到：

yield 语句：暂停执行生成器，并返回一个值。
raise 语句：引发异常。
try 语句：用于执行可能发生异常的代码段，让程序能够捕获这些异常并执行异常处理代码。
global 语句：将变量标记为全局的。
nonlocal 语句：将变量标记为闭包作用域的变量。
with 语句：用于包装使用上下文管理器的代码块，让管理器能够执行一些设置和清理操作。
import 语句：从外部模块导入名称。

语句

if 语句

assert 断言

循环

for 语句

while 语句