for循环、可迭代对象遍历，嵌套循环（break、continue，else），函数（形参，实参，返回值）

for循环和可迭代对象遍历

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

遍历一个元组或列表。

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

可迭代对象
python包含以下几种可迭代对象：
1、序列。包含：字符串、列表、元组
2、字典
3、迭代器对象（iterator）
4、生成器函数（generator）
5、文件对象

通过循环遍历各种类型的数据
1、遍历字符串中的字符

for y in ("abcdefg"):
    print(y)

2、遍历字典

d={'name':'shaohan','age':18,'job':'teacher'}
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循环，计算1-100之间数字的累加和；计算1-100之间偶数的累加和；计算1-100之间奇数的累加和。

sum_all =0  #1-100所有数的累加和
sum_odd =0   #1-100奇数的累加和
sum_even =0  # 1-100偶数的累加和
for x in range(101):
    sum_all += x
    if x%2 ==1:
        sum_odd +=x
    else:
        sum_even +=x

print("1-100累加总和{0}，奇数和{1}，偶数和{2}".format(sum_all,sum_odd,sum_even))

嵌套循环

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

1、打印如下图案
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()

2 、打印九九乘法表

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()  #换行

3、使用列表和字典存储表格中的数据（并打印出表中工资高于15000的数据）

姓名	年龄	薪资	城市
张三	20	10000	北京
李四	22	20000	上海
王五	25	30000	深圳

tb=[]
r1=dict(name="张三",age=20,salary=10000,city="北京")
r2=dict(name="李四",age=22,salary=20000,city="深圳")
r3=dict(name="王五",age=25,salary=30000,city="上海")

tb=[r1,r2,r3]
for x in tb:
    if x.get("salary")>=15000:
        print(x)

break语句和continue语句

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

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

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

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

empNum = 0
salarySum = 0
salarys = []
while True:
    s = input("请输入员工薪资（按H或h结束）")
    if s.upper()=="H":
        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))

else语句

while、for循环可以附带一个else语句。如果for、while语句没有被break语句结束，则会执行else语句，否则不执行。语法如下：
while 条件表达式：
循环体
else：
语句块

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

操作 员工一共4人，录入4位员工的薪资。全部录入后，打印提示“你已经全部录入”，最后打印输出录入的薪资和平均薪资。

salarySum = 0
salarys = []
for i in range(4):
    s = input("请输入4名员工薪资（按H或h结束）")
    if s.upper()=="H":
        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、局部变量查询较快，尽量使用局部变量。
4、连接多个字符串，使用join() 而不使用+。
5、列表进行元素插入和删除，尽量在列表尾部操作。

使用zip（）并行迭代

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

names = ("张三","李四","王五","高六")
ages = (20,30,40,50)
jobs = ("老师","工程师","公务员")

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

推导式创建序列

1、列表推导式
列表推导式生成列表对象，语法如下：
[表达式 for item in 可迭代对象 ]
{表达式 for item in 可迭代对象 if 条件判断 }

y=[x*2 for x in range(1,50) if x%5==0]
print(y)

cells = [(row,col)for row in range(1,10)for col in range(1,10)]  #可以使用两个循环
for cell in cells:
    print(cell)

2、字典推导式
字典推导式生成字典对象，格式如下：
{key_expression: value_experession for 表达式 in 可迭代对象}

my_text = "I love you, i love set,i love zhanghan"
char_count = {c:my_text.count(c)for c in my_text }
print(char_count)

3、集合推导式
格式如下：
{表达式 for item in 可迭代对象}
或者{表达式 for item in 可迭代对象 if 条件判断}

>>> {x for x in range(1,50)if x%5==0}
{35, 5, 40, 10, 45, 15, 20, 25, 30}

4、生成器推导式（元组没有推导式）
一个生成器只能运行一次，第一次迭代可以得到数据，第二次迭代就没有数据了。

gnt = (x for x in range(1,50)if x%5==0)
for x in gnt:
    print(x,end='')  #有数据
for x in gnt:
    print(x,end='')  #无数据

绘制同心圆，绘制棋盘

1、同心圆

import turtle
t = turtle.Pen()

my_colors = ("red","green","yellow","black")

t.width(4)
t.speed(5)
for i in range(5):    #0,1,2
    t.penup()
    t.goto(0,-i*10)  #0,-100,-200
    t.pendown()
    t.color(my_colors[i%len(my_colors)])
    t.circle(20+i*10)

2、绘制棋盘

import turtle

width = 40
num = 20

x1=[(-500,500),(-500+width*num,500)]
y1=[(-500,500),(-500,500-width*num)]
t = turtle.Pen()
t.speed(5)

for i in range(0,20):
    t.penup()
    t.goto(x1[0][0],x1[0][1]-40*i)
    t.pendown()
    t.goto(x1[1][0], x1[1][1]-40*i)

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

函数的基本概念

1、一个程序由一个个任务组成；函数就是代表一个任务或者一个功能。
2、函数是代码复用的通用机制。
3、python函数的分类
（1）内置函数：str（）、list（）、len（）等可以直接拿来使用。
（2）标准库函数：通过import语句导入库，然后使用其中定义的函数
（3）第三方库函数：通过import语句导入，然后使用第三方库的函数
（4）用户自定义函数：用户自己定义的函数。

函数的定义和调用

1、定义函数语法
def 函数名（[参数列表]）：
“文档字符串”
函数体/若干语句

def data01():
    print("*"*10)
    print("@"*20)

data01()
data01()
data01()

for i in range(10):
    data01()

要点：
1、我们使用def来定义函数，然后就是一个空格和函数名称；
（1）python执行def时，会创建一个函数对象，并绑定到函数名变量上
2、参数列表
（1）圆括号内是形参参数列表，有多个参数则使用逗号隔开
（2）形式参数不需要声明类型，也不需要指定函数返回值类型
（3）无参数，也必须保留空的圆括号
（4）实参列表必须与形参列表一一对应
3、return返回值
（1）如果函数体中包含return语句，则结束函数执行并返回值，如果不包含return语句，则返回None值。
4、调用函数之前必须要先定义函数，即先调用def创建函数对象
（1）内置函数对象会自动创建
（2）标准库和第三方库函数，通过import导入模块时，会执行模块中的def语句。

形参和实参

def printMax(a,b):
    if a>b:
        print(a,"较大值")
    else:
        print(b,"较大值")

printMax(14,20)
printMax(38,49)

1、a和b称为“形式参数” 用于定义。
2、在调用函数时，传递的参数称为“实际参数”。14和20就是实参，实参用于调用。

文档字符串（函数的注释）
1、通过三个单引号或者双引号来实现，中间可以加入多行文字进行说明。
2、我们调用help(函数名.doc)可以打印输出函数的文档字符串。

返回值

return返回值要点
1、如果函数体中包含return语句，则结束函数执行返回值；
2、如果函数体中不包含rename语句，则返回None值。
3、要返回多个返回值，使用列表，元组，字典集合将多个值存起来即可。

def add(a,b):
    print("计算两个数的和：{0}，{1}，{2}".format(a,b,(a+b)))
    return a+b  #返回值

c=add(40,50)
print(c*20)

def data02():
    print("hanshu")
    print("sanya")

    return  #结束函数的执行
    print("你好")  #不执行

def data03(s,d,f):
    return [s*10,d*10,f*10] #返回多个返回值

q=add(40,50)
print(q*10)
p=data02()
print(p)