流程控制

发表于 2019-07-26 更新于 2026-11-04 分类于 Python Python教程 Python基础本文字数： 15k 阅读时长 ≈ 28 分钟

前言

在Python中，流程控制用于控制程序的执行流程，使程序能够根据特定的条件或情况来做出不同的决策。
Python 提供几种常用的流程控制结构：条件语句（if、match）、循环语句（for、while），以及循环内的跳转（break、continue）。文末的 pass 是占位空语句、return 是函数返回，严格说都不属于「跳转语句」，只是习惯放在一起讲；Python 官方也没有「跳转语句」这个分类，break / continue 在文档里归在 break/continue 语句一节。

条件语句

if-else

if语句
- 简介
  
  if语句是条件语句的基本部分。它用于检查一个条件是否为真，如果为真，则执行相应的代码块。如果条件为假，则跳过该代码块。
- 语法
  1
  2
  if condition:
  # 执行代码块
- 示例
  1
  2
  3
  4
  # 判断一个数是否是3的倍数
  num = int(input('请输入一个整数：'))
  if num % 3 == 0:
  print('%d是3的倍数' % num)

elif语句

简介

elif语句是if语句的可选部分，用于检查多个条件。当if语句的条件为假时，会依次检查每个elif语句的条件，如果找到第一个为真的条件，就执行相应的代码块，并跳过其他的elif语句和else语句。

语法

if condition1:
    # 执行代码块1
elif condition2:
    # 执行代码块2

示例

# 判断闰年：分支按书写顺序求值，命中第一个就整体跳出，后面的不再看
y = int(input('请输入一个年份：'))
if y % 400 == 0:
    print('%d年是闰年' % y)
elif y % 100 == 0:
    print('%d年不是闰年' % y)
elif y % 4 == 0:
    print('%d年是闰年' % y)
else:
    print('%d年不是闰年' % y)

顺序不能反：写成 if y % 4 == 0: 闰年 再 elif y % 100 == 0: 平年，1900 会先命中第一条被判成闰年。分支不多时，一行布尔表达式更紧凑：(y % 4 == 0 and y % 100 != 0) or y % 400 == 0。

else语句

简介

else语句是if语句的可选部分，用于在所有条件都为假时执行一段代码块。else语句没有条件，它只是在前面的if语句和elif语句的条件都为假时执行。

语法

if condition1:
    # 执行代码块1
elif condition2:
    # 执行代码块2
else:
    # 执行代码块3

示例

# 判断学生成绩级别
score = int(input('请输入一个分数：'))
if score >= 90:
    print('A：优秀')
elif score >= 80:
    print('B：良好')
elif score >= 70:
    print('C：中等')
elif score >= 60:
    print('D：及格')
else:
    print('请把家长叫来！')

练习

1. 输入两个数，打印较大的那个值
2. 输入三个数，按照从小到大的顺序打印
3. 输入一个三位数，打印其个位、十位、百位上的数
4. 输入一个年份，判断是否为闰年，是打印一句话，不是打印一句话
5. 输入一个整数，判断其是否既能被 3 整除，又能被 5 整除

match

简介
- Python 3.10 中引入的 match 语句。
- match 语句是一种用于模式匹配的新条件语句，它提供了一种简洁和可读性更高的方式来处理多个条件。
- match 语句接受一个表达式并把它的值与一个或多个 case 块给出的一系列模式进行比较。这表面上像 C、Java 或 JavaScript（以及许多其他程序设计语言）中的 switch 语句，但其实它更像 Rust 或 Haskell 中的模式匹配。只有第一个匹配的模式会被执行，并且它还可以提取值的组成部分（序列的元素或对象的属性）赋给变量。

`match`语法

match expression:
    case pattern1:
        # 执行代码块1
    case pattern2:
        # 执行代码块2
    ...
    case patternN:
        # 执行代码块N
    case _:
        # 默认情况下执行的代码块

说明

expression是要进行模式匹配的表达式，pattern1、pattern2等是模式，用于匹配expression的不同情况。每个case后面跟着一个冒号（:），然后是相应的代码块。
match语句会依次检查每个case中的模式，如果找到匹配的模式，就执行相应的代码块，并跳出整个match语句。如果没有找到匹配的模式，且存在 case _，则执行 case _ 后面的代码块；没有 case _ 时 match 语句什么都不做，不抛任何异常（函数走到末尾就返回 None）。网上不少教程说会抛 MatchError——那是 PEP 634 早期草案里的东西，正式版从未提供：3.10 到 3.15 的异常文档里查不到它，本机 3.13 的 builtins 里也没有这个名字。

你可以用 | （“或”）将多个字面值组合到一个模式中：

def http_error(status):
    match status:
        case 401 | 403 | 404:      # 一个字面值匹配不上就试下一个
            return "Not allowed"
        case _:
            return "OK"

捕获模式的大坑：case x: 里的名字是「捕获」而不是「比较」，它会匹配任何值并把值绑给 x。所以拿变量当字面值写会静默失效：

def check(value):
    RED = 1                      # 模块里或 case 之前的同名变量都不参与比较
    match value:
        case RED:                # 匹配一切，并把值重新绑给 RED
            return ("captured", RED)

要按值比较得写字面值或带点的路径（case Color.RED:、case 1:）。
3.13 里如果这种捕获模式后面还有别的 case，编译期就会直接报 SyntaxError: name capture ... makes remaining patterns unreachable，算是把这个坑堵严了一半；但单独一个 case 变量名: 仍然静默匹配一切，别指望编译器兜底。

守卫（guard）：模式后面可以跟 if 条件，条件为假时继续看下一个 case。

def classify(n):
    match n:
        case x if x > 100:       # 守卫为假就继续看下一个 case
            return "big"
        case x:
            return "small"

还能顺便解构取值：序列模式 case [x, y]:、字典模式 case {"k": v}:、类模式 case Point(x, y):，匹配成功时把各部分绑到变量上（capture([3, 4]) 走 case [x, y] 得到 x=3, y=4）。
版本要求：match 是 Python 3.10 才有的语法，3.9 及更早的解释器里写它会直接 SyntaxError。

示例

def http_error(status):
    match status:
        case 400:
            return "Bad request"
        case 404:
            return "Not found"
        case 418:
            return "I'm a teapot"
        case _:
            return "Something's wrong with the internet"

循环语句

while循环

while 语句
- 简介
  - 当条件为真（True）时，while循环会重复执行一段代码，直到条件变为假（False）。
  - 如果循环条件一直为真，循环将永远不会结束，这被称为无限循环。在编写循环时，确保有适当的终止条件，以避免无限循环。
- 语法
  1
  2
  while condition:
  # 执行代码块
  在每次循环迭代之前，会先检查条件condition。如果条件为真，则执行代码块；如果条件为假，则跳过代码块，继续执行循环之后的代码。
- 示例
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
  # 计算 1 到 100 的总和
  
  n = 100
  
  total = 0
  counter = 1
  while counter <= n:
  total += counter
  counter += 1
  
  print("1 到 %d 之和为: %d" % (n, total))
  累加器别叫 sum：那会把内置函数 sum() 遮蔽掉，后面再调 sum(...) 就报错了。同样的求和用一行就够：sum(range(1, n + 1))，得 5050。
while-else 语句
- 简介
  - while-else 语法是一种特殊的循环语法，它允许在while循环结束后执行一个额外的代码块。
  - 该代码块被称为"else"代码块，它会在循环条件变为假（False）时执行，除非循环被break语句提前终止。
- 语法
  1
  2
  3
  4
  while condition:
  # 循环代码块
  else:
  # else代码块
  当循环条件为真（True）时，会执行循环代码块。如果循环正常结束（即循环条件变为假），则会执行else代码块。如果循环被break语句提前终止，那么else代码块将不会被执行。
- 示例
  1
  2
  3
  4
  5
  6
  count = 0
  while count < 5:
  print(count)
  count += 1
  else:
  print("循环结束")

练习

1. 计算 1~100 之间所有整数的和
2. 打印字符 a~z
3. 打印字符 Z~A
4. 循环输入 10 个字符，大写转为小写，小写转为大写，其他字符不处理
5. 思考：循环能否嵌套，想一想其应用场景及执行流程

for循环

for 语句

简介
for循环用于遍历一个可迭代对象（能被 for 一个个取出来的东西，如列表、元组、字符串、字典等），并执行相应的代码块。
语法
1
2
for item in iterable:
# 执行代码块
在这个结构中，item是一个临时变量，用于迭代可迭代对象iterable中的每个元素。在每次迭代中，item会依次取得可迭代对象中的元素，并执行相应的代码块。

示例

遍历字符串

1
2
3

s = 'I love you more than i can say '
for i in s:
    print(i)

遍历列表

fruits = ["apple", "banana", "cherry"]
for fruit in fruits:
    print(fruit)

"""
输出：
apple
banana
cherry
"""

# 可以获取下标，enumerate 每次循环可以得到下标及元素
for index, fruit in enumerate(fruits):
    print(index, fruit)

"""
输出：
0 apple
1 banana
2 cherry
"""

遍历字典

遍历字典的键

my_dict = {"name": "Alice", "age": 25, "city": "New York"}
for key in my_dict:
    print(key)

"""
输出：
name
age
city
"""

遍历字典的值

my_dict = {"name": "Alice", "age": 25, "city": "New York"}
for value in my_dict.values():
    print(value)

"""
输出：
Alice
25
New York
"""

遍历字典的键值对

my_dict = {"name": "Alice", "age": 25, "city": "New York"}
for key, value in my_dict.items():
    print(key, value)

"""
输出：
name Alice
age 25
city New York
"""

for-else 语句

简介
for-else语句是一种特殊的语法结构，用于在for循环完全执行完毕后执行一段代码块。
语法
1
2
3
4
for item in iterable:
# 执行代码块
else:
# 执行代码块
在这个结构中，item是一个临时变量，用于迭代可迭代对象iterable中的每个元素。在每次迭代中，item会依次取得可迭代对象中的元素，并执行相应的代码块。当所有的迭代都完成时，会执行else语句后的代码块。

示例

fruits = ["apple", "banana", "cherry"]
for fruit in fruits:
    if fruit == "orange":
        print("Found orange!")
        break
else:
    print("Orange not found.")

"""
输出：
Orange not found.
"""

在上面的示例中，我们使用for循环遍历了一个列表fruits中的每个元素。在循环体中，我们使用条件判断语句检查当前元素是否为"orange"。如果找到了"orange"，则打印一条消息并使用break语句终止循环。否则，当所有的元素都被迭代完毕时，会执行else语句后的代码块，打印"Orange not found."。

注意事项
- else语句的执行条件：
  else语句只在for循环完全执行完毕（即没有执行break语句）时才会执行。如果在循环中使用了break语句提前终止循环，则不会执行else语句。
- 适用场景：
  for-else语句通常用于在遍历一个可迭代对象后，检查是否满足特定条件。如果找到了满足条件的元素，可以使用break语句提前终止循环并执行相应的操作。如果没有找到满足条件的元素，则可以在else语句中执行一些默认操作。
- 常见用法：
  - 在搜索操作中，可以使用for-else语句来判断是否找到了目标元素。
  - 在循环中进行一些操作后，可以使用else语句来执行一些收尾工作。

range() 函数
- 简介
  - range() 函数是Python内置的一个函数，用于生成一个指定范围内的整数序列。
  - range() 函数返回一个可迭代对象（在Python 2中返回一个列表），可以通过循环遍历或转换为其他数据类型使用。
- 语法
  1
  range(start, stop, step)
- 参数说明
  - start（可选）：序列的起始值，默认为0。
  - stop：序列的结束值，生成的整数序列不包括该值。
  - step（可选）：序列中相邻两个整数之间的步长，默认为1。
- 示例
  - 生成一个从0到5（不包括5）的整数序列
    1
    2
    for i in range(5):
    print(i)
    输出：
    1
    2
    3
    4
    5
    0
    1
    2
    3
    4
  - 生成一个从2到10（不包括10）的偶数序列
    1
    2
    for i in range(2, 10, 2):
    print(i)
    输出：
    1
    2
    3
    4
    2
    4
    6
    8
  - 将 range() 返回的序列转换为列表
    1
    2
    my_list = list(range(1, 6))
    print(my_list)
    输出：
    1
    [1, 2, 3, 4, 5]
  - 结合 range() 和 len() 函数以遍历一个序列的索引
    1
    2
    3
    a = ['Google', 'Baidu', 'Runoob', 'Taobao', 'QQ']
    for i in range(len(a)):
    print(i, a[i])
    输出：
    1
    2
    3
    4
    5
    0 Google
    1 Baidu
    2 Runoob
    3 Taobao
    4 QQ
- 注意事项
  - range()函数生成的整数序列不包括结束值。例如，range(5)生成的序列是0、1、2、3、4。
  - 如果只传递一个参数给range()函数，它会作为结束值，起始值默认为0。如果传递两个参数，第一个参数为起始值，第二个参数为结束值。如果传递三个参数，第三个参数为步长。
  - 步长可以是正数或负数。正数表示递增的序列，负数表示递减的序列。默认步长为1。
  - range()函数生成的序列是惰性求值的，即只在需要时才生成下一个整数。这使得它可以处理大范围的整数序列而不会占用过多的内存。
  - range 其实是序列类型（isinstance(range(5), collections.abc.Sequence) 为 True），支持 len()、索引和切片，不是生成器；它只存起止步长三个数，所以 range(10 ** 18) 也不占内存，10 ** 15 in range(10 ** 18) 是 O(1) 的算术判断而不是逐个比对。
  - 步长不能为 0：range(0, 10, 0) 抛 ValueError。倒着走用负步长：list(range(5, 0, -1)) 得 [5, 4, 3, 2, 1]。
  - 起止相同（或方向反了）得到空序列：list(range(5, 5)) 是 []，list(range(5, 0)) 也是 []。
  - 要「下标 + 元素」用 enumerate(可迭代对象)，比 for i in range(len(a)): print(i, a[i]) 更短也不易错； enumerate 还能指定起始值：list(enumerate(['a', 'b'], start=1)) 得 [(1, 'a'), (2, 'b')]。
列表生成式
- 简介
  - 列表生成式（List Comprehension）是一种简洁而强大的语法，用于创建新的列表。
  - 它允许在一行代码中使用简洁的语法来生成列表，而不需要使用显式的循环。
  - 列表生成式是Python中非常常用和强大的特性，它可以简化代码，提高可读性，并且在处理列表数据时非常方便。
- 语法
  1
  [expression for item in iterable if condition]
- 说明
  - expression 是一个表达式，用于生成列表中的每个元素。
  - item 是可迭代对象 iterable 中的每个元素。
  - condition 是一个可选的条件，用于筛选满足条件的元素。
- 示例
  - 生成一个包含1到5的平方的列表
    1
    2
    squares = [x ** 2 for x in range(1, 6)]
    print(squares)
    输出：
    1
    [1, 4, 9, 16, 25]
  - 生成一个包含字符串长度的列表，仅包含长度大于5的字符串
    1
    2
    3
    words = ["apple", "banana", "cherry", "date"]
    lengths = [len(word) for word in words if len(word) > 5]
    print(lengths)
    输出：
    1
    [6, 6]
  - 生成一个包含两个列表对应位置元素的和的列表
    1
    2
    3
    4
    list1 = [1, 2, 3]
    list2 = [10, 20, 30]
    sums = [x + y for x, y in zip(list1, list2)]
    print(sums)
    输出：
    1
    [11, 22, 33]
  - 使用列表生成式遍历二维列表
    1
    2
    3
    4
    5
    matrix = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
    
    # 遍历二维列表并打印每个元素
    result = [element for row in matrix for element in row]
    print(result)
    输出：
    1
    [1, 2, 3, 4, 5, 6, 7, 8, 9]
- 注意事项
  - 列表生成式可以根据需要进行嵌套。可以在表达式中使用多个循环和条件语句，以生成更复杂的列表。
  - 列表生成式可以用于生成任何可迭代对象的列表，例如列表、元组、集合等。
  - 列表生成式相比于显式的循环代码更加简洁和可读性更高，尤其适用于生成简单的列表或对现有列表进行转换和筛选操作。
  - 列表生成式通常比同等的 for + append 快一些，但原因不是「底层是 C 循环」——它仍然是逐元素执行 Python 表达式，快主要省在每次循环都要去查一遍 append 方法。别为了这点常数去牺牲可读性。
  - 推导式有自己独立的作用域（Python 3）：v = [i for i in range(3)] 之后访问 i 会 NameError，循环变量不会外泄。
  - 类体里有个经典坑：类定义体内写 [y for _ in range(1)] 看不到同类的类变量 y（会 NameError），因为推导式的函数作用域不会向上查找类作用域。
  - 只要惰性求值、不需要一次性占内存时用生成器表达式：sum(x * x for x in range(4)) 得 14，它返回 generator，边取边算；要集合就去掉中括号写成 {c for c in "abracadabra" if c not in "abc"}。
  - 嵌套的 for 从左往右读，等价于把几层循环套起来： [e for row in matrix for e in row] 把二维列表拉平。
字典生成式
- 简介
  - 字典生成式（Dictionary Comprehension）是一种在一行代码中创建字典的简洁语法。
  - 它允许使用简洁的语法来生成字典，而不需要使用显式的循环。
  - 字典生成式是Python中非常常用和强大的特性，它可以简化代码，提高可读性，并且在处理字典数据时非常方便。
- 语法
  1
  {key_expression: value_expression for item in iterable if condition}
- 说明
  - key_expression 是一个表达式，用于生成字典中的键。
  - value_expression 是一个表达式，用于生成字典中的值。
  - item 是可迭代对象 iterable 中的每个元素。
  - condition 是一个可选的条件，用于筛选满足条件的元素。
- 示例
  - 生成一个包含1到5的数字及其平方的字典
    1
    2
    squares = {x: x ** 2 for x in range(1, 6)}
    print(squares)
    输出：
    1
    {1: 1, 2: 4, 3: 9, 4: 16, 5: 25}
  - 生成一个包含字符串及其长度的字典，仅包含长度大于4的字符串
    1
    2
    3
    words = ["apple", "banana", "cherry", "date"]
    lengths = {word: len(word) for word in words if len(word) > 4}
    print(lengths)
    输出：
    1
    {'apple': 5, 'banana': 6, 'cherry': 6}
  - 生成一个将列表中的元素作为键，元素出现的次数作为值的字典
    1
    2
    3
    fruits = ["apple", "banana", "cherry", "apple", "banana"]
    counts = {fruit: fruits.count(fruit) for fruit in fruits}
    print(counts)
    输出：
    1
    {'apple': 2, 'banana': 2, 'cherry': 1}
- 注意事项
  - 字典生成式可以根据需要进行嵌套。可以在键表达式和值表达式中使用多个循环和条件语句，以生成更复杂的字典。
  - 字典生成式可以用于生成任何可迭代对象的字典，例如列表、元组、集合等。
  - 字典生成式相比于显式的循环代码更加简洁和可读性更高，尤其适用于生成简单的字典或对现有字典进行转换和筛选操作。
  - 同理，字典生成式也是逐元素执行 Python 表达式，快在省去方法查找，不是因为「底层是 C」。
  - 上面「统计元素出现次数」那种写法 {fruit: fruits.count(fruit) for fruit in fruits} 是 O(n²) 的（每个键都要重新扫一遍列表），结果虽然对，但列表一大就慢；正式写法是 collections.Counter，而且不用推导式，一次调用就够：
    1
    2
    3
    4
    5
    6
    7
    import collections
    
    fruits = ["apple", "banana", "cherry", "apple", "banana"]
    counts = collections.Counter(fruits)
    print(counts)
    print(counts["apple"])
    print(dict(counts))
    输出：
    1
    2
    3
    Counter({'apple': 2, 'banana': 2, 'cherry': 1})
    2
    {'apple': 2, 'banana': 2, 'cherry': 1}
  - Counter 是 dict 的子类，原来当字典用的地方基本能直接替换，还多了 most_common(n)（取次数最多的 n 个，例子里返回 [('apple', 2), ('banana', 2)]）、elements() 以及加减、交集并集等操作；想要普通字典就 dict(counts) 脱一层壳。
  - 一个容易写错的反例：{fruit: collections.Counter[str](fruits) for fruit in fruits}。它不报错（Counter[str] 是 3.9+ 的类型别名，调用它等价于调用 Counter(...)），但那是把「整份列表的 Counter」当成每个键的值，得到的是三个键、每个值都是一份完整计数，而不是次数。
  - 实测差距：4 万元素下，{f: fruits.count(f) for f in fruits} 约 0.561s，collections.Counter(fruits) 约 0.0003s。

嵌套循环

简介
- 嵌套循环是指在一个循环内部包含另一个循环的结构。
- 通过嵌套循环，可以在外部循环的每次迭代中，完整地执行内部循环的所有迭代。
- 嵌套循环非常有用，可以在每次外部循环迭代时，对内部循环进行完整的迭代。这使得我们可以处理多维数据结构，例如二维列表或矩阵。通过嵌套循环，我们可以访问和操作二维结构中的每个元素。

语法

for outer_item in outer_iterable:
    # 外部循环代码

    for inner_item in inner_iterable:
        # 内部循环代码

执行流程
1. 外部循环开始，并取出第一个外部元素 outer_item。
2. 内部循环开始，并取出第一个内部元素 inner_item。执行内部循环代码。
3. 内部循环继续迭代，取出下一个内部元素，直到内部迭代对象中的所有元素都被遍历。
4. 外部循环继续迭代，取出下一个外部元素，重复步骤2和3，直到外部迭代对象中的所有元素都被遍历。

示例

从终端输入一个整数，打印如下图形

'''
1
1 2
1 2 3
1 2 3 4
...
1 2 3 4 ... n
'''

n = int(input('请输入一个整数：'))
for i in range(1, n + 1):
    for j in range(1, i + 1):
        print(j, end=' ')
    print()

打印 9x9 乘法表

for i in range(1, 10):
    for j in range(1, i + 1):
        print(f"{j} x {i} = {i * j}", end="\t")
    print()

选择排序

"""
选择排序（Selection Sort）是一种简单直观的排序算法。它的工作原理如下：
    1. 首先在未排序序列中找到最小（或最大）元素，存放到排序序列的起始位置。
    2. 然后，再从剩余未排序元素中继续寻找最小（或最大）元素，然后放到已排序序列的末尾。
    3. 以此类推，直到所有元素均排序完毕。
选择排序不是一个适用于大数据集的高效算法，因为它的平均和最坏情况下的时间复杂度均为 O(n^2)，其中 n 是数组的长度。
"""


def selection_sort(arr):
    n = len(arr)

    # 遍历数组中的所有元素
    for i in range(n - 1):
        # 将当前位置设为最小值位置
        min_index = i

        # 遍历未排序的元素
        for j in range(i + 1, n):
            # 找到一个更小的元素
            if arr[j] < arr[min_index]:
                min_index = j

        # 将找到的最小元素与第i个位置的元素交换
        arr[i], arr[min_index] = arr[min_index], arr[i]

    # 返回排序后的结果
    return arr


# 测试数组
arr = [64, 25, 12, 22, 11]
# 执行选择排序
sorted_list = selection_sort(arr)
# 打印排序后的数组
print(sorted_list)

冒泡排序

"""
1. 冒泡排序（Bubble Sort）是一种简单的排序算法，它通过重复遍历要排序的数列，比较每对相邻元素，如果它们的顺序错了（例如，从小到大排序时，前面的元素比后面的大），就把它们交换过来。遍历数列的工作是重复进行的，直到没有再需要交换的元素为止。
2. 尽管冒泡排序在理解和实现上都非常简单，但是它并不适合处理大数据集。这是因为它的平均和最坏情况的时间复杂度都是 O(n^2)，其中 n 是数组的长度。因此，在对较大的数列进行排序时，一个更高效的算法通常会被采用。
"""


def bubble_sort(arr):
    n = len(arr)

    # 遍历所有数组元素
    for i in range(n):
        # 最后 i 个元素已经到位
        for j in range(0, n - i - 1):
            # 遍历数组从 0 到 n-i-1
            # 交换：如果找到的元素大于下一个元素
            if arr[j] > arr[j + 1]:
                arr[j], arr[j + 1] = arr[j + 1], arr[j]
    # 返回排序后的结果
    return arr


# 测试数组
arr = [64, 34, 25, 12, 22, 11, 90]

# 执行冒泡排序
sorted_list = bubble_sort(arr)

# 打印排序后的数组
print(sorted_list)

注意事项
- 嵌套层数可以按需扩展，但层数一多代码复杂度和性能都会恶化，能抽成函数就抽成函数。
- break 只跳出当前这一层循环：内层 break 之后外层照常继续。实测两层循环里内层 break，外层仍然跑完全部三次。要一次跳出多层，常见做法是把循环包进函数用 return、用标志变量、或者内层 for...else 配合外层 break。

练习

遍历列表，打印：我叫xxx，今年yyy岁，我来自zzz，数据如下

lt = [
    {'name': '小王', 'age': 18, 'info': [('phone', '123'), ('dizhi', '广州')]},
    {'name': '小芳', 'age': 19, 'info': [('phone', '789'), ('dizhi', '深圳')]},
    {'name': '小杜', 'age': 22, 'info': [('phone', '567'), ('dizhi', '北京')]},
    {'name': '小孟', 'age': 28, 'info': [('phone', '000'), ('dizhi', '上海')]},
    {'name': '小乔', 'age': 26, 'info': [('phone', '111'), ('dizhi', '河南')]},
]

从终端输入两个整数m，n，打印m*n的表格：如2,5，打印如下效果
1
2
1 2 3 4 5
6 7 8 9 10

跳转语句

`break`语句

简介

break语句用于跳出当前循环（for循环或while循环），并继续执行循环之后的代码。当某个条件满足时，我们可以使用break语句提前终止循环的执行。

示例

for i in range(10):
    if i == 5:
        break
    print(i)

输出：

说明：
- 在上面的示例中，当i的值等于5时，break语句被执行，循环被提前终止。
- break 只跳出当前这一层循环，外层继续；想一次退出多层见「嵌套循环」一节。
- 判断「是不是因为没找到才退出循环」的惯用写法是 for...else：循环自然走完才执行 else，被 break 打断则不执行。

`continue`语句

简介

continue语句用于结束当前循环的当前迭代，并继续执行下一次迭代。当某个条件满足时，我们可以使用continue语句跳过当前迭代的剩余代码，直接进入下一次迭代。

示例

for i in range(10):
    if i % 2 == 0:
        continue
    print(i)

输出：

说明
- 在上面的示例中，当i的值为偶数时，continue语句被执行，当前迭代的剩余代码被跳过，直接进入下一次迭代。
- continue 会跳过循环体剩余的所有语句。在 while 里尤其注意：如果自增写在 continue 之后，这一轮就不会自增，条件永远为真 → 死循环。把计数器更新放在循环体最前面，或改用 for 循环。

`return`语句

简介

return语句用于从函数中返回一个值，并结束函数的执行。当函数执行到return语句时，它会立即返回指定的值，并且不再执行后续的代码。

示例

def add(a, b):
    return a + b


result = add(3, 4)
print(result)

输出：

说明
- 在上面的示例中，add函数接收两个参数a和b，并返回它们的和。当函数执行到return语句时，返回结果7，并结束函数的执行。
- return 结束的是整个函数，不是它所在的循环；在循环里 return 会连函数一起退出。
- 函数没有任何 return 时返回 None（return 不带值也一样），所以判断返回值要用 is None，别用 if f(): 混掉 0 / '' 这些假值。
- return 只能出现在函数体里，写在模块顶层是 SyntaxError。

`pass`语句（非跳转语句）

简介

pass语句是Python中的一个占位符语句，它不执行任何操作，仅用于保持语法的完整性。当您需要在代码块中保留一个空语句时，可以使用pass语句。

示例

for i in range(5):
    if i == 3:
        pass
    else:
        print(i)

输出：

说明
- 在上面的示例中，当i的值等于3时，pass语句被执行，但它不会执行任何操作。然后，程序继续执行下一次迭代，打印出其他值。
- 典型用途：还没实现的函数体 / 类体 / except 分支里先占位（语法要求缩进块不能为空），以及刻意忽略某个异常。真要「忽略」时优先用 contextlib.suppress(ZeroDivisionError)，比 except: pass 意图更清楚。
- 注意别和 continue 混：pass 什么都不做、继续往下执行；continue 是跳过本轮剩余语句直接进入下一轮。

前言

条件语句

if-else

if语句

elif语句

else语句

练习

match

简介

match语法

说明

示例

循环语句

while循环

while 语句

while-else 语句

练习

for循环

for 语句

for-else 语句

range() 函数

列表生成式

字典生成式

嵌套循环

练习

跳转语句

break语句

continue语句

return语句

pass语句（非跳转语句）

`match`语法

`range()` 函数

`break`语句

`continue`语句

`return`语句

`pass`语句（非跳转语句）