函数（二）

1.递归函数：在函数中调用本身。

（1）特性：1）要有明确的结束条件（必需要用返回值return，否则会陷入死循环）。

　　　　　　2）递归函数效率不高。原因：函数会一层一层进行，一层一层进行返回。

（2）

def red(k):
    if k == 5:
       print("结果刚刚好")
       return
    if k < 5:
        k += 1
        return red(k)
    else:
        print("这里不适合你这种重量级人物")
   

 (3)如上图代码：若k<5,则函数会一层一层深入，且函数会停留在每一层中，直到返回结果。所以，递归会很占用内存，且效率不高。

(4)针对上面缺点，可以用尾调用来对递归进行优化（在函数最后一步进行调用）。

2.匿名函数：一般与其他函数混合使用，只能使用一次，因此不会占用内存.即匿名函数就相当于代码块中的1

def test(x)
    return x+1

test(5)
1
test(2)

函数运行完毕后，1就会被清理了，内存中不在存在1，lambda的作用跟这个一样

（1）形式：lambda x : x+1 >>>>>>>相当与>>>>

　　def test(x):

　　　　return x+1

3.编程的方法论：面向过程：即一步一步进行，当有一步不成立时返回到第一步

　　　　　　　　函数式：编程语言定义的函数+数学意义的函数（可读性差）

　　　　　　　　面向对象：

4.高阶函数：

（1）函数即变量

（2）把函数当作参数传给另外一个函数，或者返回值中包含函数。这都成为高阶函数

第一种：
def bar(x):    
    return x+1
def test(y):
    return y+2

print(test(bar(1)))


>>>>>4
第二种：
def bar()
    print("i am cwt")
    return bar()

注意：第二种经常用于：尾调用优化：即在函数最后一步调用函数，最后一步并不意味着一定是在最后一行

如：

def bar(n)
    return n


def foo(x)                                  
    return bar(x)+1
相当于
def foo(x)
    res=bar(x)
    return res+1

 （3）三种常见的高阶函数

1）map>>>>修改函数，将可迭代序列中的每一项的值进行修改

def map_test(func, array):
    ret = []
    for i in array:
        ret.append(func(i))
    return ret

print(list(map(lambda x : x+1,[1,2,3,4,5,6])))


》》》》【2，3，4，5，6，7】

map(lambda x : x+1,[1,2,3,4,5,6])》》》得到的结果是一个地址，所以要加个list,list内部本身会进行迭代

2) filter>>>>筛选函数，将可迭代序列中满足条件的筛选出来

def filter_test(func,array):
    ret = []
    for i in array:
        if not func(i):
            ret.append(func(i))
    return ret

print(list(filter(lambda x: x.startswith("ab"), ["ab123", 'gf123', 'ss123', 'ab222'])))



》》》['ab123', 'ab222']

3) reduce>>>内部相互处理函数，将序列内的元素进行相互运算，reduce是funcfools库的一个函数，运用前要先调用

def reduce_test(func,array,rec=none):                                       rec=none表示初始值
    if rec=none:
        rec = array.pop(0)
        for num in arry:
            rec = func(rec,num)
    else:
        for num in arry:
            func(rec,num)
    return rec

from functools import reduce
print(reduce(lambda x, y: x+y, [1, 2, 3, 4, 5, 6]))


》》》21