递归/面向过程编程

递归/面向过程编程

返回首页

　　面向过程的编程思想：就是机械化的流水线，下一步要紧接着上一步的结果，才能运行下去。在设计时，需要把整个流程

　　　　　　　　　　　　　　  设计出来。

　　面向过程的好处是：让程序简化复杂度，体系结构清晰。

　　面向过程的坏处是：针对性很强，耦合度很强，可扩展性很差。应用场景不易经常变化。

 　　面向对象的案例：

#grep -rl 'root' /etc

import os,time

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

@wrapper
def search(target):
    """
    找到文件的绝对路径
    target是生成器对象
    :return:
    """
    while True:
        dir_name = yield   #协程函数表达式，将路径传给dir_name
        print('车间search开始生产产品：文件路径')
        time.sleep(2)
        g = os.walk(dir_name)
        for i in g:
            for j in i[-1]:
                file_path = '%s\/%s' %(i[0],j)
                target.send(file_path)  #将路径传出去。找到一个发一个。
                # print(file_path)
@wrapper
def opener(target):
    """
    打开一个文件,获取文件的句柄。
    :return:
    """
    while True:
        file_path = yield  #接到路径
        print('车间opener开始生产产品：文件句柄')
        time.sleep(2)
        with open(file_path) as f:   #接到文件路径，打开文件
            target.send(f(file_path,f))  #send可以传多个值，但是要是元组的形式。
@wrapper
def cat(target):
    """
    读取文件内容
    :return:
    """
    while True:
        file_path,f = yield   #那到文件句柄，读文件
        print('车间cat开始生产产品：文件内容')
        time.sleep(2)
        for line in f:  #读文件。
            target.send((file_path,line))

@wrapper
def grep(pattern,target):
    """
    过滤一行内容里是否有关键字。
    :return:
    """
    while True:
        file_path,line = yield
        print('车间grep开始生产产品：文件关键字')
        time.sleep(2)
        if pattern in line:
            target.send(file_path)

@wrapper
def printer():
    """
    打印有关键字的文件路径
    :return:
    """
    while True:
        file_path = yield
        print('车间printer开始生产产品：文件路径了')
        time.sleep(2)
        print(file_path)

g = search(opener(cat(grep('python',printer()))))
# next(g)
g.send("/etc")

 

　　递归： 

　　  1、必须有一个明确的结束条件

　　  2、每次进入更深一层递归时，问题规模相比上次递归都应有所减少。

　　  3、递归效率不高，递归层次过多会导致栈溢出（在计算机中，函数调用时通过栈(stack)这种数据结构实现的，每当进入一个函数调用，栈就会加一层栈帧，每当函数返回，栈就会减一层栈帧。由于栈的大小不是无限的，所以，递归调用的次数过多，会导致栈溢出）

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

　　　代码逻辑：当age = 5时，得到age(5-1)+2的结果，以此循环执行return age(n-1)+2，得到的和就是初试n=10时，age(5) 的年龄。

 　　 

--------------- END --------------