一、解釋

面向過程：核心是過程二字，過程即解決問題的步驟，基於面向過程去設計程序就像是在設計，流水線式的編程思想，在設計程序時，需要把整個流程設計出來， 一條工業流水線，是一種機械式的思維方式

二、優缺點

優點：程序體系結構清晰，可以把復雜的問題簡單化，流程化

缺點：可擴展性差，一條流線只是用來解決一個問題，所以說面向過程的應用多為不需要經常變化的軟件

應用場景：linux內核，git，httpd，shell腳本

三、實例（利用協程函數進行面向過程編程）

過濾一個文件下的子文件、字文件夾的內容中的相應的內容，在Linux中的命令就是 grep -rl ‘python‘ /etc

使用了Python的包os 裏面的walk(),能夠把參數中的路徑下的文件夾打開並返回一個元組

>>> import os
>>> os.walk(‘D:\test‘)        
generator object walk at 0x0000000002ADB3B8

>>> os.walk(‘D:\\test‘)        # 以後使用這種路徑方式，win下
>>> os.walk(r‘D:\test‘)       # 使用r 是讓字符串中的符號沒有特殊意義，針對的是轉義

出現錯誤，是因為路徑的原因，但是在不同的機器上有的是可以的

>>> g=os.walk(‘D:\test‘)
>>> next(g)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
StopIteration

以後推薦是用\

>>> g=os.walk(‘D:\\test‘)
>>> next(g)
(‘D:\\test‘, [‘a‘, ‘b‘], [‘test.txt‘])

返回的是一個元組，第一個元素是文件的路徑，第二個

1.2.1 程序流程

1. 找文件路徑 --os.walk
2. 然後打開文件 --open
3. 讀取文件的每一行內容 -- for line in f
4. 過濾一行內容中是否有Python if ‘python‘ in line
5. 打印包含Python的文件路徑

程序是從上往下執行的，1產生的路徑作為參數給2,2產生的給3...

上面產生的結果是下面的輸入參數

1 找文件的路徑

g是一個生成器，就能夠用next()執行，每次next就是運行一次，這裏的運行結果是依次打開文件的路徑

>>> g=os.walk(‘D:\\test‘)
>>> next(g)
(‘D:\\test‘, [‘a‘, ‘b‘], [‘test.txt‘])
>>> next(g)
(‘D:\\test\\a‘, [‘a1‘], [‘a.txt‘])
>>> next(g)
(‘D:\\test\\a\\a1‘, [], [‘a1.txt‘])
>>> next(g)
(‘D:\\test\\b‘, [‘b1‘], [‘b.txt‘])
>>> next(g)
(‘D:\\test\\b\\b1‘, [], [‘b1.txt‘])

我們在打開文件的時候需要找到文件的絕對路徑，現在可以通過字符串拼接的方法把第一部分和第三部分進行拼接

用循環打開：

import os
# def serach():
g = os.walk(‘D:\\test‘)
for i in g:
    print(i)
結果：
(‘D:\test‘, [‘a‘, ‘b‘], [‘test.txt‘])
(‘D:\test\a‘, [‘a1‘], [‘a.txt‘])
(‘D:\test\a\a1‘, [], [‘a1.txt‘])
(‘D:\test\b‘, [‘b1‘], [‘b.txt‘])
(‘D:\test\b\b1‘, [], [‘b1.txt‘])

將查詢出來的文件和路徑進行拼接，拼接成絕對路徑

import os
# def serach():
g = os.walk(‘D:\\test‘)
for i in g:
    # print(i)
    for j in i[-1]: # 對最後一個元素進行遍歷，這些都是文件
        file_path= ‘%s\\%s‘ %(i[0],j)
        print(file_path)
結果：
D:\test\test.txt
D:\test\a\a.txt
D:\test\a\a1\a1.txt
D:\test\b\b.txt
D:\test\b\b1\b1.txt

這樣就把文件的所有的絕對路徑找出來了

用函數實現:

def search():
    while True:
        file_name = yield   # 通過white循環能夠循環接收
        g = os.walk(file_name)   # 這裏就換成了參數
        for i in g:
            for j in i[-1]: # 對最後一個元素進行遍歷，這些都是文件
                file_path= ‘%s\\%s‘ %(i[0],j)
                print(file_path)

g=search()  #　ｇ就是生成器函數
next(g)   # 初始化
g.send(‘D:\\test‘) # 通過send傳遞的是路徑

2 然後打開文件

寫程序中，在這裏遇到的問題是 with open(file_path) as f: AttributeError: enter，不明白是為什麽，然後想到open可能是系統已經用了的，所以修改名字後執行成功。

@init   # 初始化生成器
def opener(target):
    "打開文件，操作句柄"
    while True:
        file_path=yield  #　 接收search傳遞的路徑
        with open(file_path) as f:
            target.send((file_path,f)) # send多個用元組的方式，為了把文件的路徑傳遞下去

3 讀取文件的每一行內容

@init
def cat(target):
    while True:
        file_path,f=yield
        for line in f:
            target.send((file_path,line)) # 同時傳遞文件路徑和每一行的內容

4 過濾一行內容中是否有

@init
def grep(pattern,target):  # patter是過濾的參數
    while True:
        file_path,line=yield
        if pattern in line:
            target.send(file_path)   #　傳遞有相應內容的文件路徑

5 打印包含Python的文件路徑

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

上面的是函數的定義階段，下面是函數的執行階段：

g=search(opener(cat(grep(‘python‘,printer()))))
g.send(‘D:\\test‘)

target這個生成器：
opener(cat(grep(‘python‘,printer())))

Python函數之面向過程編程