1. 匿名函数

• 没有函数名的函数就是匿名函数
• 语法: 变量名 = lambda 形参列表 : 返回值
• 说明：

  • 根据实际情况，前面的 “变量名 = ” 可以不要（并非省略）

  • lambda：关键字，固定写法

  • 形参列表：不可以通过 “冒号+类型名” 的方式来说明参数类型（因为 + 和后面的冒号冲突），只能用默认值来设定参数类型，其他和普通函数 的形参列表一样

  • “ : ”：固定写法

  • 返回值：相当于普通函数中 return 后面的语句，只能有一条语句（不能带有 return 的语句），因此有多行代码的普通函数，匿名函数无法实现

      例：
      def func(a,b):
          return a + b
      print(func(1,2))    # 运行结果:  3
      用 lambda 函数表达式表示如下：
      法一：
      x = (lambda a,b : a + b)
      print(x(1,2)           # 运行结果:  3
      法二：
      print((lambda a,b : a + b)(1,2))    # 运行结果:  3
    

2. 高阶函数

• 可以将其他函数作为参数，或者将函数作为返回值返回的函数就是高阶函数

• 特点一：函数接收的参数是一个函数名

• 特点二：返回值中包含函数

     特点一  实例：          
     # 需求一:将一个指定列表中的偶数，保存到一个新的列表中返回
     # 需求二:将一个指定列表中的大于5的数，保存到一个新的列表中返回
     lst = [1,2,3,4,5,6,7,8,9,10]    
     def fn1(a):       # 定义一个函数用来检测任意数的偶数
         if a % 2 == 0:
              return True
         return False
     def fn2(b):      # 定义一个函数用来检测大于5的数
          if b > 5:    
              return True
          return False
     def fn(func, lst):     # 参数 lst 为要进行筛选的列表
         new_lst = []       # 创建一个新的列表
         for i in lst:      # 对要筛选的列表进行遍历
             if func(i):    # 根据需求进行筛选
                 new_lst.append(i)  # 将满足需求的数添加到新的列表中
         return new_lst     # 返回新的列表
      print(fn(fn1, lst))   # 运行结果:  [2, 4, 6, 8, 10]
      print(fn(fn2, lst))   # 运行结果:  [6, 7, 8, 9, 10]
  

2.1 map() 函数

• 接收两个参数，一个是函数，另一个是 iterable

• 将传入的函数依次作用到每个元素，并把结果作为新的 iterable 返回

    def f(x):
        return x*x
    m = map(f,[1,2,3,4]) # iterable 是惰性序列，因此通过 list() 函数让它把整个序列都计算出来并返回一个列表
    # m = map(lambda x : x*x, [1,2,3,4])
    print(list(m))    # 运行结果：    [1, 4, 9, 16]
    print(tuple(m))   # 运行结果：    (1, 4, 9, 16)
    print(set(m))     # 运行结果：    {16, 1, 4, 9}  # 不建议用set() 
  

2.2 filter() 函数

• 接收一个函数和一个序列(可迭代)

• 将传入的函数依次作用于每个元素，然后根据返回值是 True 和 False 决定保留还是丢弃该元素

    def fn(n):
        return n % 2 == 1
    f = filter(fn,[1,2,3,4,5,6,7,8,9,10])
    # f = filter(lambda n : n % 2 == 1, [1,2,3,4,5,6,7,8,9,10])
    print(list(f))    # 运行结果：    [1, 3, 5, 7, 9]
    print(tuple(f))    # 运行结果：    (1, 3, 5, 7, 9)
    print(set(f))    # 运行结果：    {1, 3, 5, 7, 9}  # 不建议用set()
  

3. 闭包

• 将函数作为返回值也是⾼阶函数我们也称为闭包

• 闭包的好处：
  通过闭包可以创建⼀些只有当前函数能访问的变量
  可以将⼀些私有数据藏到闭包中

• ⾏成闭包的条件：
  函数嵌套
  将内部函数作为返回值返回
  内部函数必须要使⽤到外部函数的变量

    实例：
    def fn1():
        a = 100
        def fn2():
            print("我是fn2函数")    
            return a
        return fn2
    print(fn1()())
    # 运行结果：
    我是fn2函数
    100
  

4. 装饰器的引入

• 我们可以直接通过修改函数中的代码来完成需求，但是会产⽣以下⼀些问题
  • 如果修改的函数多，修改起来会⽐较麻烦
  • 不方便后期的维护
  • 这样做会违反开闭原则(ocp)
    程序的设计思想：要求开发对程序的扩展，要关闭对程序的修改

5. 装饰器的使用

• 通过装饰器，可以在不修改原来函数的情况下来对函数进⾏扩展

• 在开发中，我们都是通过装饰器来扩展函数的功能的

  实例：
  def fn1():
      print("我是fn1函数")
  def fn2(a,b):
      return a + b
  def start_end(old):     # 参数 old 为要扩展的函数对象          
      def new_function(*args,**kwargs):    # 创建一个新的函数
          print('函数开始执行.....')
          r = old(*args,**kwargs)
          print('函数执行结束.....')
          return r
      return new_function      # 返回函数
  print(start_end(fn1)())
  # 运行结果如下：
  函数开始执行......
  我是fn1函数
  函数执行结束......
  None
  
  print(start_end(fn2)(123,456))
   # 运行结果如下：
  函数开始执行......
  函数执行结束......
  579
  
  @start_end
  def speak():
      print('天卓金榜题名')
  
  @start_end
  def listen():
      print('助你榜上有名')
  speak()
  listen()
  # 运行结果如下：
  函数开始执行.....
  天卓金榜题名
  函数执行结束.....
  函数开始执行.....
  助你榜上有名
  函数执行结束.....