控制结构

控制结构种类

在 Python 中，控制结构是一种用于控制程序流程的结构，包括条件语句、循环语句和异常处理语句。这些结构可以根据不同的条件决定程序运行的路径，并根据需要重复执行代码块或捕获和处理异常情况。

条件语句

条件语句在程序中用于根据不同的条件来控制执行不同的代码块。Python 中最常用的条件语句是 if 语句，if 语句后面跟一个布尔表达式，如果布尔表达式为真，就执行 if 语句块中的代码，否则执行 else 语句块中的代码。还有 elif 语句可以用来处理多种情况。

循环语句

循环语句用于在程序中重复执行相同的代码块，直到某个条件满足为止。Python 中有两种循环语句：for 循环和 while 循环。

for 循环通常用于遍历序列，例如列表或字符串。在 for 循环中，代码块会在每个元素上执行一次，直到循环结束。

下面是使用例：

# 循环字符串内字符
str_for_loop = 'Matplotlib'
for str_idx in str_for_loop:
    print(str_idx)
 
# 循环list中元素
list_for_loop = ['Matplotlib', 'NumPy', 'Seaborn', 'Pandas', 'Plotly', 'SK-learn']
for item_idx in list_for_loop:
    print(item_idx)
 
# 循环中嵌入 if 判断
packages_visual = ['Matplotlib', 'Seaborn', 'Plotly']
for item_idx in list_for_loop:
    print('=================')
    print(item_idx)
    if item_idx in packages_visual:
        print('A visualization tool')

# 嵌套 for 循环
for item_idx in list_for_loop:
    print('===============')
    print(item_idx)
 
    for item_idx in item_idx:
        print(item_idx)

while 循环会重复执行代码块，直到循环条件不再满足为止。循环条件在每次循环开始前都会被检查。

下面是使用例：

i = 0
while i < 5:
    print(i)
    i += 1

异常处理语句

异常处理语句用于捕获和处理程序中出现的异常情况。Python 中的异常处理语句使用 try 和 except 关键字，try 语句块包含可能引发异常的代码，而 except 语句块用于处理异常情况。

下例使用 try 和 except 捕获除数为零的异常。

try:
    x = 1 / 0
except ZeroDivisionError:
    print("除数不能为零")

条件语句

嵌套 if 判断

if...elif...else 语句

if...elif...else 语句用于判断多个条件，如果第一个条件成立，则执行 if 语句中的代码块；如果第一个条件不成立，但第二个条件成立，则执行 elif 语句中的代码块；如果前面的条件都不成立，则执行 else 语句中的代码块。

注意

elif 的语句数量没有上限。但是，如果代码中 elif 数量过多，需要考虑简化代码结构。

下面是使用例：

num = input('输入一个整数')
num = int(num)

if num > 0:
    print("num is positive")
elif num < 0:
    print("num is negative")
else:
    print("num is zero")

break、continue、pass 语句

在 Python 的 if 条件语句、for 循环语句中，可以使用 break、continue 和 pass 来控制循环的行为。

break 语句可以用来跳出当前循环。当循环执行到 break 语句时，程序将立即跳出循环体，继续执行循环外的语句。下面是一个使用 break 的例子，该循环会在 i 等于 3 时跳出。

for i in range(1, 6):
    if i == 3:
        break
    print(i)

continue 语句可以用来跳过当前循环中的某些语句。当循环执行到 continue 语句时，程序将立即跳过本次循环，继续执行下一次循环。下面是一个使用 continue 的例子，该循环会在 i 等于 3 时跳过本次循环。

for i in range(1, 6):
    if i == 3:
        continue
    print(i)

pass 语句什么也不做，它只是一个空语句占位符。在需要有语句的地方，但是暂时不想编写任何语句时，可以使用 pass 语句。下面是一个使用 pass 的例子，该循环中的所有元素都会被输 出。

for i in range(1, 6):
    pass
    print(i)

for 循环语句

下面是一些 for 循环一些常见用法。

使用 enumerate()

在 Python 中，enumerate() 是一个用于在迭代时跟踪索引的内置函数。enumerate() 函数可以将一个可迭代对象转换为一个由索引和元素组成的枚举对象。

下面是一个简单的例子，展示了如何在 for 循环中使用 enumerate() 函数。

fruits = ['apple', 'banana', 'cherry']
for index, fruit in enumerate(fruits):
    print(index, fruit)

在这个例子中，fruits 列表中的每个元素都会被遍历一遍，每次遍历都会获得该元素的值和其在列表中的索引。这些值分别被赋给 index 和 fruit 变量，并打印输出。

提示

需要注意的是，enumerate 函数的默认起始索引为 0，但是也可以通过传递第二个参数来指定起始索引。例如,如果想要从 1 开始索引，可以使用以下代码。

fruits = ['apple', 'banana', 'cherry']
for index, fruit in enumerate(fruits, 1):
    print(index, fruit)

使用 zip()

在 Python 中，zip() 函数可以将多个可迭代对象的元素组合成元组，然后返回这些元组组成的迭代器。在 for 循环中使用 zip() 函数可以方便地同时遍历多个可迭代对象，且当这些可迭代对象的长度不同时，zip() 函数会以最短长度的可迭代对象为准进行迭代。

如果想要打印出每个学生的姓名和对应的成绩，可以使用 zip() 函数和 for 循环，代码如下所示：

names = ['Alice', 'Bob', 'Charlie']
scores = [80, 90, 75]

for name, score in zip(names, scores):
    print(name, score)

在这个例子中，zip() 函数将 names 和 scores 两个列表按照位置进行组合,然后返回一个迭代器，其中的每个元素都是一个元组，元组的第一个元素为 names 列表中对应位置的元素，第二个元素为 scores 列表中对应位置的元素。在 for 循环中使用了两个变量 name 和 score，分别用来接收每个元组中的两个元素，然后打印出来即可。

注意

如果可迭代对象的长度不相等，zip() 函数会以最短长度的可迭代对象为准进行迭代。

计算向量内积：使用 zip()

可以使用 Python 的内置函数 zip() 和运算符 *，对两个向量中的对应元素逐一相乘并相加，实现向量内积运算。

下面是使用例：

# 计算向量内积

# 定义向量 a 和 b
a = [1, 2, 3, 4, 5]
b = [6, 7, 8, 9, 0]

# 初始化内积为0
dot_product = 0

# 使用for循环计算内积
for x, y in zip(a, b):
    dot_product += x * y

# 打印内积
print("向量内积为:", dot_product)

range(start, stop, step) 函数

• 参数说明

range() 是 Python 内置的函数、用于生成一个整数序列，常用于 for 循环中的计数器。参数为：

• start 序列的起始值
• stop 序列的结束值（不包含）
• step 序列中相邻两个数之间的步长（默认为 1）

range() 函数生成的是一个可迭代的对象，而不是一个列表。这样的好处是可以节省内存空间，尤其在需要生成很长的序列时。

• 使用例

a. 生成从 0 到 4 的整数序列

for i in range(4 + 1):
    print(i)

b. 生成 10 到 20 的整数序列

for i in range(10, 20 + 1):
    print(i)

c. 生成从 10 到 1 的倒序整数序列

for i in range(10, 1 - 1, -1):
    print(i)

d. 将 range() 生成的可迭代对象变成 list：

list(range(10, 1 - 1, -1))

列表生成式

在 Python 中，列表生成式（list comprehension）是一种简洁的语法形式，用于快速生成新的列表。

它的语法形式为 [expression for item in iterable if condition]，其中 expression 表示要生成的元素，item 表示迭代的变量，iterable 表示迭代的对象，if condition 表示可选的过滤条件。

举个例子，如果我们想要生成一个包含 1 到 10 之间所有偶数的列表，我们可以使用如下列表生成式。

even_numbers = [num for num in range(1, 11) if num % 2 == 0]
print(even_numbers)

在上述代码中，我们使用列表生成式创建了一个包含 1 到 10 之间所有偶数的列表。具体来说，我们使用 range(1, 11) 迭代 1 到 10 的数字，对每个数字进行取模操作，只保留余数为 0 的数字，即偶数，最终将这些数字存储到一个新的列表中。

使用列表生成式还可以嵌套，比如下例。

matrix = [[i * j for j in range(1, 4)]
                 for i in range(1, 4)]

print(matrix)
# Output: [[1, 2, 3], [2, 4, 6], [3, 6, 9]]

在上述代码中，我们使用嵌套的列表生成式创建了一个 3 × 3 的矩阵。具体来说，我们使用外部的列表生成式迭代 1 到 3 的数字，对每个数字使用内部的列表生成式迭代 1 到 3 的数字，计算它们的乘积并将结果存储到一个新的二维列表中。

提示

使用列表生成式可以大大简化代码，提高代码的可读性和可维护性。

迭代器

itertools 是 Python 标准库中的一个模块，提供了用于创建和操作迭代器的函数。迭代器是一种用于遍历数据集合的对象，它能够逐个返回数据元素，而无需提前将整个数据集加载到内存中。

itertools 模块包含了一系列用于高效处理迭代器的工具函数，这些函数可以帮助我们在处理数据集时节省内存和提高效率。它提供了诸如组合、排列、重复元素等功能，以及其他有关迭代器操作的函数。

不放回排列

itertools.permutations 是 Python 标准库中的一个函数，用于返回指定长度的所有可能排列方式。下面举例如何使用 itertools.permutations 函数。

假设有一个字符串 string = 'abc'，我们想要获取它的所有字符排列方式，可以按照以下步骤操作。

import itertools
string = 'abc'
perms_all = itertools.permutations(string)
# 返回一个可迭代对象perms，其中包含了string的所有排列方式

# 全排列
res = []
for perm_idx in perms_all:
    res.append("".join(perm_idx))

print(res)
    
# ['abc', 'acb', 'bac', 'bca', 'cab', 'cba']

itertools.permutations 函数还有一个可选参数 r，用于指定返回的排列长度。如果不指定 r，则默认返回与输入序列长度相同的排列。例如，我们可以通过以下方式获取 string 的所有长度为 2 的排列。

import itertools
string = 'abc'

# 3个不放回取2个的排列
perms_2 = itertools.permutations(string, 2)

# 返回一个包含所有长度为2的排列的可迭代对象perms
res = []
for perm_idx in perms_2:
    res.append("".join(perm_idx))

print(res)

# ['ab', 'ac', 'ba', 'bc', 'ca', 'cb']

不放回组合

itertools.combinations 是 Python 中的一个模块，它提供了一种用于生成组合的函数。

使用 itertools.combinations 函数，需要导入 itertools 模块，然后调用 combinations 函数，传入两个参数：一个可迭代对象和一个整数，表示要选择的元素个数。该函数会返回一个迭代器，通过迭代器你可以获得所有可能的组合。

import itertools
string = 'abc'

# 3个取2个的组合
combs_2 = itertools.combinations(string, 2)

# 返回一个包含所有长度为2的组合的可迭代对象combs_2
res = []
for combo_idx in combs_2:
    res.append(''.join(combo_idx))
    
print(res)

# ['ab', 'ac', 'bc']

什么是排列？什么是组合？

排列是指从一组元素中按照一定顺序选择若干个元素形成的不同序列，每个元素只能选取一次。

组合是指从一组元素中无序地选择若干个元素形成的不同集合，每个元素只能选取一次。

有放回排列

前文介绍的排列、组合都是无放回抽样，下面聊聊有放回抽样。还是以小球为例，有放回抽样就是从口袋中摸出一个球之后，记录字母，然后将小球再放回口袋。下一次抽取时，这个球还有被抽到的机会。

itertools 模块中的 itertools.product 函数可以用于生成有放回排列。它接受一个可迭代对象和一个重复参数，用于指定每个元素可以重复出现的次数。

import itertools

string = 'abc'
# 定义元素列表
elements = list(string)
# 指定重复次数
repeat = 2

# 生成有放回排列
permutations = itertools.product(elements, repeat=repeat)

# 遍历并打印所有排列
res = []
for permutation_idx in permutations:
    res.append(''.join(permutation_idx))
    
print(res)

# ['aa', 'ab', 'ac', 'ba', 'bb', 'bc', 'ca', 'cb', 'cc']

有放回组合

itertools 模块中的 itertools.combinations_with_replacement 函数可以用于生成有放回组合。该函 数接受一个可迭代对象和一个整数参数，用于指定从可迭代对象中选择元素的个数。

import itertools

string = 'abc'
# 定义元素列表
elements = list(string)

# 指定组合长度
length = 2

# 生成有放回组合
combos = itertools.combinations_with_replacement(elements, length)

# 遍历并打印所有组合
res = []
for combination_idx in combos:
    res.append(''.join(combination_idx))

print(res)

# ['aa', 'ab', 'ac', 'bb', 'bc', 'cc']