協程函數（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後的返回值返回

表達式形式的

示例：模仿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)

匿名函數 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產生的名稱空間中名字


優缺點：

優點:方便，不用加前綴
缺點：容易跟當前文件的名稱空間沖突

python_遞歸_協程函數（yield關鍵字）_匿名函數_模塊