Python学习day05

控制语句

我们在前面学习的过程中，都是很短的示例代码，没有进行复杂的操作。现在，我们将开始学习流程控制语句。

前面学习的变量、数据类型（整数、浮点数、布尔）、序列（字符串、列表、元组、字典、集合），可以看做是数据的组织方式。数据可以看做是“砖块”！

流程控制语句是代码的组织方式，可以看做是“混凝土”。

一个完整的程序，离不开“砖块”，也离不开“混凝土”。他们的组合，才能让我们建立从小到“一个方法”，大到“操作系统”，这样各种各样的“软件”。

PyCharm下载和安装

下载地址：Download PyCharm: Python IDE for Professional Developers by JetBrains

下载对应的版本：

和安装普通软件一致，点击下一步即可。只有几个画面需要单独关注。

专业版需要激活，社区版不需要：

专业版激活的方式：

(1) 购买正版

(2) 试用30天

(3) 网上寻找激活码

创建项目和初始配置

1. 选择：“Create New Project”

选择路径（尽量不要包含中文），文件名：mypro01就是我们的项目名称，可以修改。

其他：

1. Project Interpreter部分是选择新建项目所依赖的python库，第一个选项会在项目中建立一个venv（virtualenv）目录，这里存放一个虚拟的python环境。这里所有的类库依赖都可以直接脱离系统安装的python独立运行。

3.Existing Interpreter关联已经存在的python解释器，如果不想在项目中出现venv这个虚拟解释器就可以选择本地安装的python环境。

那么到底这两个该怎么去选择呢，这里建议选择New Environment 可以在Base Interpreter选择系统中安装的Python解释器，这样做的好处如下：

· 1. python项目可以独立部署

· 2. 防止一台服务器部署多个项目之间存在类库的版本依赖问题发生

· 3. 也可以充分发挥项目的灵活性

2. 打开项目后，右键单击项目，创建Python文件“mypy01”

3. 运行py文件，使用右键单击编辑区，选择“Run ‘mypy01’”即可。

·字体大小设置

File→Setting→Editor→Font把字体调大一些

·UI主题风格设置

File→Setting→Appearance→Theme：darcula（吸血鬼，德古拉）

选择结构

选择结构通过判断条件是否成立，来决定执行哪个分支。选择结构有多种形式，分为：单分支、双分支、多分支。流程图如下：

单分支结构 双分支结构

多分支结构

单分支选择结构

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")

执行结果如下：

·条件表达式中，不能有赋值操作符“=”

在Python中，条件表达式不能出现赋值操作符“=”，避免了其他语言中经常误将关系运算符“==”写作赋值运算符“=”带来的困扰。如下代码将会报语法错误：

if 3<c and (c=20):

print("赋值符不能出现在条件表达式中")

双分支选择结构

双分支结构的语法格式如下：

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-89)、优秀(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("第四象限")

选择结构嵌套

选择结构可以嵌套，使用时一定要注意控制好不同级别代码块的缩进量，因为缩进量决定了代码的从属关系。语法格式如下：

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

    print("分数是{0},等级是{1}".format(score,degree[9-num]))

循环结构

循环结构用来重复执行一条或多条语句。表达这样的逻辑：如果符合条件，则反复执行循环体里的语句。在每次执行完后都会判断一次条件是否为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包含以下几种可迭代对象：

1. 序列。包含：字符串、列表、元组

2. 字典

3. 迭代器对象（iterator）

4. 生成器函数（generator）

5. 文件对象

我们已经在前面学习了序列、字典等知识，迭代器对象和生成器函数将在后面进行详解。接下来，我们通过循环来遍历这几种类型的数据：

【操作】遍历字符串中的字符

for x  in  "sxt001":
    print(x)

【操作】遍历字典

d = {'name':'Allen','age':18,'address':'深圳市'}
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之间奇数的累加和。

sum_all = 0         #1-100所有数的累加和
sum_even = 0        #1-100偶数的累加和
sum_odd = 0         #1-100奇数的累加和
for num in range(101):
    sum_all += num
    if num%2==0:sum_even += num
    else:sum_odd += num
 
print("1-100累加总和{0},奇数和{1},偶数和{2}".format(sum_all,sum_odd,sum_even))

嵌套循环和综合练习

一个循环体内可以嵌入另一个循环，一般称为“嵌套循环”，或者“多重循环”。

【操作】打印如下图案

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()

执行结果：

1*1=1

2*1=2 2*2=4

3*1=3 3*2=6 3*3=9

4*1=4 4*2=8 4*3=12 4*4=16

5*1=5 5*2=10 5*3=15 5*4=20 5*5=25

6*1=6 6*2=12 6*3=18 6*4=24 6*5=30 6*6=36

7*1=7 7*2=14 7*3=21 7*4=28 7*5=35 7*6=42 7*7=49

8*1=8 8*2=16 8*3=24 8*4=32 8*5=40 8*6=48 8*7=56 8*8=64

9*1=9 9*2=18 9*3=27 9*4=36 9*5=45 9*6=54 9*7=63 9*8=72 9*9=81

【操作】用列表和字典存储下表信息，并打印出表中工资高于15000的数据

姓名	年龄	薪资	城市
高小一	18	30000	北京
高小二	19	20000	上海
高小五	20	10000	深圳

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))

执行结果：

请输入员工的薪资（按Q或q结束）2000

请输入员工的薪资（按Q或q结束）3000

请输入员工的薪资（按Q或q结束）4000

请输入员工的薪资（按Q或q结束）5000

请输入员工的薪资（按Q或q结束）Q

录入完成，退出

员工数4

录入薪资： [2000.0, 3000.0, 4000.0, 5000.0]

平均薪资3500.0

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))

循环代码优化

虽然计算机越来越快，空间也越来越大，我们仍然要在性能问题上“斤斤计较”。编写循环时，遵守下面三个原则可以大大提高运行效率，避免不必要的低效计算：

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)))

其他优化手段

1. 连接多个字符串，使用join()而不使用+

2. 列表进行元素插入和删除，尽量在列表尾部操作

使用zip()并行迭代

我们可以通过zip()函数对多个序列进行并行迭代，zip()函数在最短序列“用完”时就会停止。

【操作】测试zip()并行迭代

names = ("Allen","Joke","Amy","Vivan")
ages = (18,16,20,25)
jobs = ("老师","程序员","公务员")

for name,age,job in zip(names,ages,jobs):
    print("{0}--{1}--{2}".format(name,age,job))

执行结果：

Allen--18--老师

Joke-16--程序员

Amy--20--公务员

注:没有输出Vivan的原因是zip()函数在最短序列中某个参数为空的时候就会停止，注意看Vivan是没有job的对应值的

推导式创建序列

推导式是从一个或者多个迭代器快速创建序列的一种方法。它可以将循环和条件判断结合，从而避免冗长的代码。推导式是典型的Python风格，会使用它代表你已经超过Python初学者的水平。

列表推导式

列表推导式生成列表对象，语法如下：

[表达式 for item in 可迭代对象 ]

或者：{表达式 for item in 可迭代对象 if 条件判断}

字典推导式

字典的推导式生成字典对象，格式如下：

{key_expression : value_expression for 表达式 in 可迭代对象}

类似于列表推导式，字典推导也可以增加if条件判断、多个for循环。

统计文本中字符出现的次数：

集合推导式

集合推导式生成集合，和列表推导式的语法格式类似：

{表达式 for item in 可迭代对象 }

或者：{表达式 for item in 可迭代对象 if 条件判断}

生成器推导式（生成元组）

很多同学可能会问：“都有推导式，元组有没有？”，能不能用小括号呢？

>>> (x for x in range(1,100) if x%9==0)

<generator object <genexpr> at 0x0000000002BD3048>

我们发现提示的是“一个生成器对象”。显然，元组是没有推导式的。

一个生成器只能运行一次。第一次迭代可以得到数据，第二次迭代发现数据已经没有了。

综合练习

绘制多个同心圆

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()   #程序执行完，窗口仍然在

运行结果：

绘制36*36棋盘

#画棋盘
import turtle

width = 16
num = 36

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,37):
    t.penup()
    t.goto(x1[0][0],x1[0][1]-16*i)
    t.pendown()
    t.goto(x1[1][0],x1[1][1]-16*i)

for i in range(0,37):
    t.penup()
    t.goto(y1[0][0]+16*i,y1[0][1])
    t.pendown()
    t.goto(y1[1][0]+16*i,y1[1][1])


t.hideturtle()   #隐藏画笔
turtle.done()   #保证运行窗口不被自动关闭