寫在前面

上課第四天，打卡：

　　　　如果再見不能紅著眼，是否還能紅著臉；

一、協程函數（生成器：yield的表達式形式）

　　1.yield 的語句形式： yield 1

　　2.yield 的表達式形式： x=yield

　　　　註意：next(g) #等同於 g.send(None)，示例如下：

 1 def deco(func):
 2     def wrapper(*args,**kwargs):
 3         res=func(*args,**kwargs)
 4         next(res)
 5         return
 
 res
 6     return wrapper
 7 
 8 @deco
 9 def eater(name):
10     print(‘%s ready to eat‘ %name)
11     food_list=[]
12     while True:
13         food=yield food_list
14         food_list.append(food)
15         print(‘%s start to eat %s‘ %(name,food))
16 
17 
18 g=eater(‘alex‘)
19 # print(g)
 

20 # next(g) #等同於 g.send(None)

 1 # yield表達式形式之練習一
 2 def deco(func):
 3     def wrapper(*args,**kwargs):
 4         res = func(*args,**kwargs)
 5         next(res)
 6         return res
 7     return wrapper
 8 
 9 @deco
10 def eater(name):
11     print(‘%s ready to eat‘ % name)
 
12     while True:
13         food=yield
14         print("%s start to eat %s" % (name, food))
15 g = eater(‘alex‘)
16 next(g)

 1 # yield表示器形式之練習二
 2 def deco(func):
 3     def wrapper(*args,**kwargs):
 4         res = func(*args,**kwargs)
 5         next(res)
 6         return res
 7     return wrapper
 8 
 9 @deco
10 def eater(name):
11     print(‘%s ready to eat‘ % name)
12     food_list = []
13     while True:
14         food=yield
15         food_list.append(food)
16         print("%s start to eat %s" % (name, food))
17         print("%s have eaten: %s" % (name,food_list))
18 g = eater(‘alex‘)
19 g.send(‘tomato‘)
20 g.send(‘potato‘)
21 g.send(‘beef‘)
22 g.send(‘rice‘)

　　3.yield表達式形式的應用

 1 #!/usr/bin/python
 2 # -*- coding:utf-8 -*-
 3 
 4 # 實現Linux下的如下命令： grep -rl ‘python‘ path
 5 # 即給出一個目錄和patten，遞歸遍歷查找該目錄下含有該patten的文件完整路徑，如果文件含有多行則需要去重；
 6 
 7 import os
 8 
 9 def init(func):
10     def wrapper(*args,**kwargs):
11         res = func(*args,**kwargs)
12         next(res)
13         return res
14     return wrapper
15 @init
16 def search_all_file(target):
17     while True:
18         path = yield
19         g = os.walk(path)
20         for path,_,files in g:
21             for file in files:
22                 target.send(r‘%s\%s‘ % (path,file))
23 @init
24 def opener(target):
25     while True:
26         file_to_open = yield
27         with open(file_to_open,encoding=‘utf-8‘) as rf:
28             for line in rf:
29                 res = target.send((file_to_open,line))
30                 if res:
31                     break
32 @init
33 def grep(patten):
34     flag = False
35     while True:
36         the_file,line = yield flag
37         flag = False
38         if patten in line:
39             flag = True
40             print(the_file)
41 
42 path = r‘D:\soft\work\Python_17\day05\a‘
43 g = search_all_file(opener(grep(‘python‘)))
44 print(g)
45 g.send(path)

二、遞歸調用

　　1.遞歸的概念

　　　　在函數調用過程中，直接或間接地調用了函數本身，這就是函數的遞歸調用；

　　　　包括兩部分：遞推和回溯；

1 def f1():
2      print(‘from f1‘)
3      f1()
4 
5 f1()

　　2.遞歸的層數限制

1 import sys
2 print(sys.getrecursionlimit())　　　　# 查看默認遞歸次數上限
3 sys.setrecursionlimit(2000)　　　　　　# 認為設置遞歸上限
4 print(sys.getrecursionlimit())
5 
6 ---
7 1000
8 2000

　　3.遞歸特性

　　　　1. 必須有一個明確的結束條件；

　　　　2. 每次進入更深一層遞歸時，問題規模相比上次遞歸都應有所減少；

　　　　3. 遞歸效率不高，遞歸層次過多會導致棧溢出（在計算機中，函數調用是通過棧（stack）這種數據結構實現的，每當進入一個函數調用，棧就會加一層棧幀；每當函數返回，棧就會減一層棧幀。由於棧的大小不是無限的，所以，遞歸調用的次數過多，會導致棧溢出）；

　　　　4.堆棧掃盲：http://www.cnblogs.com/lln7777/archive/2012/03/14/2396164.html

　　　　5.尾遞歸優化：http://egon09.blog.51cto.com/9161406/1842475

　　4.遞歸具體應用

　　　　1.二分法查找某個元素

　　　　　　前提：輸入的可循環對象必須是有序的；

 1 l = [1, 2, 10,33,53,71,73,75,77,85,101,201,202,999,11111]
 2 
 3 def search(find_num,seq):
 4     if len(seq) == 0:
 5         print(‘not exists‘)
 6         return
 7     mid_index=len(seq)//2
 8     mid_num=seq[mid_index]
 9     print(seq,mid_num)
10     if find_num > mid_num:
11         #in the right
12         seq=seq[mid_index+1:]
13         search(find_num,seq)
14     elif find_num < mid_num:
15         #in the left
16         seq=seq[:mid_index]
17         search(find_num,seq)
18     else:
19         print(‘find it‘)

　　　　2.DNS 的遞歸和叠代查找

待整理

　　　　3.Linux深水炸彈

待整理

三、內置函數補充

　　1.匿名函數lambda

　　2.max 和 min

　　3.sorted

　　4.zip

　　5.map

　　6.reduce

　　7.filter

　　8.global

 1 x=1000
 2 def f1():
 3     global x
 4     x=0
 5 
 6 f1()
 7 print(x)
 8 
 9 ---
10 0

四、面向過程編程與函數式編程

　　1.面向過程編程

　　　　1.概念：面向過程的程序設計：是一種流水線式的、機械式的過程；

　　　　2.優缺點

　　　　　　1.優點
　　　　　　　　程序結構清晰，復雜的問題分解成多個簡單的最小單元，每個單元完成各自的功能；
　　　　　　2.缺點
　　　　　　　　擴展性差，牽一發而動全身；
　　　　3.應用場景
　　　　　　Linux內核、git、httpd

　　2.函數式編程

　　　　1.函數式編程（不同於面向過程編程），是模擬數學意義上的函數；

　　　　2.特性
　　　　　　1.不允許對外部變量做任何修改
　　　　　　2.沒有循環的概念，所有的循環都是用 尾遞歸 實現的；
　　　　　　3.函數式編程語言 與 Python無關；
　　　　　　...

五、模塊的使用

　　1.import ... 導入

　　　　1.產生新的名稱空間;

　　　　2.以新建的名稱空間為全局名稱空間，執行文件的代碼;

　　　　3.拿到一個模塊名spam，指向spam.py產生的名稱空間;

　　2.from ... import ... 導入

　　　　1.產生新的名稱空間;

　　　　2.以新建的名稱空間為全局名稱空間，執行文件的代碼;

　　　　3.直接拿到就是spam.py產生的名稱空間中名字;

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

　　3.模塊搜索路徑

　　　　1.內存

　　　　2.內置

　　　　3.sys.path

 1 import spam ===>>  就是要找當前路徑下的 spam.py  這個文件
 2 
 3 
 4 如果在其他級別的路徑下，則需要把該路徑加入到 sys.path 
 5 
 6 import sys
 7 sys.path.append(r‘path‘)
 8 sys.path.insert(0,r‘path‘)
 9 
10 或者把相關的py文件移動到已有的sys.path某個路徑下

參考：http://www.cnblogs.com/linhaifeng/articles/6379069.html

六、包的使用

參考：http://www.cnblogs.com/linhaifeng/articles/6379069.html

七、正則相關

import re

參考：http://www.cnblogs.com/linhaifeng/articles/6384466.html#_label11

這部分需要都整理一遍

other

　　高階函數

　　第一類對象

作業：

1     函數+正則===》計算器
2 -1+(1+2*3-(-4/3)+10.3/2)

Python基礎(遞歸、模塊、包以及正則)-day05