python3-基础7

协程函数

面向过程编程

递归与二分法

内置函数   lambda

模块与包的使用

import

from ... import ...

常用模块

##################################

函数中只要有yield ， 函数执行的结果就变成了一个生成器

他并不会马上执行

生成器本身就是一个迭代器，使用next() 触发函数的执行

yield功能

1、把函数的执行结果封装好__iter__和__next__，得到一个迭代器

2、与return功能类似，都可以返回值，但不同的是，return只能返回一次值，而yield可以返回多次值

3、函数暂停与再继续运行的状态是有yield保存

 #
 def func(count):
     print('start')
     while True:
         yield count
         count+=1

 g=func(10)
 # print(g)
 print(next(g))

 print(next(g))

yield的表达式形式的应用

吃饭的过程，三种方法：

 #yield的表达式形式的应用
 #吃饭的过程
 ##方法一：
 def eater(name):
     print('%s 说：我要开始吃东西啦！' %name)
     food_list = [] #定义一个菜单空列表
     while True:
 #         food=yield   #yield 没有返回值，后面需要给yield赋值，只要函数中有yield关键字，函数执行的结果就是一个生成器
         food=yield food_list #返回值 菜单列表
         food_list.append(food)  #往列表中添加值
         print('%s eat %s ！' %(name,food))

 alex_g=eater('alex') #函数要执行下，才能得到一个生成器
 # print(alex_g)  #是个生成器 <generator object eater at 0x0000000006B522B0>

 # print(next(alex_g))   #执行结果  None
 # print('==============>')
 # print(next(alex_g))   #执行结果 alex eat None  ， food没有接收到值 ，所以每次都要给food传一个值，通过yield取值赋值给food
 # print('==============>')
 # print(next(alex_g))
 #第一阶段 初始化  next()  生成器刚开始的时候，必须给一个None值
 next(alex_g)  #保证在初始的位置，简单的触发生成器的执行，保证函数停在yield位置  等同于 alex_g.send(None)
 print('==========>')

 #第二阶段 给yield传值  通过alex_g.send() 发送值
 alex_g.send('包子')  #发送值  先给当前暂停位置的yield传值 ， 执行结果为：  alex eat 包子
 #继续往下执行，直到再次碰到yield，然后暂停，并且把yield后的返回值当做本次调用的返回值
 # alex_g.send('八宝粥')  #发送值
 print(alex_g.send('八宝粥'))
 print(alex_g.send('煎饺'))

 ##方法二：
 ##修改第二阶段

 def eater(name):
     print('%s 说：我要开始吃东西啦！' %name)
     food_list = [] #定义一个菜单空列表
     while True:
         food=yield food_list #返回值 菜单列表
         food_list.append(food)  #往列表中添加值
         print('%s eat %s ！' %(name,food))

 alex_g=eater('alex') #函数要执行下，才能得到一个生成器

 next(alex_g)
 print('==========>')

 ##第二阶段传值的功能写成一个交互函数

 def producer():
     alex_g=eater('alex')
     #第一阶段：初始化
     next(alex_g)
     #第二阶段：给yield传值
     while True:
         food=input('>>: ').strip()
         if not food:continue
         print(alex_g.send(food))

 producer()
 ##############################

 ##方法三：

 #不容易记得初始化
 #用装饰器解决初始化问题
 ####装饰器基本形式
 '''
 def init(func):
     def wrapper(*args, **kwargs):
         pass
     return wrapper
 '''
 ##先写个什么都没干的装饰器
 '''
 def init(func):
     def wrapper(*args, **kwargs):
         g = func(*args, **kwargs)
         return g
     return wrapper
 '''
 #完成调用初始化工作
 def init(func):
     def wrapper(*args, **kwargs):
         g = func(*args, **kwargs)
         next(g) #调用next()初始化
         return g
     return wrapper
 @init   #将装饰器加在目录函数上
 def eater(name):
     print('%s 说：我要开始吃东西啦！' %name)
     food_list = [] #定义一个菜单空列表
     while True:
 #         food=yield   #yield 没有返回值，后面需要给yield赋值，只要函数中有yield关键字，函数执行的结果就是一个生成器
         food=yield food_list #返回值 菜单列表
         food_list.append(food)  #往列表中添加值
         print('%s eat %s ！' %(name,food))

 alex_g=eater('alex')
 alex_g.send('包子')
 print(alex_g.send('八宝粥'))
 print(alex_g.send('煎饺'))

 面向过程

面向过程：核心是过程二字，明确的区分几个阶段，

基于面向过程去设计程序就像是在设计一条工业流水线，是一种机械式的思维方式

过程即解决问题的步骤
写程序要先设计

优点：程序结构清晰，可以把负责的问题简单化，流程化

缺点：可扩展性差，一条流水线只是用来解决一个问题

应用场景：Linux内核， Git， httpd， shell脚本

 ##遍历目录下的所有文件
 #三种方式
 #一、普通方式：
 import os   #导入os模块,os下面有个walk模块，他是个生成器
 import time

 #第一阶段：找到所有文件的绝对路径
 #使用os.walk()的方法，将walk生成的元组里的元素拼接成绝对路径
 def search(filepath):
     g=os.walk(filepath)
     for pardir,_,files in g:
         for file in files:
             abspath = r'%s\%s' %(pardir,file)
             print(abspath)
 fp = input('请输入目录绝对路径：')
 search(r'%s'  % (fp))
 time.sleep(10)

 ##二、装饰器方式，手动初始化装饰器
 import os   #导入os模块,os下面有个walk模块，他是个生成器
 import time

 #第一阶段：找到所有文件的绝对路径
 #使用os.walk()的方法，将walk生成的元组里的元素拼接成绝对路径
 def search():
     while True:
         filepath = yield
         g=os.walk(filepath)
         for pardir,_,files in g:
             for file in files:
                 abspath = r'%s\%s' %(pardir,file)
                 print(abspath)

 fp = input('请输入目录绝对路径：')
 g = search()  #使用装饰器，要先初始化
 next(g) #初始化

 g.send(r'%s'  % (fp))
 time.sleep(10)

 ##三、自动初始化装饰器
 import os   #导入os模块,os下面有个walk模块，他是个生成器
 import time

 def init(func):   #解决初始化问题
     def wrapper(*args,**kwargs):
         g=func(*args,**kwargs)
         next(g)
         return g
     return wrapper
 @init
 #第一阶段：找到所有文件的绝对路径
 #使用os.walk()的方法，将walk生成的元组里的元素拼接成绝对路径
 def search():
     while True:
         filepath = yield
         g=os.walk(filepath)
         for pardir,_,files in g:
             for file in files:
                 abspath = r'%s\%s' %(pardir,file)
                 print(abspath)
 # g = search('Null')
 # next(g)
 fp = input('请输入目录绝对路径：')            

 g = search()  #使用装饰器，要先初始化
 # next(g) #初始化
 g.send(r'%s'  % (fp))
 time.sleep(10)

 #面向过程：核心是过程二字
 #过程即解决问题的步骤
 #写程序要先设计

 #grep -rl 'error' /dir/
 #-r是递归着找，-l 是系列出文件名 ，找出目录下的所有文件，打开文件，找出有 error 的关键字，列出包含error的行的文件名
 #思路：找出所有文件的绝对路径、打开文件、循环逐行读取每行文件内容、判断error是否在文件里（过滤)、打印改行属于的文件名
 import os   #导入os模块,os下面有个walk模块，他是个生成器
 def init(func):  #写一个装饰器,完成调用初始化工作
     def wrapper(*args,**kwargs):
         g=func(*args,**kwargs)
         next(g)
         return g
     return wrapper

 #第一阶段：找到所有文件的绝对路径
 #使用os.walk()的方法，将walk生成的元组里的元素拼接成绝对路径
 def search(filepath):
     g=os.walk(filepath)
     for parddir,_,file in g:
         for file in files:
             abspath = r'%S\%s' %(pardir,file)
             print(abspath)
 search(r'F:\study\18期')
 @init
 def search(target):   #定义一个找路径的功能
     while True:
         filepath=yield
         g=os.walk(filepath)  #生成器，使用next（）方法，可以读取该文件的路径、目录、文件名，并将其为元素组成一个元组。
         for pardir,_,files in g:
             for file in files:
                 abspath=r'%s\%s' %(pardir,file)
                 target.send(abspath)
 # search(r'C:\Users\Administrator\PycharmProjects\python123\day5\aaa')
 # g=search()
 # g.send(r'C:\Python27')

 #第二阶段：打开文件
 @init
 def opener(target):
     while True:
         abspath=yield
         with open(abspath,'rb') as f:
             target.send((abspath,f))

 #第三阶段：循环读出每一行内容
 @init
 def cat(target):
     while True:
         abspath,f=yield #(abspath,f)
         for line in f:
             res=target.send((abspath,line))
             if res:break

 #第四阶段：过滤
 @init
 def grep(pattern,target):
     tag=False
     while True:
         abspath,line=yield tag
         tag=False
         if pattern in line:
             target.send(abspath)
             tag=True

 #第五阶段：打印该行属于的文件名
 @init
 def printer():
     while True:
         abspath=yield
         print(abspath)

 g = search(opener(cat(grep('os'.encode('utf-8'), printer()))))
 # g.send(r'C:\Users\Administrator\PycharmProjects\python123\day5\aaa')

 g.send(r'C:\Users\Administrator\PycharmProjects\python234')
 #a1.txt,a2.txt,b1.txt

#递归
'''
递归调用：再调用一个函数的过程中，直接或间接的调用了函数本身
python中递归的效率不高
记录下一次递归，保留上一次递归的状态，python对递归层级做了限制，默认1000层
程序中必须有个明确的结束条件

 直接调用：
 #直接
 # def func():
 # print('from func')
 # func()
 #
 # func() #直接

 #间接
 # def foo():
 # print('from foo')
 # bar()
 #
 # def bar():
 # print('from bar')
 # foo()
 #
 # foo() #间接调用

迭代 每一次更新都是上一次更新的结果
递归 直接或间接的调用了函数本身

递归包含两个阶段
递推：一层层的往下
回溯：一层层的回溯

什么时候用递归：
递归就是个循环的过程，递归可以做的，循环可以也可以做，只是麻烦点
循环是要明确的知道循环多少次
递归不需要

 #取出列表中的所有元素
 #若果使用循环，没法判断循环多少次，这里用递归来取值

 list1 =[1, 2, [3, [4, 5, 6, [7, 8, [9, 10, [11, 12, 13, [14, 15,[16,[17,]],19]]]]]]] #有很多层

 def search(l): #定义功能,给一个l参数
 for i in l: #循环列表l中的元素
 if type(i) is list: #判断如果元素是个列表
 search(i) #重复该功能，继续查找元素
 else:
 print(i) #打印该元素

 search(list1) #调用该功能
 #

二分法

##二分法（把一组元素一半一半的一直分下去）
#在下列列表中，搜索某个值是否存在，若存在请提示"find it!"  ，  除了in，如何遍历,使用二分法遍历
#若搜索的是不存在的，则返回“no exist!”

l = [1,2,5,7,10,31,44,47,56,99,102,130,240,332,346.480,520,527,572,666,668,888,999]  #从小到大排列（假设列表有很多值）, 

def binary_search(l,num):
    print(l) #[10, 31]
    if len(l) > 1:
        mid_index=len(l)//2 #1   #把列表切一半
        if num > l[mid_index]:  #和中间的值比较，如果比中间值大，则要去右边找，就要切分
            #in the right
            l=l[mid_index:] #l=[31]
            binary_search(l,num)
        elif num < l[mid_index]:
            #in the left
            l=l[:mid_index]
            binary_search(l,num)
        else:
            print('find it')
    else:
        if l[0] == num:
            print('find it')
        else:
            print('not exist!')
        return

binary_search(l,888)

####结果
[1, 2, 5, 7, 10, 31, 44, 47, 56, 99, 102, 130, 240, 332, 346.48, 520, 527, 572, 666, 668, 888, 999]
[1, 2, 5, 7, 10, 31, 44, 47, 56, 99, 102]
[1, 2, 5, 7, 10]
[5, 7, 10]
[7, 10]
[7]
not exist!