Day 5
for 循环通常用于可迭代对象的遍历。for 循环的语法格式如下：
for 变量 in 可迭代对象：
循环体语句
【操作】遍历一个元组或列表
#测试for循环
for x in (10,20,30):
print(x,end='\t')结果如下：
10 20 30
可迭代对象
Python包含以下几种可迭代对象：
- 序列。包含：字符串、列表、元组
- 字典
- 迭代器对象（iteratior）
- 生成器函数（generator）
- 文件对象
【操作】遍历字符串中的字符
for y in "abcdef":
print(y,end='\t')结果：a b c d e f
【操作】遍历字典
#字典的遍历
d={'name':'zhang','age':18,'job':'程序员'}
for x in d: #遍历字典所有的key
print(x,end='\n')
for x in d.keys(): #遍历字典所有的key
print(x,end='\t')
for x in d.values(): #遍历字典所有的value
print(x, end='\t')
for x in d.items(): #遍历字典所有的键值对
print(x,end='\t')结果如下：
name
age
job
name age job zhang 18 程序员
('name', 'zhang') ('age', 18) ('job', '程序员')
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所有数累加和',sum_all)
print('1-100所有偶数累加和',sum_even)
print('1-100所有奇数累加和',sum_odd)结果：
1-100所有数累加和 5050
1-100所有偶数累加和 2550
1-100所有奇数累加和 2500
嵌套循环
一个循环体内可以嵌入另一个循环，成为“嵌套循环”
【操作】打印下列图案
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('\n') #起到换行的作用结果：
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 y in "abcdef":
print(y,end='\t')结果：a b c d e f
【操作】遍历字典
#字典的遍历
d={'name':'zhang','age':18,'job':'程序员'}
for x in d: #遍历字典所有的key
print(x,end='\n')
for x in d.keys(): #遍历字典所有的key
print(x,end='\t')
for x in d.values(): #遍历字典所有的value
print(x, end='\t')
for x in d.items(): #遍历字典所有的键值对
print(x,end='\t')结果如下：
name
age
job
name age job zhang 18 程序员
('name', 'zhang') ('age', 18) ('job', '程序员')
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之间奇数的累加和
um_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所有数累加和',sum_all)
print('1-100所有偶数累加和',sum_even)
print('1-100所有奇数累加和',sum_odd)结果：
1-100所有数累加和 5050
1-100所有偶数累加和 2550
1-100所有奇数累加和 2500
嵌套循环
一个循环体内可以嵌入另一个循环，成为“嵌套循环”
【操作】打印下列图案
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('\n') #起到换行的作用结果：
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 m in range(1,10):
for n in range(1,m+1):
print('{0}*{1}={2}'.format(m,n,(m*n)),end='\t')
print('\n')结果：
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= {'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)结果：
{'name': '高小一', 'age': 18, 'salary': 30000, 'city': '北京'}
{'name': '高小二', 'age': 19, 'salary': 20000, 'city': '上海'}
break语句
Break语句可以用于while 和for循环，用来结束整个循环。当有嵌套循环时，，break语句只能跳出最近一层的循环
【操作】使用break语句结束循环
#测试break
while True:
a = input('请输入一个字符（输入Q或者q时推出）：')
if a == 'q' or a=='Q':
print('循环结束，退出')
break
else:
print(a)结果：
请输入一个字符（输入Q或者q时推出）：d
d
请输入一个字符（输入Q或者q时推出）：a
a
请输入一个字符（输入Q或者q时推出）：q
循环结束，退出
continue语句
continue语句用于结束本次循环，继续下一次。多个循环嵌套时，continue也是用于最近的一层循环
【操作】要求输入员工的薪资，若薪资小于0则重新输入。最后打印出录入员工的数量和薪资明细，以及平均薪资
#测试break
empNum=0
salarySum=0
salary=[] #列表表示（因为列表是可变序列）
while True:
s = input('请输入员工的薪资（按Q或q退出）')
if s.upper()=='Q' or s.upper()=='q':
print('录入完成，退出')
break
if float(s)<0:
continue
empNum +=1
salary.append(float(s))
salarySum+=float(s)
print('员工数{0}'.format(empNum))
print('录入薪资：',salary)
print('平均薪资{0}'.format(salarySum/empNum))结果：
请输入员工的薪资（按Q或q退出）1000
请输入员工的薪资（按Q或q退出）2000
请输入员工的薪资（按Q或q退出）5000
请输入员工的薪资（按Q或q退出）3500
请输入员工的薪资（按Q或q退出）q
录入完成，退出
员工数4
录入薪资： [1000.0, 2000.0, 5000.0, 3500.0]
平均薪资2875.0
else语句
while、for循环可以附带一个else语句（可选）。如果for、while语句没有被break语句结束，则会执行else子句，否则不执行。语法格式如下：
while 条件表达式
循环体
else：
语句块
或者：
for 变量 in 可迭代对象：
循环体
else：
语句块
【操作】员工一共四人，录入这4位员工的薪资，全部录入后，打印提示“您已经全部录入4名员工的薪资”。最后，打印输出录入的薪资和平均水平
salarySum = 0
salaries =[]
for i in range(4):
s =input(('请输入4名员工的薪资（按Q或q中途退出）'))
if s.upper()=='Q' or s.upper()=='q':
print('录入完成，退出')
break
if float(s)<0:
continue
salaries.append(float(s))
salarySum+=float(s)
else:
print('您已经全部录入4名员工的薪资')
print('录入薪资',salaries)
print('平均薪资：',salarySum/4)结果：
请输入4名员工的薪资（按Q或q退出）5000
请输入4名员工的薪资（按Q或q退出）4000
请输入4名员工的薪资（按Q或q退出）3600
请输入4名员工的薪资（按Q或q退出）2900
您已经全部录入4名员工的薪资
录入薪资 [5000.0, 4000.0, 3600.0, 2900.0]
平均薪资： 3875.0
循环代码优化
虽然计算机越来越快，空间也越来越大，我们仍然要在性能问题上“斤斤计较”。
编写循环时，遵循下面三个原则能大大提高运行效率，避免不必要的低效计算：
- 尽量减少循环内部不必要的计算
- 嵌套循环中，尽量减少内层循环的计算，尽可能向外提
- 局部变量查询较快，尽量使用局部变量
示例：
#循环代码优化测试
import time
#方法1：
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))
#方法2：把i乘1000提到内循环外面
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.911698341369629
耗时:1.7906055450439453
其他优化手段
- 连接多个字符串，使用join（）而不适用‘+’（因为+会产生新的字符串对象）
- 列表进行元素插入和删除，尽量在列表尾部操作（中间操作的话，后面所有数据都需要重新移位拷贝，浪费时间）
使用zip（）进行迭代
我们可以通过zip（）函数对多个序列进行并行迭代，zip（）函数在最短序列“用完”时就会停止
【操作】测试zip（）并进行迭代
names=('张一','张二','张三','张四')
ages=(18,20,30,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--老师
张二--20--程序员
张三--30--医生
张一--18--老师
张二--20--程序员
张三--30--医生
推导式创建序列
推导式是从一个或者多个迭代器快速创建序列的一种方法。它可以将循环和条件判断相结合，从而避免冗长的代码。推导式是典型的Python风格，会使用它代表你已经超过Python初学者的水平。
列表推导式
列表推导式生成列表对象，语法如下：
[表达式 for item in 可迭代对象]
或者:{表达式 for item in 可迭代对象 if 条件判断}
#列表推导式
y = [x*2 for x in range(1,50) if x%5==0]
print(y)
y = []
for x in range(1,50):
if x%5==0:
y.append(x*2)
print(y)结果如下：
[10, 20, 30, 40, 50, 60, 70, 80, 90]
[10, 20, 30, 40, 50, 60, 70, 80, 90]
cells = [(row,col) for row in range(1,10) for col in range(1,10)]
print(cells)结果：
[(1, 1), (1, 2), (1, 3), (1, 4), (1, 5), (1, 6), (1, 7), (1, 8), (1, 9), (2, 1), (2, 2), (2, 3), (2, 4), (2, 5), (2, 6), (2, 7), (2, 8), (2, 9), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (3, 8), (3, 9), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (4, 8), (4, 9), (5, 1), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (5, 8), (5, 9), (6, 1), (6, 2), (6, 3), (6, 4), (6, 5), (6, 6), (6, 7), (6, 8), (6, 9), (7, 1), (7, 2), (7, 3), (7, 4), (7, 5), (7, 6), (7, 7), (7, 8), (7, 9), (8, 1), (8, 2), (8, 3), (8, 4), (8, 5), (8, 6), (8, 7), (8, 8), (8, 9), (9, 1), (9, 2), (9, 3), (9, 4), (9, 5), (9, 6), (9, 7), (9, 8), (9, 9)]
字典推导式
字典的推导式生成字典对象，格式如下：
{key_expression : value_expression for 表达式 in 可迭代对象}
类似于列表推导式，字典推导也可以增加if条件判断、多个for循环
统计文本中字符出现的次数：
#字典推导式
my_text='i love you,i love tx,i love zzm'
#定义统计列表，和字典推导式 key是c，value是my_text.count(c)统计出现的次数
char_count = {c:my_text.count(c) for c in my_text}
print(char_count)结果：
{'i': 3, ' ': 6, 'l': 3, 'o': 4, 'v': 3, 'e': 3, 'y': 1, 'u': 1, ',': 2, 't': 1, 'x': 1, 'z': 2, 'm': 1}
集合推导式
集合推导式生成集合，和列表推导式的语法格式类似：
{表达式 for item in 可迭代对象}
或者：{表达式 for item in 可迭代对象 if 条件判断}
#集合推导式
b ={x for x in range(1,100) if x%9==0}
print(b)结果：
{99, 36, 72, 9, 45, 81, 18, 54, 90, 27, 63}
生成器推导式（生成元组）
a=(x for x in range(1,100) if x%9 ==0)
print(a)结果：
<generator object <genexpr> at 0x000002D5C24AB248>
我们发现提示的是“一个生成器对象”。显然，元组是没有推导式的
一个生成器只能运行一次。第一次迭代可以得到数据，第二次迭代数据发现数据已经没有了
#生成器推导式（生成元组）
gnt = (x for x in range(1,4))
print(tuple(gnt)) #tuple（）是生成元组
print(tuple(gnt)) #第二次遍历就看不了了
gnt1 = (x for x in range(1,4))
for x in gnt1: #gnt1是生成器对象，生成器是一个可迭代的对象
print(x,end=',')
print(tuple(gnt1))结果如下：
(1, 2, 3)
()
1,2,3,()
【绘制】不同颜色的多个同心圆
#绘制不同颜色的多个同心圆
import turtle
t = turtle.Pen()
my_colors = ('red','green','blue','purple','yellow')
t.width(4)
t.speed(10) #0是最快，1是最慢的，5,10都比较快
for i in range(10): #0,1,2,3,4,5,6,7,8，9
t.penup()
t.goto(0,-i*10) #0,-10,-20,-30,-40...-90
t.pendown()
t.color(my_colors[i%len(my_colors)])
t.circle(10*(i+1)) #10,20,30,40,50..90
turtle.done() #程序执行完，窗口仍然在结果：
【绘制】棋盘
import turtle
#获取画笔
t=turtle.Pen()
#声明棋盘的单元格宽度为30，数量为18
width = 20
num = 200 // 20*2+1 #//整数除法
#200//20=10*2+1 =21
t.speed(0)
#声明列表来存取坐标
#循环绘制横向线
for i in range(num):
t.penup()
t.goto(-200,200-width*i)
t.pendown()
t.goto(200,200-width*i)
#循环绘制纵向线
for i in range(num):
t.penup()
t.goto(-200+i*width,200)
t.pendown()
t.goto(-200+i*width,-200)
turtle.done()结果：
函数用法和底层分析
函数是可重用的程序代码块。函数的作用，不仅可以实现代码的复用，更能实现代码的一致性。一致性指的是，只要修改函数的代码，则所有调用该函数的地方都得到体现。
在编写函数时，函数体中的代码写法和我们前面讲述的基本一致，只是对代码实现了封装，并增加了函数调用，传递参数、返回计算结果等内容。
为了让大家更容易理解，掌握的更深刻。我们也要深入内存进行分析。绝大多数语言内存底层都是高度相似的，也方便学习其他的语言
函数简介
函数的基本功能
- 一个程序由一个个任务组成，函数就是代表一个任务或者一个功能
- 函数是代码复用的通用机制
Python函数的分类
Python中函数分为如下几类：
- 内置函数
我们前面使用的wtr（），list（），len（）等这些都是内置函数，可以拿来直接使用
2.标准库函数
我们可以通过import语句导入库，然后使用其中定义的函数
3.第三方库函数
Python社区也提供了很多高质量的库。下载安装这些库后，也是通过import语句导入，然后可以使用这些第三方库的函数
4.用户自己定于函数
用户自己定义的函数，显然也是开发中适应用户自身需求定义的函数。今天我们学习的就是如何自己定义函数
函数的定义和调用
核心要点
Python中，定义函数的语法如下：
def 函数名([参数列表]):
‘’’文档字符串’’’
函数体/若干语句
要点：；
- 我们使用def来定义函数，然后就是一个空格和函数名称： （1）Python执行def时，会创建一个函数对象（函数也是对象），并绑定到函数名变量上
- 参数列表 （1）圆括号内是形式参数列表，有多个参数则使用逗号隔开（2）形式参数不需要声明类型，也不需要指定函数的返回值类型（3）无参数，也必须保留空的圆括号 （4）实参列表必须与形参列表一一对应
- return返回值 （1）如果函数体中包含return语句，则结束函数执行并返回值（2）如果函数体中不包含return语句，则返回None值
- 调用函数之前，必须要先定义函数，即先调用def创建函数对象 （1）内置函数对象会自动创建（2）标准库和第三方库函数，通过import导入模块时，会执行模块中的def语句
形参和实参
【操作】定义一个函数，实现两个数的比较，并返回较大的值
#测试形参、实参的基本用法
def printMax(a,b):
if a>b:
print(a,'较大值')
else:
print(b,'较大值')
printMax(10,20)
printMax(200,300)20 较大值
300 较大值
上面的printMax函数中，在定义时写的printMax（a，b）。a和b称为“形式参数”，简称“形参”。也就是说，形式参数是在定义函数时使用的。形式参数的命名只要符合“标识符”命名规律即可
在调用函数中时，传递的参数称为“实际参数”，简称“实参”。上述代码中，printMax（10,20），10和20就是实际参数
文档字符串（函数的注释）
程序的可读性最重要，一般建议在函数体开始的部分附上函数定义说明，这就是“文档字符串”，也有人成为“函数的注释”。我们通过三个单引号或者三个双引号来实现，中间可以加入多行文字进行说明
【操作】测试文档字符串的使用
def print_star(n):
'''根据传入n，打印多个星号'''
print('*'*n)
help(print_star)我们调用help（函数名.__doc__）可以打印出函数的文档字符串。执行结果如下：
结果：
Help on function print_star in module __main__:
print_star(n)
根据传入n，打印多个星号
返回值
return返回值要点：
- 如果函数体中包含return语句，则结束函数执行并返回值
- 如果函数体中不包含return语句，则返回None值
- 要返回多个返回值，使用列表、元组、字典、集合将多个值“存起来”即可
【操作】定义一个打印N个星号的无返回值的函数
def print_star(n):
'''根据传入n，打印多个星号'''
print('*'*n)
print_star(5)结果：
*****
【操作】定义一个返回两个数平均值的函数
def my_avg(a,b):
return (a+b)/2
#如下是函数的调用
c = my_avg(20,30)
print(c)结果：
25.0
def test02():
print('abc')
print("edf")
return #return的两个作用：1.返回值 2.结束函数的执行
print('hello') #不执行
d = test02()
print(d)结果：
abc
edf
None
返回多个参数：
def test03(x,y,z):
return [x*10,y*10,z*10]
print(test03(3,4,2))结果：[30, 40, 20]
