10我的python学习之路--高阶函数

1. 高阶函数

• 1.1 把函数作为参数就是高阶函数
  • 示例：

    tup = (1,2,3,4,5,6,7,8,9)
    
    def f(i):
        if i % 3 == 0:
            return True
        return False
    
    def fn(func, t):      #   func 函数做参数
    
        new_l = []
        for n in t:
            if func(n):
                new_l.append(n)
        return new_l
    # 元组
    print(tup)
    # 将元组中能被3整除的添加到列表
    print(fn(f,tup))
    

  • 运行结果：
    
• 1.2 python内置高阶函数 -filter() ：用于过滤序列，过滤掉不符合条件的元素，返回一个迭代器对象，如果要转换为列表，可以使用 list() 来转换
  • 语法：filter(function, iterable)
    • function : 判断函数 iterable：可迭代对象（如序列）
  • 示例：

    tup = (1,2,3,4,5,6,7,8,9)
    
    def f(i):
        if i % 3 == 0:
            return True
        return False
    
    r = filter(f,tup)
    print(r)
    print(tuple(r))
    

  • 运行结果：
    
• 1.3 把函数作为返回值并返回的函数就是高阶函数（下面讲闭包的时候再说）

2. 匿名函数

• 2.1 使用场景：适用于功能单一的简单函数
• 2.2 特点：匿名函数用完后立即销毁，不能像普通函数被重复调用
• 2.3 语法：
  lambda 形参列表: 返回值 .[实参列表]
• 2.4 示例：

  tup = (1,2,3,4,5,6,7,8,9)
  # 此例与上个程序功能一样，只不过这里使用匿名函数 lambda
  r = filter(lambda i:i % 3 == 0,tup)   
  print(tuple(r))
  

  • 运行结果：
    

  • 示例：

    r = (lambda a,b:a+b)    # lambda表达式
    print(r)                # 打印lambda表达式的函数地址
    print(r(5,6))           
    print(r(8,7))
    

  • 运行结果：
    

  • 示例：将lambda函数赋值给一个变量

    # 计算三个数的和
    t = (lambda a,b,c : a+b+c) (10,20,50.45)    # 注意lambda表达式加括号
    print(t)
    

  • 运行结果：
    

3. 闭包

• 3.1 优点：

  • 重要的私有数据可放在闭包内，保证数据的安全性
  • 可以创建一些只有在当前函数下访问的变量

• 3.2 构成闭包的条件

  • 函数的嵌套
  • 把内层函数的函数名作为返回值返回
  • 内层函数必须要使用外层函数的变量
  • 语法结构示意：
    

• 3.3 示例：

  def f():
      a = 10
      def g():
          print('a =',a)
  
      return g
  
  r = f()
  print(r)
  r()
  # print(a)  # NameError: name 'a' is not defined  函数 f()内的a不能被访问
  

  • 运行结果：
    
  • 示例：创建一个字典，并添加数据

    def f():
        new_d = {}
        def d(dict):
            new_d.update(dict)
            return new_d
        return d
    r = f()
    print(r(dict(a=1)))
    print(r({'b':2}))
    

  • 运行结果：
    

4. 装饰器

• 4.1 扩展函数的普通方法

  • 直接在需要扩展的函数修改代码，但会存在一下问题：
    • 如果修改的代码过多，非常麻烦，降低软件开发效率
    • 在每个函数中都修改代码，不利用后期的维护
    • 违反开闭原则(ocp)：
      • 开闭原则：在程序开发过程中，对程序的扩展时开放的，而对程序的修改时封闭的、不允许的
  • 例如下面代码，想要对add 和mul 更多的函数扩展，只能是每个函数逐个增加代码，操作不方便。人工修改造成代码的不一致性，不便于维护，在修改原函数时，修改失误可能会导致源程序运行出错。为了方便开发、代码的高效管理引入了装饰器。

    def add(a,b):
        # 求2个数的和
        # print('函数开始执行')
        r = a + b
    
        # print('函数执行结束')
        return r
    
    def mul(a,b):
    
        # 求2个数的乘积
        return a * b
    

• 4.2 装饰器使用场景

  • 如果希望在不修改原有函数的基础上，对原函数进行扩展，可使用装饰器

• 4.3 装饰器的使用

  • @装饰器名 的方式对其他函数进行扩展

• 4.4 示例：

  def add(a,b):
  return a+b
  
  def start_end(old):
      def new_function(*args,**kwargs):
          print('函数开始执行：')
          r = old(*args,**kwargs)
          print('函数执行完毕...')
          return r
      # 返回新函数
      return new_function
  
  f = start_end(add)   # 返回装饰器内层函数的地址
  print(f)
  r =f(1,3)
  print(r)
  

  • 运行结果：
    

  • 示例：

    @start_end
    def sum(a,b,c):
        return a+b+c
    
    print(sum(10,20,30))
    

  • 运行结果：
    

5. 总结：python函数知识图