递归

建议先去看看Python如何实现栈

概念
所谓递归,就是在函数内部,去调用自己

def recoder(n):
    print(f"这是第{n}次调用")
    if n <= 1:
        return None # 结束递归
    else:
        n -= 1
        recoder(n)


if __name__ == '__main__':
    recoder(10)

这就是一个递归函数。

需求
遍历目录：输出文件夹下的所有文件的绝对路径

代码演示

def print_all_files(file_path):
    """
    思路：获得file_path下的所有文件及文件夹  os.scandir(file_path)  os.listdir(file_path)
    如果是文件，直接输出
    如果是文件夹，递归调用print_all_files（文件夹）
    """
    for item in os.scandir(file_path):
        # item是文件或者文件夹
        if item.is_file():
            print(item.path)
        elif item.is_dir():
            print_all_files(item.path) # 有多少文件夹就调用多少次


if __name__ == '__main__':
    p = "E:/平台开发学习"
    print_all_files(p)

回调函数

概念
如果一个函数的参数是函数类型，那么我们就可以把这个参数叫做回调函数

需求
比较两个数的大小，并用不同风格输出 例如

  • compare 1 and 2 ,min = 1
  • 1和2比较，最小的是1

代码演示

def get_min(a, b, func):
    """
    :param a:数字1 回传给func
    :param b:数字2 回传给func
    :param func:回调函数 传来的func
    :return: 
    """
    result = a if a < b else b
    func(a, b, result)


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


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


if __name__ == '__main__':
    get_min(1, 2, call_back_print_en)
    get_min(3, 8, call_back_print_cn)

总结
函数中调用函数：

  • 如果调用的是自身，叫递归
  • 如果调用的是别的函数，叫普通调用
  • 如果借用参数调用的别的函数，叫做回调

回调函数中的参数，至少有一个是在函数中的参数，例如代码中的a，b

闭包

概念
闭包也是一个函数
他是把一个函数“包”起，把里面的函数封闭在外面的函数

需求
不运行函数，检测任意函数的参数

代码演示

def f1(a, b):
    print("f1执行")


def f2(x, y):
    print("f2执行")


#  用闭包实现
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}")

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


f1_logger = logger(f1)
f2_logger = logger(f2)
f1_logger(1, 2)
f2_logger(10, 20)


# f1和f2都没有执行
#  一般情况，函数结束，函数里面的所有局部变量都会被销毁。
#  问：函数调用结束后，我怎么才能获得函数里面的局部变量
#  答：在函数里面再定义一个函数，把局部变量暴露给外部
def outer_function(n):
    num = n

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

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


my_func = outer_function(5)
my_func()
# 写一个方法，实现记录某个函数被调用的次数
# 闭包实现：某个函数当作内层函数，外部的函数加一个count记录内部函数被调用的次数
def outer():
    count = 0  # 用来记录inner调用的次数

    def some_function():
        nonlocal count
        count += 1
        print(count)

    return some_function


c = outer()
c()  # 1
c()  # 2
c()  # 3

总结

闭包可以将函数里的局部变量保存