Python基础——函数4（递归、高阶函数|闭包）

一、递归

引入：尝试求10的阶乘（10!）

• 1! = 1
• 2! = 1*2 = 2
• 3! = 123 = 6
• 4! = 123*4 = 24

法1：比较麻烦

print(1*2*3*4*5*6*7*8*9*10)

法2：并非通用方法

# 创建一个变量保存结果
n = 10
for i in range(1,10):
    n *= i
print(n)

法3：通用方法（函数）

# 创建一个函数，可以用来求任意数的阶乘
def factorial(n):
    '''
        该函数用来求任意数的阶乘

        参数：
            n 要求阶乘的数字
    '''

    # 创建一个变量，来保存结果
    result = n
    
    for i in range(1,n):
        result *= i

    return result    

# 求10的阶乘    
print(factorial(10))

递归式的函数

• 从前有座山，山里有座庙，庙里有个老和尚讲故事，讲的什么故事呢？从前有座山，山里有座庙，庙里有个老和尚讲故事，讲的什么故事呢？…
• 递归简单理解就是自己去引用自己！
• 递归式函数，在函数中自己调用自己！

# 无穷递归，如果这个函数被调用，程序的内存会溢出，效果类似于死循环
def fn():
    fn()
# fn()

• 递归是解决问题的一种方式，它和循环很像
• 它的整体思想是，将一个大问题分解为一个个的小问题，直到问题无法分解时，再去解决问题
• 递归式函数的两个要件
  • 1.基线条件
    • 问题可以被分解为的最小问题，当满足基线条件时，递归就不在执行了
  • 2.递归条件
    • 将问题继续分解的条件
• 递归和循环类似，基本是可以互相代替的，
• 循环编写起来比较容易，阅读起来稍难
• 递归编写起来难，但是方便阅读

# 10! = 10 * 9!
# 9! = 9 * 8!
# 8! = 8 * 7!
# ...
# 1! = 1

def factorial(n):
    '''
        该函数用来求任意数的阶乘

        参数：
            n 要求阶乘的数字
    '''
    # 基线条件 判断n是否为1，如果为1则此时不能再继续递归
    if n == 1 :
        # 1的阶乘就是1，直接返回1
        return 1

    # 递归条件    
    return n * factorial(n-1)

print(factorial(10))

练习1：创建一个函数 power 来为任意数字做幂运算 n ** i

# 练习
#   创建一个函数 power 来为任意数字做幂运算 n ** i
#   10 ** 5 = 10 * 10 ** 4
#   10 ** 4 = 10 * 10 ** 3
#   ...
#   10 ** 1 = 10
def power(n , i):
    '''
        power()用来为任意的数字做幂运算

        参数：
            n 要做幂运算的数字
            i 做幂运算的次数
    '''
    # 基线条件
    if i == 1:
        # 求1次幂
        return n
    # 递归条件
    return n * power(n , i-1)

print(power(10,5))    

练习2：创建一个函数，用来检查一个任意的字符串是否是回文字符串，如果是返回True，否则返回False

#   创建一个函数，用来检查一个任意的字符串是否是回文字符串，如果是返回True，否则返回False
#   回文字符串，字符串从前往后念和从后往前念是一样的
#       abcba
#   abcdefgfedcba
#   先检查第一个字符和最后一个字符是否一致，如果不一致则不是回文字符串
#       如果一致，则看剩余的部分是否是回文字符串
#   检查 abcdefgfedcba 是不是回文
#   检查 bcdefgfedcb 是不是回文
#   检查 cdefgfedc 是不是回文
#   检查 defgfed 是不是回文
#   检查 efgfe 是不是回文
#   检查 fgf 是不是回文
#   检查 g 是不是回文

def hui_wen(s):
    '''
        该函数用来检查指定的字符串是否回文字符串，如果是返回True，否则返回False

        参数：
            s：就是要检查的字符串
    '''
    # 基线条件
    if len(s) < 2 :
        # 字符串的长度小于2，则字符串一定是回文
        return True
    elif s[0] != s[-1]:
        # 第一个字符和最后一个字符不相等，不是回文字符串
        return False    
    # 递归条件    
    return hui_wen(s[1:-1])

print(hui_wen('abcdefgfedcba'))

• 优化函数

def hui_wen(s):
    '''
        该函数用来检查指定的字符串是否回文字符串，如果是返回True，否则返回False

        参数：
            s：就是要检查的字符串
    '''
    # 基线条件
    if len(s) < 2 :
        # 字符串的长度小于2，则字符串一定是回文
        return True
    # 递归条件    
    return s[0] == s[-1] and hui_wen(s[1:-1])

print(hui_wen('abcdefgfedcba'))

二、高阶函数

引入：函数式编程

• 在Python中，函数是一等对象
• 一等对象一般都会具有如下特点：
  • ① 对象是在运行时创建的
  • ② 能赋值给变量或作为数据结构中的元素
  • ③ 能作为参数传递
  • ④ 能作为返回值返回
• 高阶函数
  • 高阶函数至少要符合以下两个特点中的一个
    • ① 接收一个或多个函数作为参数
    • ② 将函数作为返回值返回
• 装饰器

高阶函数1

• 接收函数作为参数，或者将函数作为返回值的函数是高阶函数
• 当我们使用一个函数作为参数时，实际上是将指定的代码传递进了目标函数

实例1

• 定义一个函数
• 可以将指定列表中的所有的偶数，保存到一个新的列表中返回

# 创建一个列表
l = [1,2,3,4,5,6,7,8,9,10]

# 定义一个函数
#   可以将指定列表中的所有的偶数，保存到一个新的列表中返回

# 定义一个函数，用来检查一个任意的数字是否是偶数
def fn2(i) :
    if i % 2 == 0 :
        return True

    return False    

def fn(func , lst) :

    '''
        fn()函数可以将指定列表中的所有偶数获取出来，并保存到一个新列表中返回

        参数：
            lst：要进行筛选的列表
    '''
    # 创建一个新列表
    new_list = []

    # 对列表进行筛选
    for n in lst :
        # 判断n的奇偶
        if func(n) :
            new_list.append(n)
            
    # 返回新列表
    return new_list

print(fn(fn2, l))

实例2

• 定义一个函数
• 可以将指定列表中数字是大于5的数，保存到一个新的列表中返回

# 创建一个列表
l = [1,2,3,4,5,6,7,8,9,10]

# 这个函数用来检查指定的数字是否大于5
def fn3(i):
    if i > 5 :
        return True    
    return False

def fn(func , lst) :

    '''
        fn()函数可以将指定列表中的所有偶数获取出来，并保存到一个新列表中返回

        参数：
            lst：要进行筛选的列表
    '''
    # 创建一个新列表
    new_list = []

    # 对列表进行筛选
    for n in lst :
        # 判断是否大于5
        if func(n) :
            new_list.append(n)
            
    # 返回新列表
    return new_list

print(fn(fn3, l))

高阶函数2

• 将函数作为返回值返回，也是一种高阶函数
• 这种高阶函数我们也称为叫做闭包，通过闭包可以创建一些只有当前函数能访问的变量
• 可以将一些私有的数据藏到的闭包中

实例1

def fn():

    a = 10

    # 函数内部再定义一个函数
    def inner():
        print('我是fn2' , a)

    # 将内部函数 inner作为返回值返回   
    return inner

# r是一个函数，是调用fn()后返回的函数
# 这个函数实在fn()内部定义，并不是全局函数
# 所以这个函数总是能访问到fn()函数内的变量
r = fn()    

r()

实例2

• 形成闭包的要件
  • ① 函数嵌套
  • ② 将内部函数作为返回值返回
  • ③ 内部函数必须要使用到外部函数的变量

def make_averager():
    # 创建一个列表，用来保存数值
    nums = []

    # 创建一个函数，用来计算平均值
    def averager(n) :
        # 将n添加到列表中
        nums.append(n)
        # 求平均值
        return sum(nums)/len(nums)

    return averager

averager = make_averager()

print(averager(10))
print(averager(20))
print(averager(30))
print(averager(40))