python进阶-函数式编程(高级函数)

• 函数式编程(FunctionalProgramming)

  • 基于lambda演算的一种编程方式

    • 程序中只有函数
    • 函数可以作为参数,同样也可以作为返回值
    • 纯函数编程语言:LISP,Haskell

  • Python函数式编程只是借鉴函数式编程的一些特点,可以理解成一半函数式,一半Python

  • lambda表达式

    • 函数:最大程度服用代码
      • 存在问题:如果函数很小,很短,则会比较啰嗦
      • 如果函数被调用次数较少,则会造成浪费
    • lambda表达式(匿名函数)
      • 一个表达式,函数体相对简单
      • 不是一个代码块,仅仅是一个表达式
      • '可以有参数,有多个参数,可以用逗号隔开
    • lambda表达式用法
      • 以lambda开头
      • 紧跟一定的参数书(如果有的话)
      • 参数后面用冒号和表达式主题隔开
      • 只是一个表达式,所以没有return

    语法:st = lambda x : 代码块
    #lambda案例1
    stm = lambda x : print("我叫{0}".format(x))
    stm("张三")
    #lambda案例2
    stm2 = lambda x,y,z : x + y * 10 + z
    stm2(1,2,3)
    

  • 高阶函数

    • 把函数作为参数使用的函数叫高阶函数

    #变量可以赋值
    a = 1
    b = a
    print(b)
    #函数名称就是一个变量
    def funA():
        print("is funA")
    funB = funA
    funB()
    

    • 以上代码得出结论
      • 函数名称是变量
      • funA和funB只是名称不一样而已
      • 既然函数名称是变量,则应该可以被当作参数传入另一个参数

      #高阶函数案例
      def funA(n):
          return n * 100
      
      def funB(n , f):
          return f(n) * 3
      
      print(funB(9,funA))            
      

  • 系统高阶函数-map

    • 原意就是映射,即把几个或者列表的元素,每一个元素都按照一定的规则进行操作,生成一个新的几个或者集合
    • map函数是系统提供的具有映射功能得函数,返回值是一个迭代对象

    语法:map(fun,*itreables)
    #map案例
    
    # 利用map实现
    def mul(n):
        return n * 10
    
    #使用map函数进行操作之后,返回的类型是map类型
    l3 = map(mul, l2)
    
    for i in l3:
        print(i)
    

  • reduce

    • 原意是归并,所见
    • 把一个可迭代对象最后归并成一个结果
    • 对于与作为参数的函数要求:必须由两个参数,必须有返回结果
    • reduce([1,2,3,4,5]) == f(f(f(f(1,2),3),4),5)
    • reduce 需要导入functools包

    reduce案例
    #导入functools包
    from functools import reduce
    #定义一个操作函数
    #加入操作函数只是相加
    def myadd(x,y):
        retun x+y
    #对于列表[1,2,3,4,5,6]执行myAdd的reduce操作
    rdc = reduce(myadd,[1,2,3,4,5,6])
    print(rdc)
    

    • reduce函数就是将函数中的列表依次放入到reduce(fun)这个函数中去执行

  • filter

    • 过滤函数:对一组数据进行过滤,符合条件的数据会生成一个新的列表并返回
    • 跟map相比较:
      • 相同:都对列表的每一元素进行操作
      • 不同:
        • mao会生成一个跟原来元素相对应的新队列
          -filter不一定,只要符合条件的才会进入新的数据几个
      • 语法
        • 利用给定函数进行判断
        • 返回值一定是布尔值
        • 调用格式:filter(fun,data),data是数据

    # filter案例
    # 对于一个列表,对其进行操作,偶数形成新的列表
    def isEven(n):
           return n % 2 == 0
    
    
    l = [i for i in range(1, 100)]
    fl = filter(isEven, l)
    for i in fl:
       print(i)
    

  • sorted(排序)

    • 把一个序列按照给定的算法进行排序
    • key:在排序前对每一个元素进行key函数运算,可以理解成按照key函数定义的逻辑进行排序
      -python2和python3中相差甚大
    • sort 与 sorted 区别：
      sort 是应用在 list 上的方法，sorted 可以对所有可迭代的对象进行排序操作。
      list 的 sort 方法返回的是对已经存在的列表进行操作，而内建函数 sorted 方法返回的是一个新的 list，而不是在原来的基础上进行的操作。
    • 语法:

        sorted(iterable, key=None, reverse=False)          
    

    • 参数说明
      • iterable – 可迭代对象。
        key – 主要是用来进行比较的元素，只有一个参数，具体的函数的参数就是取自于可迭代对象中，指定可迭代对象中的一个元素来进行排序。
        reverse – 排序规则，reverse = True 降序 ， reverse = False 升序（默认）。
    • 返回值:返回重新排序的列表

  • 返回函数

    • 函数可以返回具体的值
    • 也可以返回一个函数作为结果

    # 返回函数案例
    def returnFuncOne(*args):
        def returnFunTwo():
            n = 0
            for i in args:
                n += i
            return n
    
        return returnFunTwo
    
    
    rf = returnFuncOne(1, 2, 34, 545, 6)
    a = rf()
    print(a)
    

  • 闭包(closure)

    • 闭包函数:生命在一个函数中的函数叫做闭包
    • 当一个函数在内部定义函数,并且内部的函数应用外部函数的参数或者局部变量,当内部函数被当作返回值的时候,相关参数和变量保存在返回的函数中,这种结果叫做闭包
    • 上面returnFuncOne返回函数就是一个闭包结构

    # 闭包案例
    def count():
        fs = []
        for i in range(1, 4):
            def f():
                return i * i
    
            fs.append(f)
        return fs
    
    
    f1, f2, f3 = count()
    print(f1())
    print(f2())
    print(f3())
    
    >>控制台输出
    9
    9
    9
    
    

    • 出现的问题
      • 造成上述状况的原因是,返回函数引用了变量i,i非立即执行,而是等到三个函数都返回的时候才统一使用,此时i已经变为了3,最终调用的时候,都返回的是3*3
      • 此问题描述成:返回闭包时,返回函数不能引用任何循环变量

    # 改进闭包案例
    def count2():
        def f(j):
            def g():
                return j + j
    
            return g
    
        fs = []
        for i in range(1, 4):
            fs.append(f(i))
        return fs
    f1, f2, f3 = count()
    print(f1())
    print(f2())
    print(f3())
    >>控制面板输出
    1
    4
    9
    

  • 装饰器(Decrator)

    • 在不改动函数代码的基础上无限制扩展函数功能的一种机制,本质上讲,装饰器是一个返回函数的高阶函数
    • 装饰器的使用:使用@语法,即在每次要扩展的到函数顶以前使用@+函数名

    # 装饰器案例
    import time , random
    
    
    def printTime(f):
        def jsTime(*args, **kwargs):
            start_time = time.time()
            f()
            end_time = time.time()
            print(start_time - end_time)
            return f(*args, **kwargs)
    
        return jsTime
    
    
    # 定义一个打招呼的类
    @printTime
    def hello():
        time.sleep(random.randrange(1, 10))
        print("大家好,我是张家辉,是兄弟就来砍我")
    hello()
    

    • 装饰器的好处
      • 一旦定义可以装饰任意函数
      • 一旦被其装饰,则把装饰器的功能直接添加到定义函数上
        -装饰器的仔细解析
      • 装饰器中第一个函数中的参数就是被其装饰要传入的函数,而得到的返回值则是需要得到的函数,其本质就是在不改动原有代码的基础上,添加返回函数中间的代码