流程控制

发表于 更新于 分类于 > > 本文字数： 5.5k 阅读时长 ≈ 18 分钟

前言

  • 在Python中，流程控制用于控制程序的执行流程，使程序能够根据特定的条件或情况来做出不同的决策。
  • Python提供了几种常用的流程控制结构，包括条件语句（if语句）、循环语句（for循环和while循环）以及跳转语句（break、continue和return语句）。

条件语句

if-else

  1. if语句

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

  2. elif语句

    • 简介
      elif语句是if语句的可选部分，用于检查多个条件。当if语句的条件为假时，会依次检查每个elif语句的条件，如果找到第一个为真的条件，就执行相应的代码块，并跳过其他的elif语句和else语句。
    • 语法
      1
      2
      3
      4
      if condition1:
          # 执行代码块1
      elif condition2:
          # 执行代码块2
    • 示例
      1
      2
      3
      4
      5
      6
      # 判断闰年
      y = int(input('请输入一个年份：'))
      if ((y % 4 == 0) and (y % 100 != 0)) or (y % 400 == 0):
          print('%d年是闰年' % y)
      else:
          print('%d年不是闰年' % y)

  3. else语句

    • 简介
      else语句是if语句的可选部分，用于在所有条件都为假时执行一段代码块。else语句没有条件，它只是在前面的if语句和elif语句的条件都为假时执行。
    • 语法
      1
      2
      3
      4
      5
      6
      if condition1:
          # 执行代码块1
      elif condition2:
          # 执行代码块2
      else:
          # 执行代码块3
    • 示例
      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      # 判断学生成绩级别
      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
    1. 输入两个数，打印较大的那个值
    2. 输入三个数，按照从小到大的顺序打印
    3. 输入一个三位数，打印其个位、十位、百位上的数
    4. 输入一个年份，判断是否为闰年，是打印一句话，不是打印一句话
    5. 输入一个整数，判断其是否既能被 3 整除，又能被 5 整除

match

  • 简介

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

  • match语法

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    match expression:
        case pattern1:
            # 执行代码块1
        case pattern2:
            # 执行代码块2
        ...
        case patternN:
            # 执行代码块N
        case _:
            # 默认情况下执行的代码块

  • 说明

    • expression是要进行模式匹配的表达式，pattern1、pattern2等是模式，用于匹配expression的不同情况。每个case后面跟着一个冒号（:），然后是相应的代码块。
    • match语句会依次检查每个case中的模式，如果找到匹配的模式，就执行相应的代码块，并跳出整个match语句。如果没有找到匹配的模式，且存在case _，则执行case _后面的代码块。如果没有找到匹配的模式，且没有case _，则match语句会引发MatchError异常。
    • 你可以用 | （“或”）将多个字面值组合到一个模式中：
      1
      2
      case 401 | 403 | 404:
          return "Not allowed"

  • 示例

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    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循环

  1. while 语句

    • 简介
      • 当条件为真（True）时，while循环会重复执行一段代码，直到条件变为假（False）。
      • 如果循环条件一直为真，循环将永远不会结束，这被称为无限循环。在编写循环时，确保有适当的终止条件，以避免无限循环。
    • 语法
      1
      2
      while condition:
          # 执行代码块

      在每次循环迭代之前，会先检查条件condition。如果条件为真，则执行代码块；如果条件为假，则跳过代码块，继续执行循环之后的代码。

    • 示例
      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      # 计算 1 到 100 的总和

      n = 100

      sum = 0
      counter = 1
      while counter <= n:
          sum = sum + counter
          counter += 1

      print("1 到 %d 之和为: %d" % (n, sum))

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

for循环

  1. 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)
      • 遍历列表
        1
        2
        3
        4
        5
        6
        7
        8
        9
        10
        11
        12
        13
        14
        15
        16
        17
        18
        19
        20
        21
        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
        """
      • 遍历字典
        • 遍历字典的键
          1
          2
          3
          4
          5
          6
          7
          8
          9
          10
          my_dict = {"name": "Alice", "age": 25, "city": "New York"}
          for key in my_dict:
              print(key)
              
          """
          输出：
          name
          age
          city
          """
        • 遍历字典的值
          1
          2
          3
          4
          5
          6
          7
          8
          9
          10
          my_dict = {"name": "Alice", "age": 25, "city": "New York"}
          for value in my_dict.values():
              print(value)
              
          """
          输出：
          Alice
          25
          New York
          """
        • 遍历字典的键值对
          1
          2
          3
          4
          5
          6
          7
          8
          9
          10
          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
          """

  2. for-else 语句

    • 简介
      for-else语句是一种特殊的语法结构，用于在for循环完全执行完毕后执行一段代码块。
    • 语法
      1
      2
      3
      4
      for item in iterable:
          # 执行代码块
      else:
          # 执行代码块

      在这个结构中，item是一个临时变量，用于迭代可迭代对象iterable中的每个元素。在每次迭代中，item会依次取得可迭代对象中的元素，并执行相应的代码块。当所有的迭代都完成时，会执行else语句后的代码块。

    • 示例
      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      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语句来执行一些收尾工作。

  3. 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()函数生成的序列是惰性求值的，即只在需要时才生成下一个整数。这使得它可以处理大范围的整数序列而不会占用过多的内存。

  4. 列表生成式

    • 简介
      • 列表生成式（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]
    • 注意事项
      • 列表生成式可以根据需要进行嵌套。可以在表达式中使用多个循环和条件语句，以生成更复杂的列表。
      • 列表生成式可以用于生成任何可迭代对象的列表，例如列表、元组、集合等。
      • 列表生成式相比于显式的循环代码更加简洁和可读性更高，尤其适用于生成简单的列表或对现有列表进行转换和筛选操作。
      • 列表生成式的性能通常比显式循环要高，因为它是在底层使用了优化的C代码来生成列表。

  5. 字典生成式

    • 简介
      • 字典生成式（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}
    • 注意事项
      • 字典生成式可以根据需要进行嵌套。可以在键表达式和值表达式中使用多个循环和条件语句，以生成更复杂的字典。
      • 字典生成式可以用于生成任何可迭代对象的字典，例如列表、元组、集合等。
      • 字典生成式相比于显式的循环代码更加简洁和可读性更高，尤其适用于生成简单的字典或对现有字典进行转换和筛选操作。
      • 字典生成式的性能通常比显式循环要高，因为它是在底层使用了优化的C代码来生成字典。

  6. 嵌套循环

    • 简介
      • 嵌套循环是指在一个循环内部包含另一个循环的结构。
      • 通过嵌套循环，可以在外部循环的每次迭代中，完整地执行内部循环的所有迭代。
      • 嵌套循环非常有用，可以在每次外部循环迭代时，对内部循环进行完整的迭代。这使得我们可以处理多维数据结构，例如二维列表或矩阵。通过嵌套循环，我们可以访问和操作二维结构中的每个元素。
    • 语法
      1
      2
      3
      4
      5
      6
      for outer_item in outer_iterable:
          # 外部循环代码
          
          for inner_item in inner_iterable:
              # 内部循环代码

    • 执行流程
      1. 外部循环开始，并取出第一个外部元素 outer_item。
      2. 内部循环开始，并取出第一个内部元素 inner_item。执行内部循环代码。
      3. 内部循环继续迭代，取出下一个内部元素，直到内部迭代对象中的所有元素都被遍历。
      4. 外部循环继续迭代，取出下一个外部元素，重复步骤2和3，直到外部迭代对象中的所有元素都被遍历。
    • 示例
      • 从终端输入一个整数，打印如下图形
        1
        2
        3
        4
        5
        6
        7
        8
        9
        10
        11
        12
        13
        14
        '''
        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 乘法表
        1
        2
        3
        4
        for i in range(1, 10):
            for j in range(1, i + 1):
                print(f"{j} x {i} = {i * j}", end="\t")
            print()
      • 选择排序
        1
        2
        3
        4
        5
        6
        7
        8
        9
        10
        11
        12
        13
        14
        15
        16
        17
        18
        19
        20
        21
        22
        23
        24
        25
        26
        27
        28
        29
        30
        31
        32
        33
        34
        35
        36
        37
        """
        选择排序（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
        2
        3
        4
        5
        6
        7
        8
        9
        10
        11
        12
        13
        14
        15
        16
        17
        18
        19
        20
        21
        22
        23
        24
        25
        26
        27
        28
        29
        30
        """
        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)

    • 注意事项
      嵌套循环的层数可以根据需求进行扩展。可以在内部循环中嵌套更多的循环，以处理更复杂的多维数据结构。但是，需要注意嵌套循环可能导致代码复杂性增加和性能下降，因此在使用嵌套循环时需要谨慎考虑。

  • 练习

    1. 遍历列表，打印：我叫xxx，今年yyy岁，我来自zzz，数据如下
      1
      2
      3
      4
      5
      6
      7
      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', '河南')]},
      ]
    2. 从终端输入两个整数m，n，打印m*n的表格：如2,5，打印如下效果
      1
      2
      1 2 3 4 5
      6 7 8 9 10

跳转语句

break语句

  • 简介
    break语句用于跳出当前循环（for循环或while循环），并继续执行循环之后的代码。当某个条件满足时，我们可以使用break语句提前终止循环的执行。
  • 示例
    1
    2
    3
    4
    for i in range(10):
        if i == 5:
            break
        print(i)
    输出：
    1
    2
    3
    4
    5
    0
    1
    2
    3
    4
  • 说明：
    在上面的示例中，当i的值等于5时，break语句被执行，循环被提前终止。

continue语句

  • 简介
    continue语句用于结束当前循环的当前迭代，并继续执行下一次迭代。当某个条件满足时，我们可以使用continue语句跳过当前迭代的剩余代码，直接进入下一次迭代。
  • 示例
    1
    2
    3
    4
    for i in range(10):
        if i % 2 == 0:
            continue
        print(i)
    输出：
    1
    2
    3
    4
    5
    1
    3
    5
    7
    9
  • 说明
    在上面的示例中，当i的值为偶数时，continue语句被执行，当前迭代的剩余代码被跳过，直接进入下一次迭代。

return语句

  • 简介
    return语句用于从函数中返回一个值，并结束函数的执行。当函数执行到return语句时，它会立即返回指定的值，并且不再执行后续的代码。
  • 示例
    1
    2
    3
    4
    5
    6
    def add(a, b):
        return a + b


    result = add(3, 4)
    print(result)
    输出：
    1
    7
  • 说明
    在上面的示例中，add函数接收两个参数a和b，并返回它们的和。当函数执行到return语句时，返回结果7，并结束函数的执行。

pass语句（非跳转语句）

  • 简介
    pass语句是Python中的一个占位符语句，它不执行任何操作，仅用于保持语法的完整性。当您需要在代码块中保留一个空语句时，可以使用pass语句。
  • 示例
    1
    2
    3
    4
    5
    for i in range(5):
        if i == 3:
            pass
        else:
            print(i)
    输出：
    1
    2
    3
    4
    0
    1
    2
    4
  • 说明
    在上面的示例中，当i的值等于3时，pass语句被执行，但它不会执行任何操作。然后，程序继续执行下一次迭代，打印出其他值。
本文结束 感谢您的阅读
正在加载今日诗词....