函数进阶的实例化理解

 一 内置函数的常用高阶函数实例理解

函数	filter(function, iterable)	map(function, iterable, ...)	sorted(iterable, cmp=None, key=None, reverse=False)
描述	过滤序列，过滤掉不符合条件的元素，返回由符合条件元素组成的新列表。	根据提供的函数对指定序列做映射处理。	对所有可迭代的对象进行排序操作。
实例1	'''2. 从指定2个数字范围内中找出所有的回文数字。 （回文数字是值从左向右读和从右向左读都是一样的数，例如：1221，242这样的） 输入：1, 100 输出：[1,2,3,...,11, 22, ..., 100]''' # data = range(1,100) # def func(item): # return str(item) == str(item)[::-1] # ret = filter(func,data) # print(list(ret))	'''1. 提取列表中每个字符串成员中的数字。 输入：["3Q", "250", "w3w", "=3=", "4_4"] 输出：["3", "250", "3", "3", "44"]''' # def func(item): # w = "" # for i in item: # if ord(i) in range(48,58): # w += i # return w # # data = ["3Q", "250", "w3w", "=3=", "4_4"] # ret = map(func,data) # print(list(ret))	'''1. 对下列数据进行排序 输入：(1, "B", 5, "QQ") 输出：[1, 5, 'B', 'QQ']''' # data = (1, "B", 5, "QQ") # ret = sorted(data, key=lambda x:str(x)) # 或ret = sorted(data,key=str) # print(ret) #[1, 5, 'B', 'QQ']

二 闭包函数实例理解

闭包函数声明和执行过程中，外函数作用域下的局部变量不会因为闭包函数执行结束而被内存回收删除，而是与内部函数进行引用绑定，导致该变量会继续保留在内存中，并且闭包函数还可以在其定义环境外被执行，并保持与该变量的关系。

实例：

1 编写函数，计算两个数字的平方的和，基于闭包原理缓存计算的结果到内存中，当出现重复的参数时，直接从外函数的变量中提取结果。

"""
实例1：
首次输入：7, 2 [首次出现，记录到外函数的变量中]
结果：53 # 49+4
再次输入：2, 3 [首次出现，记录到外函数的变量中]
结果：13 # 4+9
再次输入：7, 2 [重复输入，直接从外函数的记录中提取结果，不需要经过运算]
结果：53 # 49+4
"""
def outer():
    result = {
        # (7, 2): 53,
    }
    def inner(a, b):
        key = (a, b)
        if key in result:
            print("来自缓存的结果：")
            return result[key]

        ret = a**2+b**2
        print("来自计算的结果：")
        result[key] = ret
        return ret

    return inner

calc = outer()

ret = calc(7,2)
print(ret)  #来自计算的结果：53

ret = calc(2,3)
print(ret)  #来自计算的结果:13

ret = calc(7,2)
print(ret)  #来自缓存的结果：53

 三 递归函数实例理解

python在内存中是使用栈桢空间是用来运行函数的。调用函数就是开辟栈桢空间的过程，调用结束之后，会自动释放栈桢空间。

每调用一次函数，就开辟一个栈桢空间，每结束一个函数，就释放一层栈桢空间，递归本质上就是开辟和释放栈桢空间的过程。

递归函数的运行需要占用的空间内存等性能消耗远比循环要高。使用递归时务必在函数调用前添加一个判断条件，直到不满足退出重复操作。如果递归的层数过多，层数达到1000层则报错，将会被python解释器强制终止递归。

建议大家针对简单操作少用递归，多用循环，除非这个问题真的很适合使用递归。而针对复杂操作多用递归，少用循环，因为复杂操作情况下的循环代码（4层以上嵌套循环），很容易让人懵逼。

以下为一些递归函数实例便于理解

"""
1. 编写递归函数，计算任意数n的阶乘。
1*2*3*4...*n  n 的阶乘
采用递归的思路：
假设n=4
1*2*3*4        要计算4的阶乘，先要计算3的阶乘是多少
1*2*3          要计算3的阶乘，先要计算2的阶乘是多少
1*2            要计算2的阶乘，先要计算1的阶乘是多少
1              1的阶乘就是1呀！！！
得到1的阶乘1以后，
则2的阶乘就是
fn(2) ---> fn(1)*2
则3的阶乘就是
fn(3) ---> fn(2)*3
"""
# def fn(n):
#     if n == 1:
#         return 1
#     else:
#         return n*fn(n-1)
#
# ret = fn(4)
# print(ret) #24
"""
2. 编写递归函数，输出斐波那契数列的第n项。
斐波那契数列:
0,1,1,2,3,5,8,13,21,34,55...
计算第n项的数列
fa(n)  ---> fa(n-1) + fa(n-2)
假设n=5
fn(5)  ---> fa(4) + fa(3)
            fa(4) ----> fa(3) + fa(2)
                    fa(3) ---> fa(2) + fa(1)
                               fa(2) ---> fa(1) + fa(0)
                                             1       0
"""
# def fa(n):
#     if n == 0:
#         return 0
#     if n == 1:
#         return 1
#     return fa(n-2) + fa(n-1)
#
# print( fa(4) ) # 3

3. 思路：

 

"""
3. 编写递归函数，输出类似123454321这样的回文数字。
"""

def func(s):
    if s < 5:
        print(s, end="")
        func(s + 1)
    print(s, end="")

func(1)

4. 思路

4.编写函数，基于递归原理，反转字符串
实例1：
输入："12453"
结果："35421"

实例2：
输入："abf"
结果："fba"
def fn(content):
    if content == "":
        return content
    else:
        return fn(content[1:]) + content[0]