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

Posted 2020-09-21

协程函数（yield）

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

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

 1 yield的语句形式： yield 1
 2 #yield的表达式形式： x=yield
 3 
 4 
 5 
 6 #协程函数
 7 
 8 def deco(func):
 9     def wrapper(*args,**kwargs):
10         res=func(*args,**kwargs)
11         next(res)
12         return res
13     return wrapper
14 
15 @deco
16 def eater(name):
17     print(‘%s ready to eat‘ %name)
18     food_list=[]
19     while True:
20         food=yield food_list
21         food_list.append(food)
22         print(‘%s start to eat %s‘ %(name,food))
23 
24 
25 g=eater(‘alex‘)
26 # print(g)
27 # next(g) #等同于 g.send(None)
28 
29 #
30 
31 # g.send(‘手指头‘)
32 # g.send(‘脚指头‘)
33 # g.send(‘别人的手指头‘)
34 # g.send(‘别人的脚指头‘)
35 
36 # print(g)
37 print(g.send(‘脚趾头1‘))
38 print(g.send(‘脚趾头2‘))
39 print(g.send(‘脚趾头3‘))
40 
41 
42 
43 
44 #x=yield
45 #g.send(‘1111‘),先把1111传给yield，由yield赋值给x
46 # 然后再往下执行，直到再次碰到yield，然后把yield后的返回值返回

协程函数示例

 

表达式形式的yield的用途：

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

 

 

 1 #grep -rl ‘python‘ /root
 2 
 3 
 4 import os
 5 
 6 def init(func):
 7     def wrapper(*args,**kwargs):
 8         res=func(*args,**kwargs)
 9         next(res)
10         return res
11     return wrapper
12 
13 @init
14 def search(target):
15     while True:
16         search_path=yield
17         g=os.walk(search_path)
18         for par_dir,_,files in g:
19             for file in files:
20                 file_abs_path=r‘%s\%s‘ %(par_dir,file)
21                 # print(file_abs_path)
22                 target.send(file_abs_path)
23 
24 @init
25 def opener(target):
26     while True:
27         file_abs_path=yield
28         # print(‘opener func==>‘,file_abs_path)
29         with open(file_abs_path,encoding=‘utf-8‘) as f:
30             target.send((file_abs_path,f))
31 
32 @init
33 def cat(target):
34     while True:
35         file_abs_path,f=yield  #(file_abs_path,f)
36         for line in f:
37             tag=target.send((file_abs_path,line))
38             if tag:
39                 break
40 @init
41 def grep(target,pattern):
42     tag=False
43     while True:
44         file_abs_path,line=yield tag
45         tag=False
46         if pattern in line:
47             tag=True
48             target.send(file_abs_path)
49 
50 @init
51 def printer():
52     while True:
53         file_abs_path=yield
54         print(file_abs_path)
55 
56 
57 
58 x=r‘C:\Users\Administrator\PycharmProjects\python17期\day5\a‘
59 
60 
61 
62 g=search(opener(cat(grep(printer(),‘python‘))))
63 print(g)
64 
65 g.send(x)

表达式_grep -rl

匿名函数 lambda

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

示例：

有名函数：

def func (x,y):

　　return x+y

匿名函数

lanbda x,y:x+y

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

 1 #匿名函数
 2 # f=lambda x,y:x+y
 3 # print(f)
 4 #
 5 # print(f(1,2))
 6 #
 7 # lambda x,y:x+y
 8 
 9 
10 #max,min,zip,sorted的用法
11 salaries={
12 ‘egon‘:3000,
13 ‘alex‘:100000000,
14 ‘wupeiqi‘:10000,
15 ‘yuanhao‘:2000
16 }
17 
18 # print(max(salaries))
19 # res=zip(salaries.values(),salaries.keys())
20 #
21 # # print(list(res))
22 # print(max(res))
23 
24 # def func(k):
25 #     return salaries[k]
26 
27 # print(max(salaries,key=func))
28 # print(max(salaries,key=lambda k:salaries[k]))
29 # print(min(salaries,key=lambda k:salaries[k]))
30 
31 # print(sorted(salaries)) #默认的排序结果是从小到到
32 # print(sorted(salaries,key=lambda x:salaries[x])) #默认的排序结果是从小到到
33 # print(sorted(salaries,key=lambda x:salaries[x],reverse=True)) #默认的排序结果是从小到到
34 #
35 
36 
37 
38 
39 # x=1000
40 # def f1():
41 #     # global x
42 #     x=0
43 #
44 # f1()
45 # print(x)
46 
47 
48 
49 
50 ‘‘‘
51 4. 内置函数
52     map
53     reduce
54     filter
55 ‘‘‘
56 
57 
58 # def func(f):
59 #     return f
60 #
61 # res=func(max)
62 # print(res)
63 
64 
65 # l=[‘alex‘,‘wupeiqi‘,‘yuanhao‘]
66 #
67 #
68 # res=map(lambda x:x+‘_SB‘,l)
69 #
70 # print(res)
71 #
72 # print(list(res))
73 #
74 # nums=(2,4,9,10)
75 #
76 # res1=map(lambda x:x**2,nums)
77 #
78 # print(list(res1))
79 
80 # from functools import reduce
81 #
82 # l=[1,2,3,4,5]
83 # print(reduce(lambda x,y:x+y,l,10))
84 
85 
86 # l=[‘alex_SB‘,‘wupeiqi_SB‘,‘yuanhao_SB‘,‘egon‘]
87 #
88 # res=filter(lambda x:x.endswith(‘SB‘),l)
89 # print(res)
90 # print(list(res))

匿名函数使用场景

递归调用函数

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

递归函数示例：

　　

1 # def age(n):
2 #     if n == 1:
3 #         return 18
4 #     return age(n-1)+2
5 #
6 # 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产生的名称空间中名字


优缺点：

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