深度学习——第3章 Python程序设计语言（3.2 Python程序流程控制）

3.2 Python程序流程控制

目录

1.布尔数据类型及相关运算

2.顺序结构

3.选择（分支）结构

4.循环结构

无论是在机器学习还是深度学习中，Python已经成为主导性的编程语言。而且，现在许多主流的深度学习框架，例如PyTorch、TensorFlow也都是基于Python。本课程主要是围绕“理论+实战”同时进行，所以本章将重点介绍深度学习中Python的必备知识点。

布尔数据类型及相关运算

布尔数据类型（bool）

生活中，对于一个疑问通常会有Yes或者No的回答。在Python中，对问题肯定的结果用True来表示，否定的结果用False来表示。这就是布尔数据类型，它只包含两个值：

• True（真；默认值为1）
• False（假，默认值为0）

那么，Python中什么情况判定为True（真），什么情况为False（假）？

数值类型（0）、空字符串（“”）、空元组（()）、空列表（[]）、空字典（{}）为 False（假），反之布尔值为True（真）。

例如：123、“abc”、(1,2)均为True（真）。

bool(0),bool(1),bool(()),bool([])
#输出：(False, True, False, False)

bool('ABC') == 0
#输出：False

# 布尔类型示例
b = 100 < 101
print(b),type(b)
#输出：
#True
#(None, bool)

上例布尔表达式中包含了一个比较运算符“<”。除此之外， Python 还有 关系 （<, >, <=, >=, ==, !=）、逻辑（and, or, not）、成员（in, not in）、身份（is, is not）运算符，其计算结果都将评价为布尔数据类型。

关系（比较）运算符 （Comparison operator）

Python中比较（关系）运算符延续了数学中的比较运算概念。

等于（==）、不等于（!=）、大于（>）小于（<）、大于等于（>=）、小于等于（<=），比较运算符返回的结果为 True 或 False 。

等于比较运算符是双等号，要与赋值运算符的单等号区别使用。

所有关系运算符的优先级别相同。

1 == True             #输出True

False == 0            #输出True

None == False         #输出False

a, b = 23, 10
print(a == b)         #输出False
print(a != b)         #输出True
print(a > b)          #输出True
print(a < b)          #输出False
print(a >= b)         #输出True
print(a <= b)         #输出False

逻辑运算符（Logic operator）

not（逻辑非）：得到一个表达式的真假之后取相反的值。例如b = 100<101返回的值为“True”，那么b = not 100<101返回的就是False。

and （逻辑与）：左右两边表达式的值均为True时结果才为True。如a = 100<101 and 100>99，因为100<101和100>99均为真，那么a的值为True，但是，如果a = 100<101 and 100<99，那么a的值就为False。

or （逻辑或）：操作符与and操作符不同，它只需要两个表达式中有一个表达式的值为True，结果就是True，例如a = 100<101 or 100>99和b = 100<101 or 100<99，它们的返回值均为True。

# 示例
a,b,c = 2,1,3
print(a==b and b>c)       #输出False 
print(a>b or c>=b)        #输出True
print(a<b and c>=b)       #输出False 
print(not a >b)           #输出False
print(a<=b and not a<b)   #输出False
print(not a==b and b>c)   #输出False

成员运算符 （Membership operator）

成员运算符包括in和not in两个运算符，判断某元素是否为序列中的成员，是则返回值True，否返回值False。

in：在指定的序列中找到值返回 True，否则返回 False。如：x 在 y 序列中 , 如果 x 在 y 序列中返回 True。

not in：在指定的序列中没有找到值返回 True，否则返回 False，与 in是相反的。

a,b = 'a',2
list1 = [1,2,3,4,5,'b','a']

a in list1           #输出True

a not in list1       #输出False

b in list1           #输出True

b not in list1       #输出False

9 in list1           #输出False

'c' not in list1     #输出True

'c' in 'abc'          #输出True

a in 'abc'           #输出True

顺序结构

顺序结构是程序代码按照线性顺序依次执行的运行方式。

顺序结构程序实例：求解三角形面积

问题描述：

已知三角形三条边的边长（简单起见，假设这三条边可以构成三角形），求三角形的面积。

提示：三角形面积的计算公式： √ (𝑝(𝑝−𝑎)(𝑝−𝑏)(𝑝−𝑐))

其中，a、b、c是三角形三边的边长，p是三角形周长的一半。

选择（分支）结构

Python使用if语句实现程序的选择（分支）结构。

if语句使用if、else、elif三个保留关键字组合出三种常用的分支结构：

条件控制if语句，用来检验一个条件（if和冒号之间的布尔表达式）的真假。如果条件为真，运行“if <条件>:”后面的程序段（也称为if语句块)，否则跳过if块，直接处理下一个语句。

有时，if语句后面会有else子语句，之所以叫子语句，是因为else不能独立执行，只能跟在if语句后面作为if的一部分，表示if语句的条件为假时需要执行的语句块。

单分支结构

单分支if语句语法结构：

if <条件>:
	<语句块>

if为保留关键字，提示后面的语句是条件语句。

if和冒号之间的语句称之为“条件” 。

if语句首先评估<条件>的结果值，如果结果为True，则执行语句块里的语句序列，然后控制转向程序的下一条语句。如果结果为False，语句块里的语句会被跳过。

语句块是if条件满足后执行的一个或多个语句序列。

语句块中语句通过与if所在行形成缩进表达包含关系。

if语句中语句块执行与否依赖于条件判断，无论什么情况，控制都会转到if语句后与该语句同级别的下一条语句。

双分支结构

双分支if语句语法结构：

if <条件>:
    <语句块1>
else:
    <语句块2>

if、else为保留字，提示后面的语句是条件语句。

双分支语句用于区分<条件>的真假两种可能，分别形成执行路径。

语句块1是在if条件满足后执行的一个或多个语句序列。语句块2是if条件不满足后执行的语句序列。

if和else后面都有一个冒号，不可或缺，用来标志着语句块的开始。if语句块和else语句块都要相对if和else进行缩进，可以把if语句块和else语句块看作第二层级。相对于第一层级，第二层级都是一样的缩进。

二分支结构还有一种更简洁的表达方式，适合通过判断返回特定值

语法格式如下：

条件为真时的值 if 条件表达式 else 条件为假时的值

多分支结构

在Python中，使用elif关键字实现多分支结构语句。

elif其实就是else if 的简写，表示带条件的else子语句。elif同if一样，后面同样接一个条件表达式，只是elif需要在if后面的条件判定为假时执行。

多分支语法结构：

if <条件1>:
    <语句块1>
elif <条件2>:
    <语句块2>
elif <条件…>:
    <语句块…>
else:
    <语句块n>

多分支结构是双分支结构的扩展，这种形式常用于设置同一个判断条件的多条执行路径。Python依次寻找第一个结果为真的条件，执行该条件下的语句块后结束整个if–elif–else语句，如果没有任何条件为真，则else语句块会被执行。else子句是可选的。

elif作为子语句与else语句一样需要与if语句联合起来使用，不能单独出现。而且必须在if语句后面，只有在if后的条件判定为False时才会执行。

可以有多个elif，顺序是重要的，只有当前面的elif为False时，才会检查下一个elif。

语句块内可以包含着if-else或任何语句，这说明条件语句块可以是复杂语句，甚至可以是条件语句本身。这种条件语句块中包含条件语句的结构我们称之为嵌套条件语句，作为判断外层if条件之后的内层条件判断语句。

多分支结构

在Python中，使用elif关键字实现多分支结构语句。

elif其实就是else if 的简写，表示带条件的else子语句。elif同if一样，后面同样接一个条件表达式，只是elif需要在if后面的条件判定为假时执行。

多分支语法结构：

if <条件1>:
    <语句块1>
elif <条件2>:
    <语句块2>
elif <条件…>:
    <语句块…>
else:
    <语句块n>

多分支结构是双分支结构的扩展，这种形式常用于设置同一个判断条件的多条执行路径。Python依次寻找第一个结果为真的条件，执行该条件下的语句块后结束整个if–elif–else语句，如果没有任何条件为真，则else语句块会被执行。else子句是可选的。

elif作为子语句与else语句一样需要与if语句联合起来使用，不能单独出现。而且必须在if语句后面，只有在if后的条件判定为False时才会执行。

可以有多个elif，顺序是重要的，只有当前面的elif为False时，才会检查下一个elif。

语句块内可以包含着if-else或任何语句，这说明条件语句块可以是复杂语句，甚至可以是条件语句本身。这种条件语句块中包含条件语句的结构我们称之为嵌套条件语句，作为判断外层if条件之后的内层条件判断语句。

分支结构案例

案例：找出代码中的缺陷并修正

问题描述：假如小明的数学成绩达到80分得到一颗红心，英语成绩达到90分得到一块巧克力。如果两个条件都没有达到，那么需要家长签名。请查看如下所示的这段程序有没有问题？

p = 85
q = 95
if p >= 80:
    print('红心')
elif q >= 90:
    print('巧克力')
else: 
    print('家长签名')

如果有缺陷，该如何修改？

分支结构程序实例：判断某一年是否为闰年

判断条件：年份能被4整除但不能被100整除，或者能被400整除。

四年一闰，百年不闰，四百年再闰

import calendar

y = 2200

# 方法一：使用双分支条件语句嵌套
if y % 400 == 0:
    print("是闰年")
else:
    if y % 4 == 0:
        if y % 100 == 0:
            print("不是闰年")
        else:
            print("是闰年")
    else:
        print("不是闰年")


# 方法二：使用多分支条件语句
if y % 400 == 0:
    print("是闰年")
elif y % 4 != 0:
    print("不是闰年")
elif y % 100 == 0:
    print("不是闰年")
else:
    print("是闰年")


# 方法三。使用一个逻辑表达式包含所有的闰年条件
if (y % 4 == 0 and y % 100 != 0) or y % 400 == 0:
    print("是闰年")
else:
    print("不是闰年")


# 方法四。使用calendar模块的isleap函数来判断闰年，相关语句如下：
if calendar.isleap(y):
    print("是闰年")
else:
    print("不是闰年")

循环结构

循环结构用来重复执行一条或多条语句。

Python使用for和while语句来实现循环结构。

循环结构可以分为确定次数的循环和非确定次数循环。确定次数循环指循环体对循环次数有明确的定义，这类循环在Python中被称为“遍历循环”，采用for语句实现。非确定次数循环指程序不确定循环体可能的执行次数，只能通过条件判断决定是否继续执行循环体，Python采用while语句实现根据判断条件执行程序的无限循环。

遍历循环：for语句

Python通过保留字for实现“遍历循环”，基本使用方法如下：

for <循环变量> in <遍历结构>:
    <语句块>

之所以称之为“遍历循环”，是因为for语句的循环执行次数是根据遍历结构中元素个数确定的。遍历循环可以理解为从遍历结构中逐一提取元素，放在循环变量中，对于所提取的每个元素执行一次语句块。

常见的遍历结构有range函数、字符串、文件、组合数据类型。

遍历结构必须是可迭代对象，包括：系列（序列；sequence）,例如字符串（str）、列表（list）、元组（tuple）；字典（dict）；文件对象；迭代器对象（iterator）；生成器函数（generator）。
for语句的常用使用方式：

循环N次：

for i in range(N):
	<语句块>

遍历文件fi的每一行：

for i in file:
    <语句块>

遍历字符串：

for c in s:
    <语句块>    

遍历列表：

for item in list:
	<语句块>    

for循环的一般执行过程：

进入for循环，首先对for的初始语句中的range做创建或者是已有的序列做检查；

假如不为空，则循环控制变量i指向第0个元素，将该元素赋值给循环控制变量并执行for循环内的语句块；

执行完语句块后，判断序列中下一个位置有没有元素，若有，则将该元素赋值给循环控制变量i并继续执行for循环内语句块；若没有，则结束循环，这种结束方式是for循环正常结束方式。

for循环的两种结束方式：

1.正常结束；

2.在循环执行过程中在循环体内碰到break语句，则马上中途跳出，结束循环。

break语句是什么，在后面的知识点马上讲解。

内置函数range()

range() 函数用于创建一个整数列表，一般用在for循环中。

语法:

range(start, stop) 或者 range(stop) 或者 range(start, stop, step)

参数说明：

• start：计数从 start 开始。默认是从 0 开始。例如range（5）等价于range（0， 5）;
• stop：计数到 stop 结束，但不包括 stop。例如：range（0， 5） 是[0, 1, 2, 3, 4]没有5
• step：步长，默认为1。例如：range（0， 5） 等价于 range(0, 5, 1)

例如range(3,8,2)依次返回3,5,7；range(3,9,2)，依次产生3,5,7。

注意，最后一个值必须要小于终止值，所以range(3,9,2)的最后值是7而不是9。

步长step可以为负数，但是当step为负数时，产生的最后一个值要大于终止值n。 例如range(7,3,-2)依次返回7,5，最后迭代值不是3而是5。

利用嵌套循环打印九九乘法表：

无限循环：while语句

for循环语句是确定次数的循环，程序一开始就是确定循环次数，这是它的优点，也是它的缺点。当不确定循环次数只确定循环条件时，可以用Python提供的无限循环结构，使用while语句实现，一般被称为当型循环。

无限循环一直保持循环操作直到循环条件不满足时结束，不需要提前确定徃次数。

while语句格式：

while <条件>:
    <语句块>

<条件>与if语句中的判断条件（布尔表达式）一样，结果为True或False。

条件判断为真时循环体重复执行语句块中的语句，为假时循环终止，执行后续语句。

i = 1
while i <= 5:
    print(i)  #输出结果：12345(每输出一个数字都会换行)
    i=i+1 

while循环的一般执行过程：

程序中，我们初始化了一个循环控制变量i，它的起始值为1，并在每次执行循环时加1。当i的值小于等于5时，while循环控制条件的值为True，循环继续执行。

循环体内按顺序执行所有语句，本例中先打印i的值，并将i的值加1。

在下一次循环开始之前，需要再次检测循环控制条件，决定是否再次执行循环体。

当i的值递增到6时，while循环控制条件i<=5的判断结果为False，这就意味着循环要马上结束，不再执行循环体内语句。

while循环的两种结束方式：

1.<条件>为假;

2.循环体内碰到break，则马上跳出循环。break语句知识点稍候讲解。

使用while循环注意事项：

如果使用while实现计数循环，需要在循环之前对计数器进行初始化，并在每次循环中对计数器进行累加或累减，让循环条件逐渐接近为假，使得循环语句块在有限时间内结束。

for循环中循环变量逐一取自遍历结构，不需要程序维护计数器。

如果循环体忘记累加i，条件判断将会一直为真，循环体也将永远执行下去，这就是所谓的死循环程序。

# 程序：死循环示例
# i=0
# while i <= 10:
#     print(i,end=' ')
#     # i = i+1
# #i = i+1

while循环程序案例：求自然对数的底数$e$的值

问题描述：用如下近似公式求自然对数的底数$e$的值，直到最后一项的绝对值小于$10^{-6}$为止。公式：
$$e\approx 1+\frac{1}{1!}+\frac{1}{2!}+\cdots +\frac{1}{n!}$$

# 用近似公式求自然对数的底数e的值
# 直到最后一项的绝对值小于1.0E-6为止
# c5_05_while_e.py

i = 1
e = 1
t = 1
while 1 / t >= 10 ** -6:
    t *= i
    e += 1 / t
    i += 1
print("e =", e)

循环保留字：break和continue

循环结构有两个保留字：break和continue，用来辅助控制循环执行。

break语句用于退出最内层的循环结构，提前结束循环，接着执行循环语句的后继语句。当多个for、while语句彼此嵌套时，break语句只应用于最里层的语句，即break语句只能跳出最近的一层循环。

程序：break语句

for s in “BIT”:
for i in range(10):
print(s,end=‘’)
if s == ‘I’:
break
# 输出BBBBBBBBBBITTTTTTTTTT

break语句跳出了最内层for循环，但仍然继续执行外层循环。每个break语句只有能力跳出当前层次循环。

break语句通常会出现在if语句内。当if条件满足时执行break。为了区别两种结束循环的方式，要在if语句后面加else子句。

break语句案例：素数判断

问题描述：判断所输入的任意一个正整数是否为素数。

# 方法一：利用while循环和bool变量#
# 判断所输入的任意一个正整数是否为素数

m = int(input("请输入判断整数（>1）:"))
flag = True  # flag默认值True，素数
i = 2
while i ** 2 <= m and flag:
    if m % i == 0:
        flag = False
    i += 1
if flag:
    print(m, "是素数。", sep="")
else:
    print(m, "是合数。", sep="")

#方法二：利用for循环和break语句
# 判断所输入的任意一个正整数是否为素数

m = int(input("请输入判断整数（>1）:"))
k = int(m ** 0.5)

for i in range(2, k + 2):
    if m % i == 0:
        break

if i == k + 1:
    print("{}是素数。".format(m))
else:
    print("{}是合数。".format(m))

continue语句用来结束本次循环，即跳过循环体内自continue下面尚未执行的语句，返回到循环的起始处，并根据循环条件判断是否执行下一次循环。

对于while循环，继续求解循环条件。而对于for循环，程序流程接着遍历循环列表。

continue语句案例：输出100-200之间不能被3整除的数

不能被3整除的数则输出，能整除就使用continue语句跳出循环体。要求一行显示10个数。

# 显示100-200之间不能被3整除的数，要求一行显示10个数。

j = 0  # 控制一行显示的数字个数
print("100~200之间不能被3整除的数为：")
for i in range(100, 200 + 1):
    if i % 3 == 0:
        continue  # 跳过被3整除的数
    print(str.format("{0:<5}", i), end="")
    j += 1
    if j % 10 == 0:
        print()  # 一行显示10个数后换行