Python 控制语句 (3)

Python 控制语句

选择结构

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

    单分支结构    双分支结构

多分支结构

单分支选择结构

if 语句单分支结构的语法形式如下： if 条件表达式:

语句/语句块

其中：

 

1．条件表达式：可以是逻辑表达式、关系表达式、算术表达式等等。

2．语句/语句块：可以是一条语句，也可以是多条语句。多条语句，缩进必须对齐一致。

【操作】输入一个数字，小于 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 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':'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 之间奇数的累加和。

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()而不使用+

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

1. 使用 zip()并行迭代
2. 我们可以通过 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}

1. 绘制多个同心圆

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

运行效果：

1. 【操作】绘制 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() #保证运行窗口不被自动关闭

运行结果：