python_gao'qi_4控制语句

1. 选择结构

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

　　1.1 单分支选择结构

　　距离：【操作】输入一个数字，小于 10，则打印这个数字(if_test01.py)

　　　　num = input("输入一个数字：")
　　　　if int(num)<10:
　　　　print(num)

　　1.2 条件表达式详解

　　在选择和循环结构中，条件表达式的值为 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")

　　2 双分支选择结构

　　　　双分支结构的语法格式如下：
　　　　if 条件表达式 :
　　　　语句 1/语句块 1
　　　　else:
　　　　语句 2/语句块 2

　　　举例：【操作】输入一个数字，小于 10，则打印该数字；大于 10，则打印“数字太大”

　　　　num = input("输入一个数字：")
　　　　if int(num)<10:
　　　　print(num)
　　　　else:
　　　　print("数字太大")

　　3. 三元条件运算符

　　　　三元条件运算符语法格式如下：条件为真时的值 if (条件表达式) else 条件为假时的值

　　　　num = input("请输入一个数字")
　　　　print( num if int(num)<10 else "数字太大")

　　4. 多分支选择结构

　　【操作】输入一个学生的成绩，将其转化成简单描述：不及格(小于 60)、及格(60-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))

　　【操作】已知点的坐标(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("第四象限")

　　5. 选择结构嵌套

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

　　6. 循环结构

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

　　　　6.2 for 循环和可迭代对象遍历

　　　　　　for 循环通常用于可迭代对象的遍历。for 循环的语法格式如下：
　　　　　　for 变量 in 可迭代对象：
　　　　　　循环体语句

　　　　举例：【操作】遍历一个元组或列表

　　　　　　for x in (20,30,40):
　　　　　　print(x*3)

　　　　6.3 可迭代对象　　　

　　　　举例：【操作】遍历字典

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)

2. range 对象

　　　　1.range 对象是一个迭代器对象，用来产生指定范围的数字序列。格式为：range(start, end [,step])生成的数值序列从 start 开始到 end 结束（不包含 end）。
　　　　若没有填写 start，则默认从 0开始。step 是可选的步长，默认为 1。如下是几种典型示例：

　　　　举例：【操作】利用 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))

　　　　2. 嵌套循环和综合练习

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)

3.break 语句

　　　　break 语句可用于 while 和 for 循环，用来结束整个循环。当有嵌套循环时，break 语句只能跳出最近一层的循环。

　　　　举例：【操作】使用 break 语句结束循环

while True:
a = input("请输入一个字符（输入 Q 或 q 结束）")
if a.upper()=='Q':
    print("循环结束，退出")
    break
else:
    print(a)

4.continue 语句

　　　　continue 语句用于结束本次循环，继续下一次。多个循环嵌套时，continue 也是应用于最近的一层循环。

　　　　举例：【操作】要求输入员工的薪资，若薪资小于 0 则重新输入。最后打印出录入员工的数量和薪资明细，以及平均薪资

emp Num = 0
salary Sum= 0
salarys = []
while True:
    s = input("请输入员工的薪资（按 Q 或 q 结束）")
    if s.upper()=='Q':
        print("录入完成，退出")
        break
    if float(s)<0:
        continue
    emp Num +=1
    salarys.append(float(s))
    salary Sum += float(s)
print("员工数{0}".format(emp Num))
print("录入薪资：",salarys)
print("平均薪资{0}".format(salary Sum/emp Num))
        

5.else 语句

　　　　while、for 循环可以附带一个 else 语句（可选）。如果 for、while 语句没有被 break 语句结束，则会执行 else 子句，否则不执行。语法格式如下：

　　　　举例：【操作】员工一共 4 人。录入这 4 位员工的薪资。全部录入后，打印提示“您已经全部录入 4 名员工的薪资”。最后，打印输出录入的薪资和平均薪资

salary Sum= 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))
salary Sum += float(s)
else:
print("您已经全部录入 4 名员工的薪资")
print("录入薪资：",salarys)
print("平均薪资{0}".format(salary Sum/4))

6.循环代码优化

　　　　遵守下面三个原则可以大大提高运行效率，避免不必要的低效计算：
　　1. 尽量减少循环内部不必要的计算
　　2. 嵌套循环中，尽量减少内层循环的计算，尽可能向外提。
　　3. 局部变量查询较快，尽量使用局部变量

7.列表推导式

　　　　列表推导式生成列表对象，语法如下：
　　　　　　[表达式 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']

8.字典推导式

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

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

9.集合推导式

　　　　集合推导式生成集合，和列表推导式的语法格式类似：
　　　　　　{表达式 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}

10. 生成器推导式（生成元组）　　元组是没有推导式的。

11.综合练习

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

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