Python学习笔记五：控制语句
Pycharm 开发环境的下载安装配置_项目管理
控制语句
我们在前面学习的过程中，都是很短的示例代码，没有进行复杂的操作。现在，我们将开始学习流程控制语句。
前面学习的变量、数据类型（整数、浮点数、布尔）、序列（字符串、列表、元组、字典、集合）可以看做是数据的组织方式。数据可以看做是“砖块”！
流程控制语句是代码的组织方式，可以看做是 “混凝土”。
一个完整的程序，离不开“砖块”，也离不开“混凝土”。他们的组合，才能让我们建立从小到 “一个方法”，大到一个“操作系统”，这样各种各样的“软件”。
Pycharm 开发环境的使用
开始学习控制语句，就会有大量的练习，我们开始学习更加强大的IDE。目前，比较流行的IDE 是 Pycharm 。当然，好友其他IDE可供我们使用：
1. IDLE
2. PyCharm
3. wingIDE
4. Eclipse
5. IPython
Pycharm 下载和安装
下载地址： https://www.jetbrains.com/pycharm/download/#section=windows
下载对应的版本：
和安装普通软件一致，点击下一步即可。只有几个画面需要单独关注。
根据win系统是64 还是 32 位。选择不同的类型。
不导入配置：
将右侧滚动条拖到最下面，然后选择 “accept”
不发送消息：选择“Don’t send”：
激活和选择不同UI 风格
激活方式：
（1）购买正版
（2）试用30天
（3）网上寻找激活码
没有激活码 ，选择试用：
若有激活码，则输入激活码：
选择不同的UI风格：
根据自己的喜好，选择 Dracula 风格或者 IntelliJ风格。然后点击“Skip Remaining and Set Defaults”
创建项目和初始化配置
- 选择：“Create New Project”
选择路径（尽量不要包含中文），文件名：mypro01 就是我们的项目名称，可以修改。
其他
- Project Interpreter 部分是选择新建项目所以来的python 库，第一个选项会在项目中建立一个 venv（virtualenv）目录，这里存放一个虚拟的python环境。这里所有的类库依赖都可以直接脱离系统安装的python 独立运行。
- Existing Interpreter 关联已经存在的python 解释器，如果不想在项目中出现 venv 这个虚拟解释器就可以选择本地安装的python 环境。
那么到底这两个该怎么去选择呢？这里建议选择 New Enviroment 可以在Base Interpreter 选择系统中安装的 Python 解释器。这样做的好处如下：
（1）python 项目可以独立部署
（2） 防止一台服务器部署多个项目之间存在类库的版本依赖问题发生
（3） 也可以充分发挥项目的灵活性
- 打开项目后，右键单击项目，创建Python 文件 “mypy01”
- 运行 py 文件，使用右键单击编辑区，选择 Run ‘mypy01’ 即可
字体大小设置
File→Setting→Editor→Font把字体调大一些
单分支选择结构)_条件表达式详解
选择结构
选择结构通过判断条件是否成立，来决定执行哪个分支。选择结构有多种形式，分为：单分支、双分支、多分支。流程图如下：
单分支结构：
双分支结构：
多分支结构：
单分支结构
if语句单分支结构的语法形式如下：
if 条件表达式：
语句/语句块
其中：
- 条件表达式：可以是逻辑表达式、关系表达式、算术表达式等等。
- 语句/语句块：可以是一条语句，也可以是多条语句。多条语句，缩进必须对齐一致
【操作】输入一个数字，小于10 ，则打印这个数组（if_test01.py）
num = input("输入一个数字：")
if int(num)<10:
print(num)
条件表达式详解
在选择和循环结构中，条件表达式的值为 False 的情况如下：
False、0、0.0、空值None、空序列对象（空列表、空元组、空集合、空字典、空字符串）、空range对象、空迭代对象。
其他情况，均为 True。这么看来，Python 所有的合法表达式都可以看做条件表达式，甚至包括函数调用的表达式。
【操作】测试各种条件表达式
if 3: #整数作为条件表达式
print("ok")
a = [] #列表作为条件表达式，由于为空列表，是False
if a:
print("空列表，False")
s = "False" #非空字符串，是True
if s:
print("非空字符串，是True")
c = 9
if 3<c<20:
print("3<c<20")
if 3<c and c<20:
print("3<c and c<20")
if True: #布尔值
print("True")
执行结果如下：
ok
非空字符串，是True
3<c<20
3<c and c<20
True
>>>
条件表达式中，不能有赋值操作符 “=”
在python 中，条件表达式不能出现赋值操作符 “=”，避免了其他语言中经常误将关系运算符 “==” 写作赋值运算符“=”带来的困扰。
双分支选择结构
双分支选择结构格式如下：
if 条件表达式 :
语句1/语句块1
else:
语句2/语句块2
【操作】输入一个数字，小于10 ，则打印该数字；大于10，则打印“数字太大”
num = input("输入一个数字：")
if int(num)<10:
print(num)
else:
print("数字太大")
三元条件运算符
Python 提供了三元运算符，用来在某些简单双分支赋值情况。三元条件运算符语法格式如下：
条件为真时的值 if（条件表达式）else 条件为假时 的值
上一个案例代码，可以用三元条件运算符实现：
num = input("请输入一个数字")
print( num if int(num)<10 else "数字太大")
可以看到，这种写法跟更加简洁、易读
多分支选择结构
多分支选择结构的语法格式如下：
if 条件表达式1 :
语句1/语句块1
elif 条件表达式2:
语句2/语句块2
.
.
.
elif 条件表达式n :
语句n/语句块n
[else:
语句n+1/语句块n+1
]
注意：计算机行业，描述语法格式时，使用中括号【】通常表示可选，非必选。
多分支结构，介个分支之间的是有逻辑关系的，不能随意颠倒顺序。
【操作】输入一个学生的成绩，将其转化为简单描述：不及格（小于60）、及格（60-79）、良好（80-90）、优秀（90-100）
方法1（使用完整的条件表达）
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))
每个分支都少用了独立的、完整的判断，顺序可以随意移动，而不影响程序执行。
方法2（利用多分支结构）
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))
多分支结构，几个分支之间是有逻辑关系的，不能随意颠倒顺序。
【操作】已知点的坐标（x，y），判断其所在的象限
x = int(input("请输入x坐标"))
y = int(input("请输入y坐标"))
if(x==0 and y==0):print("原点")
elif(x==0):print("y轴")
elif(y==0):print("x轴")
elif(x>0 and y>0):print("第一象限")
elif(x<0 and y>0):print("第二象限")
elif(x<0 and y<0):print("第三象限")
else:
print("第四象限")
选择结构嵌套
选择结构可以嵌套，使用时一定要之一控制好不同级别diamante块的缩进量，因为缩进量决定了代码的从属关系。语法格式如下：
if 表达式1：
语句块1
if 表达式2：
语句块2
else:
语句块3
else:
if 表达式4：
语句块4
【操作】输入一个分数。分数在0-100之间。90分以上是 A ，80分以上是B，70分以上是C，60分以上是D 。60 以下是E。
循环结构
循环结构用来重复执行一条或多条语句。表达这样的逻辑：如果符合条件，则反复执行循环体里的语句。在每次执行完后都会判断一次条件是否为True，如果为True 则重复执行循环体里的语句。图示如下：
循环体里面的语句至少应该包含改变条件表达式的语句，以使循环趋于结束；否则，就会变成一个死循环。
while循环
while循环的也发格式如下：
while 条件表达式：
循环体语句
我们通过一些简单的练习，来慢慢熟悉while 循环。
【操作】利用while 循环打印从 0-10 的数字。
num=0
while num<=10:
print(num)
num+=1
【操作】利用while循环，计算 1-100 之间数字的累加和；计算1-100之间偶数的累加和，计算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 "sxt001":
print(x)
【操作】遍历字典
d = {'name':'gaoqi','age':18,'address':'西三旗001号楼'}
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
【操作】利用for循环，计算1-100 之间数字的累加和；计算1-100之间偶数的累加和，计算1-100之间奇数的累加和
嵌套循环和综合练习
一个樽还体内可以嵌入另一个循环，一般 称为 “嵌套循环”，或者 “多重循环”。
【操作】打印如下图案
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的数据
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:
语句块
【操作】员工一共4名。录入中4位员工的薪资。远不录入后，打印提示“您已经全部录入4名员工的薪资”。最后，打印输出录入的薪资和平均薪资
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))
循环代码优化
虽然计算机越来越快，空间也越来越大，我们仍然要在性能问题上“斤斤计较”。编写循环时，遵循下面三个原则可以大大提高运行效率，避免不必要的低效计算：
- 尽量减少循环内部不必要的计算
- 嵌套循环中，尽量减少内层循环的计算，极可能向外提。
- 局部变量查询就比较快，尽量使用局部变量
#循环代码优化测试
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)))
使用zip（）并行迭代
我们可以通过zip（）函数对多个序列进行并行迭代，zip（）函数在最短序列“用完”时就会停止。
【操作】测试zip（）进行迭代
names = ("高淇","高老二","高老三","高老四")
ages = (18,16,20,25)
jobs = ("老师","程序员","公务员")
for name,age,job in zip(names,ages,jobs):
print("{0}--{1}--{2}".format(name,age,job))
执行结果：
高淇--18--老师
高老二--16--程序员
高老三--20--公务员
推导式创建序列
推导式是从一个或多个迭代器快速创建序列的一种方法。它可以将循环和条件判断结合，从而避免冗长的代码。推导式是典型的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]
>>> [a for a in "abcdefg"]
['a', 'b', 'c', 'd', 'e', 'f', 'g']
>>> 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 = ' i love you, i love sxt, i love gaoqi'
>>> char_count = {c:my_text.count(c) for c in my_text}
>>> char_count
{' ': 9, 'i': 4, 'l': 3, 'o': 5, 'v': 3, 'e': 3, 'y': 1, 'u': 1, ',': 2, '
s': 1, 'x': 1, 't': 1, 'g': 1, 'a': 1, 'q': 1}
集合推导式
集合推导式生成集合，和列表推导式的语法格式类似：
{表达式 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="" 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): #0 1 2 3 4
t.penup()
t.goto(0,-i*10) #0, -100,-200,-300,-400
t.pendown()
t.color(my_colors[i%len(my_colors)])
t.circle(15+i*10) #100,200,300, 400,, 500
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.goto(x1[0][0],x1[0][1])
# t.goto(x1[1][0],x1[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() #保证运行窗口不被自动关闭
运行结果：
