python第五次

for循环和可迭代对象遍历

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

遍历字符串中的字符：

for x in "sxt101":
    print(x)
#返回 s x t 1 0 1

遍历字典：

d = {'name':'gaoqi','age':18,'address':'西三'}
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对象

sum_all = 0
sum_even = 0
sum_odd = 0
for num in range(101):
    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 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()#换行

练习

#使用列表和字典存储表格的数据
tb = []
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语句只能跳出最近一层的循环，结束整个循环，continue继续下一次

#测试break
while True:
    a = input("请输入字符（输入Q，q时退出）")
    if a=="q" or a =="Q":
        print("结束")
        break
    else:
        print(a)

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

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

薪资小于0，无效，不计入

else语句

empNum = 0
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))

循环代码 优化：

#循环代码优化测试
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（）不适用+
2.列表进行元素插入和删除，尽量在列表尾部操作

使用zip()并行迭代
可以通过zip()函数对多个序列进行并行迭代，zip()函数在最短序列“用完”时就会停止
测试zip并行迭代：

# 测试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]))

推导式创建序列
推导式是从一个或者多个迭代器快速创建序列的一种方法。它可以将循环和条件判断结合，从而避免冗长的代码。

#测试推导式

#列表推导式
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)

cells = [(row,col) for  row in range(1,10) for col in range(1,10)]
print(cells)

#字典推导式
my_text = "i love you, i love sxt, i love gaoqi"
char_count = { c:my_text.count(c) for c in my_text}
print(char_count)



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


#生成器推导式（生成元组）
gnt = (x for x in range(4))
#print(tuple(gnt))

for x in gnt:   #gnt是生成器对象，生成器是可迭代的对象，只能使用一次
    print(x,end=",")
print(tuple(gnt))

练习:绘制不同颜色的同心圆

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

棋盘的画法：

#画棋盘
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(100)#控制速度
# 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()   #保证运行窗口不被自动关闭

函数的用法和底层分析

函数是可重用的程序代码块，函数的作用，不仅可以实现代码的复用，更能实现代码的一致性。一致性指的是，只要修改函数的代码，则所有调用该函数的地方都能得到体现。

在编写函数时，函数体现中的代码写法和之前的一致，只是对代码实现了封装，并增加了函数调用、传递参数、返回计算结果等内容。

函数简介

函数的基本概念：
1.一个程序由一个个任务组成，函数就是代表一个任务或者一个功能。
2.函数是代码复用的通用机制。

python函数的分类：

1.内置函数
前面的str() list() len()等都是内置函数
2.标准库函数
可以通过import语句导入库，然后使用其中定义的函数
3.第三方库函数
python社区也提供了大量的库。下载安装后，通过import语句导入，然后可以使用这些第三方库的函数
4.用户自定义的函数，开发中适应用户自身需求定义的函数。

自定义函数，函数的定义和调用

核心要点：
python中，定义函数的语法如下：
def 函数名（[参数列表]）：
‘’‘文档字符串’’’
函数体/若干语句

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

def  test01():
    print("*"*10)
    print("@"*10)


print(id(test01))
print(type(test01))
print(test01)

test01()
test01()
test01()#反复调用

for i in range(10):
    test01()

形参和实参

#测试形参、实参的基本用法

def printMax(a,b):
    '''用于比较两个数的大小，打印较大的值'''

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

printMax(10,20)
printMax(200,300)
help(printMax.__doc__)

形参用于定义时，实参用于调用时

文档字符串（函数的注释）

程序的可读性很重要，一般建议在函数体开始的部分上附上函数定义说明，就是文档字符串，也称为函数的注释。我们通过三个单引号三个双引号来实现，中间可以加入多行文字进行说明。

def print_star(n):
    '''根据传入的n，打印多个星号'''
    print("*"*n)
help(print_star)

调用help(函数名.doc)可以打印输出函数的文档字符串。

函数返回值

#测试返回值的基本用法

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

def test02():
    print("sxt")
    print("gao")
    return      #return,两个作用。返回值和结束函数命令
    print("1")
c = add(30,40)
print(add(30,40)*10)
test02()