一、函数的嵌套

1、函数嵌套的代码示例

  def f1():

      print('我是函数1')

      def f2():

          print('我是函数2')

      f2()

  if __name__ == "__main__":

      f1()

二、函数的作用域

坚持一个原则:在作用域小地方可以访问比它作用域大里面的变量,在作用域大地方不能访问比它更小作用域里面的变量

1、如果在函数外面要使用函数内部的函数的方式

1.使用global修饰变量

2.函数将变量返回

三、高阶函数的认识(只要满足下面条件一个就是高阶函数)

1、一个函数作为参数传递给另外一个函数

2、一个函数的返回值是一个函数

四、高阶函数示例

1、一个函数作为参数传递给另外一个函数

  def foo(func):

      print('foo函数')

      func()

  def bar():

      print('bar函数')

  if __name__ == "__main__":

      print(type(bar))

2、一个函数中返回另外一个函数

  def foo():

      print('foo函数')

      def bar():

          print('bar函数')

      return bar

  if __name__ == "__main__":

      foo()()

3、柯理化函数(典型的高阶函数)

  def foo(x):

    def bar(y):

      return x + y

    return bar

  if __name__ == "__main__":

      print(foo(1)(2))

五、关于闭包的介绍

1、闭包的概念总结:闭包=函数+环境变量

2、形成闭包的几个条件

1.函数(外函数)中定义了内函数

2.内函数使用了外函数的非全局变量

3.外函数最终返回是内函数的引用

六、闭包的认识

1、最基本的闭包代码

  def f1():  # 外部函数中定义内函数

      a = 10

      def f2():

          return a # 内函数中引用外函数非全局变量(只要使用了就可以)

      return f2 # 返回内函数的引用

  if __name__ == "__main__":

      f = f1()

      # 如果是闭包就会输出内容

      print(f.__closure__)

2、外部函数中的变量是传递进去的

  def f1(a):

      def f2():

          c = a ** 2

          return a

      return f2

  if __name__ == "__main__":

      f = f1(5)

      # 如果是闭包就会输出内容

      print(f.__closure__)

七、闭包案例(行走的示例)

1、直接修改全局变量来实现

  origin = 0

  def go(step):

      global origin

      # 当前行走的位置

      new_pos = origin + step

      # 直接修改全局变量

      origin = new_pos

      return new_pos

  if __name__ == "__main__":

      print(go(2))

      print(go(3))

      print(go(6))

2、使用闭包会记住上一次调用的状态

  origin = 0

  def factory(pos):

      def go(step):

          # 强制申明不是使用本地变量

          nonlocal pos

          new_pos = pos + step

          pos = new_pos

          return new_pos

      return go

  if __name__ == "__main__":

      factory1 = factory(origin)

      print(factory1(2))

      print(factory1(3))