python_递归_协程函数（yield关键字）_匿名函数_模块

协程函数（yield）

协程函数：生成器：yield关键字的另一种用法

例：装饰器自动初始化函数（生成器函数）deco

yield的语句形式： yield 1
#yield的表达式形式： x=yield



#协程函数

def deco(func):
    def wrapper(*args,**kwargs):
        res=func(*args,**kwargs)
        next(res)
        return res
    return wrapper

@deco
def eater(name):
    print('%s ready to eat' %name)
    food_list=[]
    while True:
        food=yield food_list
        food_list.append(food)
        print('%s start to eat %s' %(name,food))


g=eater('alex')
# print(g)
# next(g) #等同于 g.send(None)

#

# g.send('手指头')
# g.send('脚指头')
# g.send('别人的手指头')
# g.send('别人的脚指头')

# print(g)
print(g.send('脚趾头1'))
print(g.send('脚趾头2'))
print(g.send('脚趾头3'))




#x=yield
#g.send('1111'),先把1111传给yield，由yield赋值给x
# 然后再往下执行，直到再次碰到yield，然后把yield后的返回值返回

表达式形式的yield的用途：

示例：模仿grep -rl <dir>；递归过滤文件和文件内容；os.walk(r;原生字符串，python解释器跳过解释;<dir>)

#grep -rl 'python' /root


import os

def init(func):
    def wrapper(*args,**kwargs):
        res=func(*args,**kwargs)
        next(res)
        return res
    return wrapper

@init
def search(target):
    while True:
        search_path=yield
        g=os.walk(search_path)
        for par_dir,_,files in g:
            for file in files:
                file_abs_path=r'%s\%s' %(par_dir,file)
                # print(file_abs_path)
                target.send(file_abs_path)

@init
def opener(target):
    while True:
        file_abs_path=yield
        # print('opener func==>',file_abs_path)
        with open(file_abs_path,encoding='utf-8') as f:
            target.send((file_abs_path,f))

@init
def cat(target):
    while True:
        file_abs_path,f=yield  #(file_abs_path,f)
        for line in f:
            tag=target.send((file_abs_path,line))
            if tag:
                break
@init
def grep(target,pattern):
    tag=False
    while True:
        file_abs_path,line=yield tag
        tag=False
        if pattern in line:
            tag=True
            target.send(file_abs_path)

@init
def printer():
    while True:
        file_abs_path=yield
        print(file_abs_path)



x=r'C:UsersAdministratorPycharmProjectspython17期day5a'



g=search(opener(cat(grep(printer(),'python'))))
print(g)

g.send(x)

匿名函数 lambda

匿名函数：与函数有相同的作用域，但是匿名意味着引用计数为0，使用一次就释放，除非让其有名字

示例：

有名函数：

def func (x,y):

　　return x+y

匿名函数

lanbda x,y:x+y

匿名函数常用场景：max，min，sorted,map,reduce,filter

#匿名函数
# f=lambda x,y:x+y
# print(f)
#
# print(f(1,2))
#
# lambda x,y:x+y


#max,min,zip,sorted的用法
salaries={
'egon':3000,
'alex':100000000,
'wupeiqi':10000,
'yuanhao':2000
}

# print(max(salaries))
# res=zip(salaries.values(),salaries.keys())
#
# # print(list(res))
# print(max(res))

# def func(k):
#     return salaries[k]

# print(max(salaries,key=func))
# print(max(salaries,key=lambda k:salaries[k]))
# print(min(salaries,key=lambda k:salaries[k]))

# print(sorted(salaries)) #默认的排序结果是从小到到
# print(sorted(salaries,key=lambda x:salaries[x])) #默认的排序结果是从小到到
# print(sorted(salaries,key=lambda x:salaries[x],reverse=True)) #默认的排序结果是从小到到
#




# x=1000
# def f1():
#     # global x
#     x=0
#
# f1()
# print(x)




'''
4. 内置函数
    map
    reduce
    filter
'''


# def func(f):
#     return f
#
# res=func(max)
# print(res)


# l=['alex','wupeiqi','yuanhao']
#
#
# res=map(lambda x:x+'_SB',l)
#
# print(res)
#
# print(list(res))
#
# nums=(2,4,9,10)
#
# res1=map(lambda x:x**2,nums)
#
# print(list(res1))

# from functools import reduce
#
# l=[1,2,3,4,5]
# print(reduce(lambda x,y:x+y,l,10))


# l=['alex_SB','wupeiqi_SB','yuanhao_SB','egon']
#
# res=filter(lambda x:x.endswith('SB'),l)
# print(res)
# print(list(res))

递归调用函数

递归：在函数调用过程中，直接或间接的调用了函数本身，这就是函数的递归调用

递归函数示例：

　　

# def age(n):
#     if n == 1:
#         return 18
#     return age(n-1)+2
#
# print(age(5))

二分法：

示例：

l = [1, 2, 10,33,53,71,73,75,77,85,101,201,202,999,11111]

def search(find_num,seq):
    if len(seq) == 0:
        print('not exists')
        return
    mid_index=len(seq)//2
    mid_num=seq[mid_index]
    print(seq,mid_num)
    if find_num > mid_num:
        #in the right
        seq=seq[mid_index+1:]
        search(find_num,seq)
    elif find_num < mid_num:
        #in the left
        seq=seq[:mid_index]
        search(find_num,seq)
    else:
        print('find it')

　　

模块

模块：一个模块就是一个包含了python定义和声明的文件，文件名就是模块名字加上.py的后缀

为什么使用模块：

如果你退出python解释器然后重新进入，那么你之前定义的函数或者变量都将丢失，因此我们通常将程序写到文件中以便永久保存下来，需要时就通过python test.py方式去执行，此时test.py被称为脚本script。

    随着程序的发展，功能越来越多，为了方便管理，我们通常将程序分成一个个的文件，这样做程序的结构更清晰，方便管理。这时我们不仅仅可以把这些文件当做脚本去执行，还可以把他们当做模块来导入到其他的模块中，实现了功能的重复利用，

使用模块：import ； from xx import xx,xxx,xx *

import导入模块干的事：
'''
1.产生新的名称空间
2.以新建的名称空间为全局名称空间，执行文件的代码
3.拿到一个模块名spam，指向spam.py产生的名称空间

from xx import xx ,*

1.产生新的名称空间
2.以新建的名称空间为全局名称空间，执行文件的代码
3.直接拿到就是spam.py产生的名称空间中名字


优缺点：

优点:方便，不用加前缀
缺点：容易跟当前文件的名称空间冲突