高阶函数

• 将函数作为参数
• 例如

  •  def sum_naturals(n):
    
             total, k = 0, 1
    
             while k <= n:
    
                 total, k = total + k, k + 1
    
             return total

    def sum_cubes(n):
    
            total, k = 0, 1
    
            while k <= n:
    
                total, k = total + k*k*k, k + 1
    
            return total

    def pi_sum(n):
    
            total, k = 0, 1
    
            while k <= n:
    
                total, k = total + 8 / ((4*k-3) * (4*k-1)), k + 1
    
            return total

  • 以上三个例子中有许多共同的部分

    • def <name>(n):
      
          total, k = 0, 1
      
          while k <= n:
      
              total, k = total + <term>(k), k + 1
      
          return total

  • 高阶函数形式

  • def summation(n, term):
    
        total, k = 0, 1
    
        while k <= n:
    
            total, k = total + term(k), k + 1
    
        return total
    
    def cube(x):
    
        return x*x*x
    
    def sum_cubes(x):
    
        return summation(x,cube)

  • 函数环境
  • 黄金比例

  • def improve(update, close, guess=1):
    
            while not close(guess):
    
                guess = update(guess)
    
            return guess
    
    def golden_update(guess):
    
            return 1/guess + 1
    
    def square_close_to_successor(guess):
    
            return approx_eq(guess * guess, guess + 1)
    
    def approx_eq(x, y, tolerance=1e-15):
    
            return abs(x - y) < tolerance
    
    improve(golden_update, square_close_to_successor)

• 高阶函数的不足
  • 在全局环境中名称复杂
  • 每一个函数的形参个数是由限制的

函数的嵌套定义

• 解决高阶函数存在的不足

• def sqrt(a):
  
          def sqrt_update(x):
  
              return average(x, a/x)
  
          def sqrt_close(x):
  
              return approx_eq(x * x, a)
  
          return improve(sqrt_update, sqrt_close)

• 嵌套定义中的函数作用域
  • 每一个嵌套的函数在定义函数内环境
  • #不是函数的调用处
• 函数作用域的实现方法
  • 每一个函数都有他的父环境
  • 当函数被调用时，在其父环境中评估
• 函数作用域的好处
  • 局部环境中的绑定不会影响全局环境

• def square(x):
  
      return x * x
  
  def successor(x):
  
      return x + 1
  
  def compose1(f,g):
  
      def h(x):
  
          return f(g(x))
  
      return h
  
  square_successor = compose1(square,successor)
  
  result = square_successor(12)

牛顿法

• def newton_update(f, df):
  
          def update(x):
  
              return x - f(x) / df(x)
  
          return update
  
  def find_zero(f, df):
  
          def near_zero(x):
  
              return approx_eq(f(x), 0)
  
          return improve(newton_update(f, df), near_zero)
  
  def square_root_newton(a):
  
          def f(x):
  
              return x * x - a
  
          def df(x):
  
              return 2 * x
  
          return find_zero(f, df)

Currying

• >>> def curried_pow(x):
  
          def h(y):
  
              return pow(x, y)
  
          return h
  
  >>> curried_pow(2)(3)
  
  8

  def curry2(f):
  
          """Return a curried version of the given two-argument function."""
  
          def g(x):
  
              def h(y):
  
                  return f(x, y)
  
              return h
  
          return g

  def uncurry2(g):
  
          """Return a two-argument version of the given curried function."""
  
          def f(x, y):
  
              return g(x)(y)
  
          return f

• 环境图

匿名函数

• 可以看做

  • 　　     lambda            x            :          f(g(x))
    
    "A function that    takes x    and returns     f(g(x))"

函数装饰器

• >>> def trace(fn):
  
          def wrapped(x):
  
              print('-> ', fn, '(', x, ')')
  
              return fn(x)
  
          return wrapped
  
  >>> @trace
  
      def triple(x):
  
          return 3 * x
  
  >>> triple(12)
  
  ->  <function triple at 0x102a39848> ( 12 )
  
  36

  • @trace等同于

  • >>> def triple(x):
    
            return 3 * x
    
    >>> triple = trace(triple)