Python中高阶函数讲解

                                                   高阶函数讲解

1. 常规高阶函数

1. 递归函数

   格式：def func_name(variable):
            '''__doc__'''#函数的说明文档
            if 条件表达式:#限制递归退出值
                pass
            return func_name(variable2)#variable2必须是通过一系列等运算后的值。
   例如：def jiecheng(n):
            if n <= 1:
                return n
            return jiecheng(n-1)*n
        print(jiecheng(5))
    >>> 120
   #递归就是函数自身调用自身，Python最大递归层数为999层。
   

   注：递归的三大特性：

   1. 一定要有一个结束的条件
   2. 每次进入更深一层递归时，问题规模相比上次递归应有所减少
   3. 效率不高
   

2. 遍历（迭代）函数

   格式：def func_name(variable):
            for variable2 in range(1,variable):
                variable *= variable2
        return variable
   例如：def jie1(n):
            for i in range(1,n):
                n *= i
        return n
        print(jie1(5))
    >>> 120
   例如：def jie2(n):
            for i in range(n-1,0,-1):#由于顾头不顾尾，所以是n-1
                n *= i
        return n
    >>> 120
   #当range的步长为负数时，序列将end值到start值。
   

   注：一般迭代函数要比递归常用，主要原因就是速度快。

3. 函数作为参数

   格式：def func_name1():
            expression
        def func_name2(func_name1):
            expression
   例如：def num1():
            print(123)
        def num2(n):
            print(1234)
            return n()
        num2(num1)
    >>> 1234
    >>> 123
   #函数1作为函数2的参数传入到函数2中，执行函数2的代码。
   

2. 内置高阶函数

1. filter（过滤）

   格式：filter(function or None, iterable)
   例如：x = filter(lambda m:m > 1,[1,2,3])
        for i in x:
            print(i)
    >>> 2
    >>> 3
   #使用filter过滤时，当条件为Ture时，则返回符号条件的。需要两个参数，第一个是函数（不声明时，则直接把后面传入的参数转换为迭代器），第二个则是可迭代的对象（列表、元祖、字典和集合），返回值为迭代器。
   

2. map（映射）

   格式：map(function,iterable)
   例如：x = map(lambda m:m+10,(1,2,3))
        for i in x:
            print(i)
    >>> 11
    >>> 12
    >>> 13
   #与filter类似，不同于map对第二个参数的中元素进行映射，传入到第一个参数（即函数）中进行映射，返回值仍是一个迭代器。
   

3. closure（闭包）

闭包是函数返回函数，多用于装饰器函数中。

格式：def func_name1(args):
         def func_name2():
             expression
         return func_name2
例如：def outt(num):
         def inn():
            print('ab')
         return inn
     print(outt(2))
#上述的返回值为函数体inn即为闭包。

4. 装饰器

装饰器属于闭包的一种应用，主要表示符为@，装饰器的定义为：装饰器是一个高阶函数+嵌套函数，同时也是一个‘变量’。用于装饰函数，主要有两大原则，1.不能修改原代码，2.不能修改原代码的调用方式。

1. 格式：def zhuang(arg1):
             '''__doc__'''#函数的说明文档
             expression
             return arg1()
          @zhuang
          def bzhuang():
              '''__doc__'''#函数的说明文档
              expression
   例如：def zh(n1):
             print(123)
             return n1()
         @zh
         def bzh():
             print('123')
         print(bzh())
     >>> 123
     >>> '123'
   #上述为最简单的装饰器，一般很少用。主要是由于装饰器在没有调用的情况下直接执行了。
2. 例如：def login(x):
            def inner():
                return x()
            return inner
        @login
        def beiz():
            return 'abc'
        print(beiz())
    >>> 'abc'
   #上述装饰器为常用装饰器，在调用函数前，装饰器是没有执行完，只返回一个函数体。
3. 例如：def login(arg):#符号@即调用该函数
            def outter(func):#由于装饰器需要一个参数，因此这里调用装饰器也需要一个参数
                def inner(*args,**kwargs):#这里直接调用it和xinxi两个函数
                    if arg == 'abc':
                        print('arg is abc')
                    elif arg == '123':
                        print('arg is 123')
                    return func(*args,**kwargs)
                return inner#返回该函数体即为it和xinxi两个函数体
            return outter#由于装饰器调用，因此该返回的函数也将进行调用
        @login(arg='abc')#装饰器直接调用
        def it():
            print('It')
        @login(arg='123')#装饰器直接调用
        def xinxi():
            print('信息')
        it()
        xinxi()
    #该实例为装饰器的终极版，即一个装饰器可以带参数。当然也可以带动态参数，具体不再详细介绍。