递归 回调函数 闭包

 

一、递归实现获取某文件夹下的所有文件的绝对路径

import os

# 原始方法
def print_all_files(file_path):
    for root, dirs, files in os.walk(file_path):
        for filename in files:
            print(os.path.join(root, filename))

# 递归实现
def print_all_files2(file_path):
    """
    思路：获得file_path下的所有文件及文件夹    # os.scandir(file_path)  os.listdir(file_path)
    如果是文件，直接输出
    如果是文件夹，递归调用print_all_files2(文件夹)
    """
    for item in os.scandir(file_path):
        if item.is_file():
            print(item.path)  # 输出文件夹下的所有文件
        elif item.is_dir():
            print("~~~~~~")
            print_all_files2(item.path)  # 有多少个文件夹，print_all_files2函数就被调用多少次

if __name__ == '__main__':
    p = "C:/Users/10795/PycharmProjects/python_advance_programming"
    print_all_files2(p)

递归的特点

1. 必须有一个明确的结束条件，要不就会变成死循环了，最终撑爆系统
2. 每次进入更深一层递归时，问题规模相比上次递归都应有所减少

递归执行效率不高，递归层次过多会导致栈溢出

def zero(n):
    n = n // 2
    print(n)
    if n == 0:
        return 'Done'
    zero(n)
    print(n)  # 1 2 5


'''
第一层会n=5，第二层会n=2，第三层会n=1，第四层n=0,符合条件程序停止。停止之后，程序的控制权会回到第三层调用第四层的位置，也就是zero(n)，然后print出1，然后回到第二层print出2,最后回到第一层print出5。
整个程序是先一层层进去，然后在一层层出来。
'''
zero(10)  # 5 2 1 0 1 2 5

二、回调函数

函数： 用一块代码实现某个特定的功能
回调函数：如果一个函数的参数是函数类型，那么我们可以把这个参数叫做回调函数
函数中调用函数：
    1.如果调用的是自身，叫递归；
    2.如果调用的是别的函数，叫普通调用；
    3.如果借用参数调用的别的函数，叫回调；

def get_min(a, b, func):  # 来： 传来的函数func； 回：我把参数回传给你——func
    # func是回调函数的引用
    result = a if a < b else b
    func(a, b, result)  # 回调
    # f()  # 普通调用

# 回调函数一
def call_back_print_en(a, b, _min):
    print(f"compare {a} and {b},min={_min}")


# 回调函数二
def call_back_print_zh(a, b, _min):
    print(f"{a} 和 {b}比较,{_min}最小")


if __name__ == '__main__':
    get_min(1, 2, call_back_print_zh)

三、闭包

闭包也是一个函数，闭包返回的是函数的引用

import logging


def f1(a, b):
    print("hello")

def f2(x, y):
    pass

# 用闭包实现
def logger(func):
    def log_func(*args):
        logging.basicConfig(filename="demo.log", level=logging.INFO)
        logging.info(f"{func.__name__} is running, arguments is {args}")

    # 返回 log_func 不加括号  ,这里就是闭包
    return log_func  # 把log_func函数的引用 传给 logger的调用者


f1_logger = logger(f1)  # def f1(a,b):pass
f2_logger = logger(f2)  # def f2(x,y):pass
f1_logger(1, 2)
f2_logger(10, 20)

内函数对外函数的调用

一般情况，函数结束，函数里面所有的局部变量都会被销毁
函数调用结束后，怎么才能获得函数里面的局部变量：使用闭包（ 在函数里面再定义一个函数，把局部变量暴露给外部  ）

def outer_function(n):
    num = n

    def inner_function():
        # nonlocal 一般用在嵌套函数中
        nonlocal num  # global(全局) local(局部)  nonlocal(不在本局部，但不是全局)
        print("hello")
        num -= 1

    # 不加括号，返回inner_function()函数的函数名（即引用）
    return inner_function

my_func = outer_function(3)
my_func()

 

 

 

 

引用：https://www.cnblogs.com/lshedward/p/9959845.html