函数-3

• 高级函数

1.高级：支持函数式编程---泛函编程，允许参数不仅仅是一个数据，还可以是一个函数对象(且函数内部，有这个函数对象的调用)
    普通传进来的参数：数据是固定的，最终执行完毕后的结果也是固定的
    函数对象作为参数：函数的执行结果是不确定，最终执行完毕后的结果也不确定
2.在python2中：
    filter/map/reduce都是高级函数
3.在python3中：
    filter/map：是类---filter/map对象
    reduce依然是函数

• filter类

filter(function or None, iterable): 过滤
function or None:可以传入一个函数(布尔函数)对象或None
iterable：可迭代对象
返回一个filter对象
如果第一个参数是None:过滤出iterrable为假的元素，留下为真的元素，并返回
如果第一个参数是函数对象，将iterable的每一个元素，都传递给函数对象(参数),并在内部执行函数对象(参数),将函数得到的结果为真的元素留下，并返回
补充：
    参数function，其实就是过滤条件，如果为真，则留下原有的可迭代的元素--布尔函数(结果只表示为真或假)

代码：
f = list(filter(None, [0, 1, 2, 3, 4, 5, '', [], 6, 7, 8]))
f1 = list(filter(lambda x: True if x%2 else False, [0, 1, 2, 3, 4, 5, 6, 7, 8]))
print(f, f1)
效果：
[1, 2, 3, 4, 5, 6, 7, 8] [1, 3, 5, 7]

• map类

1.map(func, *iterables): 映射
func:函数对象
*iterable:可迭代对象(多个)
返回一个map对象
将多个可迭代对象的相同下标的元素，同时传递给func对象(参数),map会将func执行的结果作为新的元素进行返回
最终返回一个可迭代对象(每个元素都是func将*iterable计算之后的结果)
以最短的可迭代对象为基准(与zip类打包很像),进行运算，多出的数据不做运算
可迭代对象的数量要和函数对象的参数数量一一对应

代码：
m = list(map(lambda *a: sum(a), [1, 2, 3], [4, 5, 6], [7, 8, 9]))
print(m)
效果：
[12, 15, 18]

• reduce函数

在python3中，更换了位置：在functools模块下
1.reduce(function, sequence[,initial]):折叠
    function:函数对象
    sequence:序列
    initial:初始值
    将sequence中的每一个元素和前一个运算出来的数据进行再运算(运算规则：function对象)，每一个元素都会传递给funtion对象(参数),
    运算结果回合下一个元素继续递归运算，知道最后只有一个值为止
    注意：function函数对象是有限制的，只能有两个参数
        补充：第一次运算，是将序列的前两个值先进行运算
        如果initial给出，则第一运算时，先使用初始值+序列的第一元素进行运算(与sum里的start很像)

代码：
import functools
print(functools.reduce(lambda a, b: a+b, [1, 2, 3, 4], 10))
效果：
20

• 函数递归

1.一个函数内部可以调用自己---函数的递归调用
2.注意：
    如果递归层数过多，会报错：RecursionError
    这是一种python的保护机制
    1.避免无限递归
        每递归一次，额外开辟一块空间，容易造成内存溢出
    2.合理使用递归的收敛条件，避免无限递归
3.什么时候使用递归？
    递归---解决难题时：
    当一个问题，可以拆分成小问题，小问题可以继续拆分成更小的问题，并且大问题和小问题解决思路完全一直，可以使用递归
4.递归和循环的关系
    循环：是逻辑代码级别，重复执行某操作，不会额外占用空间
    递归：是函数/对象级别，每重复一次，会额外创建一个空间
    循环和递归：循环执行效率高，递归的执行效率很低
    只要能用递归解决的问题，一定能用循环解决

代码：
def fun(n):
    return 1 if n == 1 else n*fun(n-1)
print(fun(int(input('请输入一个整数：'))))   
效果：
120 

代码：
#汉诺塔问题
#有三个柱子 有n个盘子 每次挪动一个 且小的只能在大的上面
def hanio(start, target, temp, n):
    """
    汉诺塔问题 A B C
    :param start: 起始柱子
    :param target: 目标柱子
    :param temp: 中介柱子
    :param n: 盘子的数量
    :return:
    """
    if n == 1:
        print('{}---->{}'.format(start, target))
    else:
        # n-1个盘子 A-->C
        hanio(start, temp, target, n-1)
        # 1个盘子
        print('{}----->{}'.format(start, target))
        # n-1个盘子 C--->B
        hanio(temp, target, start, n-1)
hanio('A', 'B', 'C', 3)

效果：
A---->B
A----->C
B---->C
A----->B
C---->A
C----->B
A---->B