【人生苦短，我学 Python】（9）分支判断和循环

简述 / 前言

前面讲了输入、输出和文件的读写，但是一个程序怎么写呢？总不能都是一行行输入、赋值、输出语句吧，那么下面将引出每个编程语言都会有的，且很重要的又基础的内容：顺序结构、选择结构和循环结构。

其实这章应该要在讲完数据类型之后引出的~

1. 顺序结构

顾名思义，就是从第一行写到最后一行，且每行代码都没有缩进，如下面这个代码：

import sys

name = str(sys.argv[1])
age = int(sys.argv[2])

print(f'name: {name}, age: {age}')

都是直接按照顺序执行代码的就是顺序结构，但是在真正的开发中，这种结构很少见。

2. 选择结构

选择结构有3中形式：单分支、双分支和多分支。

2.1 单分支

格式：只有一个 if 语句的。

if (条件表达式):
    语句块

示例：

>>> if True:
...     print('小邓在森林')
...
小邓在森林

2.2 双分支

格式：只有一个 if 语句和一个 else 语句的。

if (条件表达式):
    语句块
else:
    语句块

示例：
编写 CSDN.py，代码如下（判断输出的字符串是不是小邓在森林）：

import sys

name = sys.argv[1]
if name == "小邓在森林":
    print('我是小邓在森林')
else:
    print('我不是小邓在森林')

在终端（terminal）中输入：python CSDN.py 小邓在森林

D:\MyCode\Python_Code\PyCharm>python CSDN.py 小邓在森林
我是小邓在森林

在终端（terminal）中输入：python CSDN.py 小邓在森林a

D:\MyCode\Python_Code\PyCharm>python CSDN.py 小邓在森林a
我不是小邓在森林

2.3 多分支

格式：只有一个 if 语句、一个 else 语句，但有不止1个的 elif 语句的。

if (条件表达式):
    语句块
elif (条件表达式):
    语句块

...

elif (条件表达式):
    语句块
else:
    语句块

示例：
编写 CSDN.py，代码如下（判断输出的字符串是不是小邓在森林）：

import sys

age = int(sys.argv[1])	# 注意这里要转为int类型，默认命令行参数是以字符串类型传入的！！！
if age == 20:
    print('我到20岁啦！')
elif age == 21:
    print('我到21岁啦~')
elif age == 22:
    print('我到22岁啦^_^')
else:
    print('我忘了自己几岁噜...')

在终端（terminal）中输入（具体输入什么见下面代码）：

D:\MyCode\Python_Code\PyCharm>python CSDN.py 20
我到20岁啦！

D:\MyCode\Python_Code\PyCharm>python CSDN.py 21
我到21岁啦~

D:\MyCode\Python_Code\PyCharm>python CSDN.py 22
我到22岁啦^_^

D:\MyCode\Python_Code\PyCharm>python CSDN.py 23
我忘了自己几岁噜...

3. 循环结构

循环结构就有 for 和 while。

3.1 for 循环

格式：

for 变量 in 对象集合:
    语句块

示例：

>>> for year in range(2020, 2024):
...     print(year)
...
2020
2021
2022
2023
>>> for year in [2020, 2021, 2022, 2023, 2024]:
...     print(year)
...
2020
2021
2022
2023
2024

这里的对象集合可以是：字符串、列表、元组、字典、文件、迭代器或者生成器。

3.1.1 range()

刚刚上面的代码用到了 Python 内置的 range() 方法。

格式：range(start, stop[, step])，从start开始，到stop结束（不包含stop）【就是数学中的左闭右开区间】。如果指定了可选的步长step，则序列按步长增长！

>>> list(range(2020, 2024))	# 2020~2023
[2020, 2021, 2022, 2023]
>>> list(range(2020, 2024, 2))	# 2020~2023且中间隔了一个再取
[2020, 2022]
>>> list(range(2023, 2019, -1))	# 2020~2023的逆序
[2023, 2022, 2021, 2020]
>>> list(range(2023, 2019, -2))
[2023, 2021]

注意：如果步长为负数，表示逆置整个区间，取绝对值就是步长！

3.2 while 循环

格式：当满足给定的条件时，就会一直运行，当条件不满足时才会结束循环，所以我们一般会搭配 break 语句一起使用！

while (条件表达式):
    语句块

示例：

num = 1
while num <= 5:
    print(num)
    num += 1

>>> num = 1
>>> while num <= 5:	# 当 num 大于 5 时就会结束循环
...     print(num)
...     num += 1
...
1
2
3
4
5

3.2.1 break 语句

当我们想提前退出循环时就使用 break 语句。

num = 1
while num <= 5:     # 当 num 大于 5 时就会结束循环
    if num == 3:    # 当 num 等于 3 时就会提前结束循环
        break
    print(num)
    num += 1

>>> num = 1
>>> while num <= 5:     # 当 num 大于 5 时就会结束循环
...     if num == 3:    # 当 num 等于 3 时就会提前结束循环
...         break
...     print(num)
...     num += 1
...
1
2

注意：**break语句只应用于最里层的语句，即break语句只能跳出最近的一层循环！**详见下面例子：

num = 1
while num <= 8:
    while num <= 5:  # 当 num 大于 5 时就会结束循环
        if num == 3:  # 当 num 等于 3 时就会提前结束循环
            break
        print(f'  里层循环 num = {num}')
        num += 1
    print(f'外层循环 num = {num}')
    num += 1

>>> num = 1
>>> while num <= 8:
...     while num <= 5:  # 当 num 大于 5 时 就会结束循环
...         if num == 3:  # 当 num 等于 3 时就会提前结束循环
...             break
...         print(f'  里层循环 num = {num}')

...         num += 1
...     print(f'外层循环 num = {num}')
...     num += 1
...
  里层循环 num = 1
  里层循环 num = 2
外层循环 num = 3
  里层循环 num = 4
  里层循环 num = 5
外层循环 num = 6
外层循环 num = 7
外层循环 num = 8

虽有 break 语句，但是最后还是输出了 8，这是因为外层循环没有被提前终止！

3.2.1 continue 语句

如果你不想完全跳出整个循环，而只是想跳过这一次的循环，那就用 continue 语句。

for year in range(2020, 2024):
    if year == 2021:	# 跳过2021年
        continue
    print(year)

>>> for year in range(2020, 2024):
...     if year == 2021:	# 跳过2021年
...         continue
...     print(year)
...
2020
2022
2023

一般 while 搭配 break，for 搭配 continue， 当然两者也可以交换，主要看你要完成的功能是什么！

3.3 死循环

程序一直运行不停止，即循环条件永远为真：
【谨慎运行，命令行可以使用快捷键 + 终止当前程序的运行】

while True:
    print('小邓在森林')

4. enumerate 函数

• 如果需要在循环中使用索引下标访问集合元素，则可以使用内置的enumerate()函数；
• enumerate()函数用于将一个可遍历的数据对象（如列表、元组或字符串）组合为一个索引序列，并返回一个可迭代对象，故在for循环当中可直接迭代下标和元素。

for index, year in enumerate(range(2020, 2024)):
    print(index, ' --> ', year)

>>> for index, year in enumerate(range(2020, 2024)):
...     print(index, ' --> ', year)
...
0  -->  2020
1  -->  2021
2  -->  2022
3  -->  2023

5. zip 函数

zip()函数将多个可迭代的对象中对应的元素打包成一个个元组，然后返回一个可迭代对象。如果元素个数不一致，则返回列表长度与最短的对象相同。

>>> a = [1, 2, 3, 4, 5]
>>> b = [6, 7, 8, 9, 10]
>>> list(zip(a, b))
[(1, 6), (2, 7), (3, 8), (4, 9), (5, 10)]
>>> a, b = zip(*zip(a, b))
>>> a, b
((1, 2, 3, 4, 5), (6, 7, 8, 9, 10))

利用运算符*，还可以实现将元组解压为列表。

文章传送门

上一篇文章：【人生苦短，我学 Python】（8）文件的读写和过滤器
下一篇文章：