python语言第六天笔记

控制语句

1 选择

  选择结构与C语言大同小异。

（1）单分支

if 条件表达式:
	语句/语句块

其中：
  ① 条件表达式：可以是逻辑表达式、关系表达式、算术表达式等等。
  ② 语句/语句块：可以是一条语句，也可以是多条语句。多条语句，缩进必须对齐一致。

（2） 条件表达式

  在选择和循环结构中，条件表达式的值为 False 的情况如下：
  False、0、0.0、空值 None、空序列对象（空列表、空元组、空集合、空字典、空字符串）、空 range 对象、空迭代对象。
  其他情况，均为 True。这么看来，Python 所有的合法表达式都可以看做条件表达式，甚至包括函数调用的表达式。

（3） 双分支与三元运算符

if 条件表达式 :
	语句 1/语句块 1
else:
	语句 2/语句块 2

  输入一个数字，小于 10，则打印该数字；否则打印“数字太大”

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

上面的结构可以用三元运算符替代，三元运算符的表达式为：
  条件为真时的值 if (条件表达式) else 条件为假时的值

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

（4）多分支

if 条件表达式 1 :
	语句 1/语句块 1
elif 条件表达式 2:
	语句 2/语句块 2
elif 条件表达式 n :
	语句 n/语句块 n
[else:
	语句 n+1/语句块 n+1
]

中括号[]表示可选。
  需要注意的是，python语言里面没有switch—case结构。
  例：输入一个分数。分数在 0-100 之间。90 以上是 A,80 以上是 B，70 以上是 C，60以上是 D。60 以下是 E。
  可以用多分支，也可以用选择嵌套，但这里有一个更牛逼的方法：

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

2 循环

  python的循环，与C语言的循环大同小异，但是python没有do—while结构，只有for和while，而且for和while循环可以有else语句。

（1）while循环

while 条件表达式：
	循环体语句

例：利用 while 循环打印从 0-10 的数字。

num = 0
while num<=10:
	print(num)
num += 1

（2）for 循环

for 变量 in 可迭代对象：
	循环体语句

例：遍历一个元组或列表

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

（3）可迭代对象

Python 包含以下几种可迭代对象：
  1.序列。包含：字符串、列表、元组
  2.字典，集合
  3.迭代器对象（iterator），例如 zip 对象，range对象
  4.生成器对象（generator）
  5.文件对象
例：利用 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))

（4）循环嵌套

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

（5）break，continue语句

  与C语言一致

（6）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))

3 代码优化

（1）循环代码优化

  编写循环时，遵守下面三个原则可以大大提高运行效率，避免不必要的低效计算：
  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)		# i*1000 在内层循环

end = time.time()
print("耗时：{0}".format((end-start)))

start2 = time.time()
for i in range(1000):
    result = []
    c = i*1000							# 把i*1000移到外层去了
    for m in range(10000):
        result.append(c+m*100)		

end2 = time.time()
print("耗时：{0}".format((end2-start2)))

输出

耗时：4.322247266769409
耗时：3.587205171585083

  可以看到，将一些内层运算移动到外层之后，运行时间明显更短

（2）其他优化措施

  1.连接多个字符串， 使用 join()而不使用+
  2.列表进行元素插入和删除， 尽量在列表尾部操作

4 并行迭代

  只要每次从迭代器中获得元组，就能实现并行迭代

# 测试zip()并行迭代

for i in [1,2,3]:
    print(i)

names = ("高淇","高老二","高老三","高老四")
ages = (18,16,20,25)
jobs = ("老师","程序员","公务员")

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

for i in range(3):
    print("{0}--{1}--{2}".format(names[i],ages[i],jobs[i]))

输出

中国--18--老师
美国--16--程序员
俄罗斯--20--公务员

names和ages都有四个元素，而jobs只有三个元素，并行迭代时，只迭代三次

a = [(1, 10), (2, 20), (3, 30)]
for m, n in a:
    print(m,n)

输出

1 10
2 20
3 30

5 推导式创建序列

  前面介绍过了如何使用列表推导式生成列表，也讲过用生成器生成元组，其实还可以生成字典和集合。
  生成字典对象：{key_expression : value_expression for 表达式 in 可迭代对象}
  生成集合对象：{表达式 for item in 可迭代对象 }
  同列表推导式一样，还可以在后面加上 if 语句进行过滤。

s = {x for x in range(1, 100) if x%9 == 0}	# 集合推导式
print(s)

text = 'I think I will win!'
d = {key : text.count(key) for key in text}	# 字典推导式
print(d)

输出

{99, 36, 72, 9, 45, 81, 18, 54, 90, 27, 63}
{'I': 2, ' ': 4, 't': 1, 'h': 1, 'i': 3, 'n': 2, 'k': 1, 'w': 2, 'l': 2, '!': 1}

  推导式生成元组时比较特殊，因为它是先生成一个生成器对象，再在这个对象外面套上一层 tuple() 来实现，并且生成器对象与 zip 对象类似，只能使用一次，第二次就无效了。

6 综合练习

（1）绘制10个同心圆颜色可以重复

import turtle

turtle.width(20)
color = ['red', 'blue', 'green', 'yellow']
r = 50
turtle.speed(0)             # 设定速度
'''speed()可以指定0-10之间的整数，数值越大，作图速度越快。
当给定值大于10或者小于0.5，则统一设置为0，为0时就没有动画产生。
'''
for i in range(1, 11):
    turtle.penup()
    turtle.goto(0, -20*i)
    turtle.pendown()
    turtle.color(color[i%4])
    turtle.circle(50+i*20)

turtle.done()           # 程序执行完，绘图窗口仍然在

输出

（2）绘制18x18的棋盘

import turtle

turtle.speed(10)

for i in range(18):
    turtle.penup()
    turtle.goto(-180, 180-i*20)
    turtle.pendown()

    turtle.goto(160, 180-i*20)		# 第一个参数是160，如果也是180的话，那么最后将画出19条线

for i in range(18):
    turtle.penup()
    turtle.goto(-180+i*20, 180)
    turtle.pendown()

    turtle.goto(-180+i*20, -160)


turtle.done()