今天开始学习第四章😎
第 四 章 流程控制语句
前言
经过前几篇博客的入门，想必大家对于python编程有了一定的了解。从本节开始我们会进一步深入学习python语言基础，只有把基础学好，后面的学习才会越学越轻松！！！😘
本篇博客我会介绍关于流程控制语句的使用，前面我们学习的变量、数据类型、序列可以看作是数据的组织方式，而流程控制语句是代码的组织方式。只有流程控制语句和数据的相结合，才能编写出各式各样的软件，现在让我们一起开始学习之旅吧🤞
pycharm开发环境的使用
在开始学习之前，我们来做一下准备工作，俗话说：磨刀不误砍柴工嘛。从本节开始，我们将会有大量的练习，因此单调的命令行窗口已经不能满足我们的需求。我们需要更加强大的IDE。目前比较流行的IDE我推荐使用pycharm。当然你也可以选择以下几种IDE：
1、IDLE
2、Pycharm
3、wingIDE
4、Eclipse
5、Ipython
6、Jupyter Notebook
pycharm下载和安装
下载地址：Download Pycharm
根据自己的操作系统选择合适的Pycharm安装。
安装过程中几个步骤注意一下（以windows系统为例）：
- 根据 win系统是64 还是32 位，选择不同的类型。
- 不导入配置：
激活和选择不同UI风格
激活的方式：
(1) 购买正版
(2) 试用 30天
(3) 网上寻找激活码(公众号：软件安装管家 里有详细的教程和破解的软件）
选择不同的UI风格：
根据自己喜好，选择Dracula 风格或者 IntelliJ 风格。然后点击“SkipRemainingand Set Defaults”
创建项目和初始配置
1. 选择：“Create New Project
2. 选择路径（尽量不要包含中文），文件名：mypro01就是我们的项目名称，可以修改。
3.打开项目后，右键单击项目，创建Python文件“mypy01”
4.运行py 文件：使用右键单击编辑区，选择“Run ‘mypy01’”即可。
补充：
Project Interpreter 部分是选择新建项目所依赖的python库，第一个选项会在项目中建立一个 venv（virtualenv）目录，这里存放一个虚拟的python环境。这里所有的类库依赖都可以直接脱离 系统安装的python独立运行。
ExistingInterpreter 关联已经存在的python解释器，如果不想在项目中出现 venv 这个虚拟解释 器就可以选择本地安装的python环境。
这里建议选择New Environment 可以在 Base Interpreter 选择 系统中安装的Python解释器，这样做的好处如下：
1. python项目可以独立部署
2. 防止一台服务器部署多个项目之间存在类库的版本依赖问题发生
3. 也可以充分发挥项目的灵活性
选择结构
选择结构通过判断条件是否成立，来决定执行哪个分支。选择结构有多种形式，分为：单分支、双分支、多分支。流程图如下：
单分支选择结构
if语句单分支结构的语法形式如下：
if 条件表达式:
语句/语句块
其中：
1 ．条件表达式：可以是逻辑表达式、关系表达式、算术表达式等等。
2 ．语句/语句块：可以是一条语句，也可以是多条语句。多条语句，缩进必须对齐一
【操作】输入一个数字，小于10则打印这个数字：
>>> num = input("输入一个数字：")
输入一个数字：6
>>> if int(num)<10:
print(num)
6
条件表达式详解
在选择和循环结构中，条件表达式的值为 False的情况如下：
False、0、0.0、空值 None、空序列对象（空列表、空元祖、空集合、空字典、空字符串）、空range 对象、空迭代对象。
其他情况下，都是True，包括函数调用的表达式
【操作】测试各种表达式：
>>> if 3: #整数作为表达式
print("True")
True
>>> s = [] #列表作为条件表达式 空列表为False
>>> if s:
print("空列表 False")
>>> s = "False" #非空字符串 True
>>> if s:
print("非空字符串 True")
非空字符串 True
条件表达式中不能出现赋值操作符“=”
在Python中，条件表达式不能出现赋值操作符“=”，避免了其他语言中经常误将关系运 算符“==”写作赋值运算符“=”带来的困扰。如下代码将会报语法错误：
if 3<c and (c=20):
print("赋值操作符不能出现在条件表达式中")
SyntaxError: invalid syntax
双分支选择结构
双分支结构的语法格式如下：
if 条件表达式 :
语句 1/语句块 1
else:
语句 2/语句块 2
【操作】输入一个数字，小于10，则打印该数字，大于10，则打印“数字大于10”：
num = input("输入一个数字：")
if int(num)<10:
print(num)
else:
print("数字大于10")
三元条件运算符
Python提供了三元运算符，用来在某些简单双分支赋值情况。三元条件运算符语法格式如下：
条件为真时的值 if (条件表达式) else 条件为假时的值
示例：
num = input("输入一个数字：")
if int(num)<10:
print(num)
else:
print("数字大于10")
#上述代码使用三元运算符
num = input("输入一个数字：")
print(num if int(num) < 10 else "数字大于10")
有时使用三元运算符可以使代码更加简洁。
多分支选择结构
语法格式：
if 条件表达式 1 :
语句 1/语句块 1
elif 条件表达式 2:
语句 2/语句块 2
.
.
.
elif 条件表达式 n :
语句 n/语句块n
[else:
语句 n+1/语句块 n+1
]
[ ]表示非必选即可要可不要
多分支结构，几个分支之间是有逻辑关系的，不能随意颠倒顺序。
【操作】输入一个学生成绩，将其转化成：不及格（小于60分）、及格（69,=79）、良好（80-89）、优秀（90-100）：
方法一：（使用完整的条件表达式）
score = int(input("请输入分数："))
grade = ''
if(score<60):
grade = '不及格'
if(60 <=score <80):
grade = '及格'
if(80 <= score <90):
grade = '良好'
if(90 <= score <=100):
grade = '优秀'
print("分数是：{0},等级是:{1}".format(score,grade))
每个分支都使用了独立的、完整的判断，顺序可以随意挪动，而不影响程序运行。
方法二：（利用多分支结构）
score = int(input("请输入分数"))
grade = ''
if score<60 :
grade = "不及格"
elif score<80 :
grade = "及格"
elif score<90 :
grade = "良好"
elif score<=100:
grade = "优秀"
print("分数是{0},等级是{1}".format(score,grade))
多分支结构，几个分支之间是有逻辑关系的，不能随意颠倒顺序。
选择结构嵌套
选择结构可以嵌套，使用时一定要注意控制好不同级别代码块的缩进量，因为缩进量决定了 代码的从属关系。
语法结构如下：
if 表达式 1：
语句块1
if 表达式 2：
语句块2
else:
语句块3
else:
if 表达式 4：
语句块4
看着有点复杂，但我们做个练习就能理解了
【操作】输入一个分数。分数在0~100之间。90以上是A，80以上是B，70以上是C，60以上是D，60以下是E：
score = int(input("请输入一个在 0-100 之间的数字："))
grade = ""
if score>100 or score<0:
score = int(input("输入错误！请重新输入一个在 0-100 之间的数字："))
else:
if score>=90:
grade = "A"
elif score>=80:
grade = 'B'
elif score>=70:
grade = 'C'
elif score>=60:
grade = 'D'
else:
grade = 'E'
print("分数为{0},等级为{1}".format(score,grade))
下面还有个更简单的写法，需要动点脑子哦：
score = int(input("请输入一个在 0-100 之间的数字："))
degree = "ABCDE"
num = 0
if score>100 or score<0:
score = int(input("输入错误！请重新输入一个在 0-100 之间的数字："))
else:
num = score//10
if num<6:
num=5
if num==10:
num=9
print("分数是{0},等级是{1}".format(score,degree[9-num]))
循环结构
循环结构用来重复执行一条或多条语句。表达这样的逻辑：如果符合条件，则反 复执行循环体里的语句。在每次执行完后都会判断一次条件是否为 True，如果 为True则重复执行循环体里的语句。图示如下：
循环体里面的语句至少应该包含改变条件表达式的语句，以使循环趋于结束。否则，就会变成一个死循环。
while循环
while 循环的语法格式如下：
while 条件表达式：
循环体语句
【操作】使用while循环打印从0~10的数字
num = 0
while num<=10:
print(num)
num += 1
【操作】使用while循环计算1~100之间数字的累加和：
num = 0
sum_all = 0 #1-100 所有数的累加和
sum_even = 0 #1-100 偶数的累加和
sum_odd = 0 #1-100 奇数的累加和
while num<=100:
sum_all += num
if num%2==0:
sum_even += num
else:
sum_odd += num
num+=1 #迭代，改变条件表达式，使循环趋于结束
print("1-100 所有数的累加和",sum_all)
print("1-100 偶数的累加和",sum_even)
print("1-100 奇数的累加和",sum_odd)
for循环和可迭代 对象遍历
for 循环通常用于可迭代对象的遍历。for 循环的语法格式如下：
for 变量 in 可迭代对象：
循环体语句
【操作】遍历一个元组或列表：
for x in (20,30,40):
print(x*3)
可迭代对象
Python包含以下几种可迭代对象：
- 序列。包含：字符串、列表、元组
- 字典
- 迭代器对象（iterator）
- 生成器函数（generator）
- 文件对象
【操作】遍历字符串序列中的字符：
for x in "shy-2xixi":
print(x)
【操作】遍历字典：
d = {'name':'shy-2','age':18,'job':'student'}
for x in d: #遍历字典所有的key
print(x)
for x in d.keys(): #遍历字典所有的key
print(x)
for x in d.values(): #遍历字典所有的value
print(x)
for x in d.items(): #遍历字典所有的“键值对”
print(x)
range对象
range 对象是一个迭代器对象，用来产生指定范围的数字序列。格式为：
range(start, end [,step])
生成的数值序列从start 开始到 end结束（不包含 end）。若没有填写start，则默认从 0 开始。step是可选的步长，默认为 1。如下是几种典型示例：
for i in range(10) 产生序列：0 1 2 3 4 5 6 7 8 9
for i in range(3,10) 产生序列：3 4 5 6 7 8 9
for i in range(3,10,2) 产生序列：3 5 7 9
嵌套循环
一个循环体内可以嵌入另一个循环，一般称为“嵌套循环”，或者“多重循环”。
【操作】打印以下图表：
0 0 0 0 0
1 1 1 1 1
2 2 2 2 2
3 3 3 3 3
4 4 4 4 4
for x in range(5):
for y in range(5):
print(x,end='\t')
print() #仅用于换行
【操作】使用嵌套循环打印九九乘法表：
for m in range(1,10):
for n in range(1,m+1):
print("{0}*{1}={2}".format(m,n,(m*n)),end="\t")
print()
【操作】用列表和字典存储下表信息并打印工资高于15000的数据
r1= dict(name="高小一",age=18,salary=30000,city="北京")
r2= dict(name="高小二",age=19,salary=20000,city="上海")
r3= dict(name="高小三",age=20,salary=10000,city="深圳")
tb = [r1,r2,r3]
for x in tb:
if x.get("salary")>15000:
print(x)
break语句
break语句可用于 while 和for 循环，用来结束整个循环。当有嵌套循环时，break 语句只 能跳出最近一层的循环。
【操作】使用break语句结束循环：
while True:
a = input("请输入一个字符（输入 Q或 q结束）")
if a.upper()=='Q':
print("循环结束，退出")
break
else:
print(a)
continue语句
continue 语句用于结束本次循环，继续下一次。多个循环嵌套时，continue 也是应用于最近的一层循环。
【操作】要求输入员工的薪资，若薪资小于0则重新输入。最后打印出录入员工的数量和薪资说明以及平均工资：
empNum = 0
salarySum = 0
salarys = []
while True:
s = input("输入员工的薪资：（按Q或q结束）")
if s.upper() == 'Q':
print("录入完成 退出")
break
if float(s)<0:
continue
empNum += 1
salarys.append(float(s))
salarySum += float(s)
print("员工数{0}".format(empNum))
print("录入薪资：",salarys)
print("平均薪资{0}".format(salarySum/empNum))
else语句
while、for 循环可以附带一个 else 语句（可选）。如果for、while 语句没有被break 语句 结束，则会执行else 子句，否则不执行。语法格式如下：
while 条件表达式：
循环体
else:
语句块
或者：
for 变量 in 可迭代对象：
循环体
else:
语句块
【操作】员工一共四人，录入这四位员工的薪资。全部录入后，打印提示：“您已经全部录入这四名员工的薪资”。最后打印录入的薪资和平均薪资：
salarySum= 0
salarys = []
for i in range(4):
s = input("请输入一共4名员工的薪资（按 Q或 q中途结束）")
if s.upper()=='Q':
print("录入完成，退出")
break
if float(s)<0:
continue
salarys.append(float(s))
salarySum += float(s)
else:
print("您已经全部录入4 名员工的薪资")
print("录入薪资：",salarys)
print("平均薪资{0}".format(salarySum/4))
循环代码优化
虽然现在计算机运行速度越来越快，空间越来越大，但我们仍然在性能上更进一步。编写循环时，遵守一些规则会使得代码运行效率大大提高，避免不必要的低效计算：
1.尽量减少循环内部不必要的计算
2.嵌套循环中，尽量减少内层循环的计算
3.局部变量查询比较快，尽量使用局部变量
【操作】循环代码优化测试：
import time
start = time.time()
for i in range(1000):
result = []
for m in range(10000):
result.append(i*1000+m*100)
end = time.time()
print("耗时：{0}".format((end - start)))
start2 = time.time()
for i in range(1000):
result = []
c = i*1000
for m in range(10000):
result.append(c+m*100)
end2 = time.time()
print("耗时：{0}".format((end2-start2)))
输出结果：
耗时：2.003817558288574
耗时：1.414168357849121
其他优化手段
- 连接多个字符串，使用 join()而不使用+
- 列表进行元素插入和删除，尽量在列表尾部操作
使用zip（）并行迭代
我们可以通过 zip()函数对多个序列进行并行迭代，zip()函数在最短序列“用完”时就会停止。
【操作】测试zip（）并行迭代
names = ('shy-1','shy-2','shy-3','shy-4')
ages = (16,17,18,19)
jobs = ('员工1','员工二','员工三','员工四')
for name,age,job in zip(names,ages,jobs):
print("{0}--{1}--{2}".format(name,age,job))
输出结果：
shy-1–16–员工1
shy-2–17–员工二
shy-3–18–员工三
shy-4–19–员工四
推导式创建序列
推导式是从一个或者多个迭代器快速创建序列的一种方法。它可以将循环和条件判断结合， 从而避免冗长的代码。推导式是典型的Python 风格，会使用它代表你已经超过Python初 学者的水平。
列表推导式
列表推导式生成列表对象，语法如下：
[表达式 for item in 可迭代对象 ]
或者：
{表达式 for item in 可迭代对象 if 条件判断}
>>> [x for x in range(1,5)]
[1, 2, 3, 4]
>>> [x*2 for x in range(1,5)]
[2, 4, 6, 8]
>>> [x*2 for x in range(1,20) if x%5 == 0]
[10, 20, 30]
>>> cells = [(row,col) for row in range(1,10) for col in range(1,10)]
>>> for cell in cells:
... print(cell)
字典推导式
字典的推导式生成字典对象，格式如下：
{key_expression : value_expression for 表达式 in 可迭代对象}
类似于列表推导式，字典推导也可以增加 if条件判断、多个 for 循环。
【操作】统计文本中字符出现的次数：
>>> my_text = 'ashcow ojcjaj appjajwiq,ja,sajap'
>>> char_count = {c : my_text.count(c) for c in my_text}
>>> char_count
{'a': 7, 's': 2, 'h': 1, 'c': 2, 'o': 2, 'w': 2, ' ': 2, 'j': 7, 'p': 3, 'i': 1, 'q': 1, ',': 2}
集合推导式
集合推导式生成集合，和列表推导式的语法格式类似：
{表达式 for item in 可迭代对象 }
或者：
{表达式 for item in 可迭代对象 if 条件判断}
>>>{x for x in range(1,100) if x%9 == 0}
{99, 36, 72, 9, 45, 81, 18, 54, 90, 27, 63}
生成器推导式 (生成元组）
上述我们了解了字符串、字典、集合、列表这些序列的推导式，那么元组这个序列有没有推导式呢？
>>>(x for x in range(1,100) if x%9 == 0)
<generator object <genexpr> at 0x0000000002BD3048>
我们发现提示的是“一个生成器对象”。显然，元组是没有推导式的。
一个生成器只能运行一次。第一次迭代可以得到数据，第二次迭代发现数据已经没有了。
>>> gnt = (x for x in range(1,100) if x%9==0)
>>> for x in gnt: print(x,end=' ')
9 18 27 36 45 54 63 72 81 90 99
>>> for x in gnt:
print(x,end=' ')
>>> #空白
综合练习
【操作】绘制多个同心圆
import turtle
t = turtle.Pen()
my_colors = ("red",'green','yellow','black')
t.width(4)
t.speed(1)
for i in range(10):
t.penuo90
t.goto(0,-i*10)
t.pendown()
t.color(my_colors[i%len(my_colors)])
t.circle(15+i*10)
turtle.done() #程序运行完窗口依然存在
【操作】绘制18*18的棋盘：
import turtle
width = 30
num = 18
x1 = [(-400,400),(-400+width*num,400)]
y1 = [(-400,400),(-400,400-width*num)]
t = turtle.Pen()
t.speed(10)
# t . g o t o ( x 1 [ 0 ] [ 0 ] , x 1 [ 0 ] [ 1 ] )
# t . g o t o ( x 1 [ 1 ] [ 0 ] , x 1 [ 1 ] [ 1 ] )
for i in range(0,19):
t.penup()
t.goto(x1[0][0],x1[0][1]-30*i)
t.pendown()
t.goto(x1[1][0],x1[1][1]-30*i)
for i in range(0,19):
t.penup()
t.goto(y1[0][0]+30*i,y1[0][1])
t.pendown()
t.goto(y1[1][0]+30*i,y1[1][1])
t.hideturtle()
# 隐 藏 画 笔
turtle.done() #程序运行完窗口依然存在
2301
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
