Python入门day16——函数对象、闭包函数

一、函数对象

精髓：可以把函数当成变量去用

1. 可以赋值

   # func=内存地址
   def func():
       print('from func')
   
   f=func              # 函数func赋值给变量f
   print(f,func)       # 打印f和func的内存地址，完全相同
   f()                 # 相当于调用了函数func()
   
   输出：
   <function func at 0x0000023674D47280> <function func at 0x0000023674D47280>
   from func
   

2. 可以当做参数传给另外一个函数

   def func():
       print('from func')
   
   def foo(x):     # x = func的内存地址
       print(x)    # 打印func的内存地址，完全相同
       x()         # 相当于调用了函数func()
   
   foo(func) # foo(func的内存地址)
   
   输出：
   <function func at 0x000002AB41C87280>
   from func
   

3. 可以当做另外一个函数的返回值

   def func():
       print('from func')
       
   def foo(x):     # x=func的内存地址
       return x    # return func的内存地址
   
   res=foo(func)   # foo（func的内存地址）
   print(res)      # res=func的内存地址
   res()           # 相当于调用了函数func()
   
   输出：
   <function func at 0x02FB34F0>
   from func
   

4. 可以当做容器类型的一个元素

   def func():
       print('from func')
       
   l=[func,]               # 把func当作列表的一个元素
   print(l)                # 输出列表l
   l[0]()                  # l[0]=func，l[0]()相当于调用了函数func()
   dic={'k1':func}         # 把func当作字典dic第一个key'k1'的值
   print(dic)              # 输出字典dic
   dic['k1']()             # dic['k1']=func,dic['k1']()相当于调用了函数func()
   
   输出：
   [<function func at 0x0000015F2DF87280>]
   from func
   {'k1': <function func at 0x0000015F2DF87280>}
   from func
   

5. 函数对象应用示范：

   def login():
       print('登录功能')
   
   
   def transfer():
       print('转账功能')
   
   
   def check_banlance():
       print('查询余额')
   
   def withdraw():
       print('提现')
   
   
   def register():
       print('注册')
   
   func_dic={
       '1':login,
       '2':transfer,
       '3':check_banlance,
       '4':withdraw,
       '5':register
   }
   # func_dic['1']()
   while True:
       print("""
       0 退出
       1 登录
       2 转账
       3 查询余额
       4 提现
       5 注册
       """)
       choice = input('请输入命令编号：').strip()
       if not choice.isdigit():
           print('必须输入编号，傻叉')
           continue
           
       if choice == '0':
           break
   
       if choice in func_dic:
           func_dic[choice]()
       else:
           print('输入的指令不存在')
   
       # if choice == '1':
       #     login()
       # elif choice == '2':
       #     transfer()
       # elif choice == '3':
       #     check_banlance()
       # elif choice == '4':
       #     withdraw()
       # else:
       #     print('输入的指令不存在')
   
   
   # 修正简化
   def login():
       print('登录功能')
   
   
   def transfer():
       print('转账功能')
   
   
   def check_banlance():
       print('查询余额')
   
   
   def withdraw():
       print('提现')
   
   
   def register():
       print('注册')
   
   
   func_dic = {
       '0': ['退出', None],
       '1': ['登录', login],
       '2': ['转账', transfer],
       '3': ['查询余额', check_banlance],
       '4': ['提现', withdraw],
       '5': ['注册', register]
   }
   # func_dic['1']()
   
   while True:
       for k in func_dic:
           print(k, func_dic[k][0])
   
       choice = input('请输入命令编号：').strip()
       if not choice.isdigit():
           print('必须输入编号，傻叉')
           continue
   
       if choice == '0':
           break
   
       # choice='1'
       if choice in func_dic:
           func_dic[choice][1]()
       else:
           print('输入的指令不存在')
   

函数嵌套

1. 函数的嵌套调用：在调用一个函数的过程中又调用其他函数

   def max2(x,y):
       if x > y:
           return x
       else:
           return y
   
   def max4(a,b,c,d):
       # 第一步：比较a，b得到res1
       res1=max2(a,b)
       # 第二步：比较res1，c得到res2
       res2=max2(res1,c)
       # 第三步：比较res2，d得到res3
       res3=max2(res2,d)
       return res3
   
   res=max4(1,2,3,4)
   print(res)
   
   # 输出
   4
   

2. 函数的嵌套定义:在函数内定义其他函数

   def f1():
       def f2():
           pass
   

3. 求圆形的求周长、面积

   # 求圆形的求周长：2*pi*radius
   def circle(radius,action=0):
       from math import pi
       
       def perimiter(radius):
           return 2*pi*radius
   
       # 求圆形的求面积：pi*(radius**2)
       def area(radius):
           return pi*(radius**2)
   
       if action == 0:
           return 2*pi*radius
   
       elif action == 1:
           return area(radius)
   
   circle(33,action=0)
   

闭包函数

1. 大前提

   闭包函数=名称空间与作用域+函数嵌套+函数对象

   核心点：名字的查找关系是以函数定义阶段为准

2. 什么是闭包函数

   "闭"函数指的该函数是内嵌函数

   "包"函数指的该函数包含对外层函数作用域名字的引用（不是对全局作用域）

   # 闭包函数：名称空间与作用域的应用+函数嵌套
   def f1():
       x = 333
       def f2():
           print(x)
       f2()
   x=11111
   def bar():
       x=444444
       f1()
   
   def foo():
       x=2222
       bar()
   foo()
   
   # 输出：33333333333333333333
   # 思路：调用的是函数foo(),函数foo()内的x=2222未被调用，调用了函数bar()
   #     函数bar()内的x=444444未被调用，调用了函数f1()
   #     函数f1()内定义了x,定义了函数f2(),函数f2()内输出x
   #     函数f2()内未定义x,就去f1()中，找到了x=333
   #     最后函数f1()调用了函数f2()，输出333
   
   
   # 闭包函数：函数对象
   def f1():
       x = 33333
       def f2():
           print('函数f2：',x)
       return f2
   
   f=f1() # 调用f1()，返回f2
   
   def foo():
       x=5555
       f() # 调用foo(),foo()内调用了f()，也就是调用了f2()，输出：函数f2：33333
   
   foo()
   # 输出：函数f2： 33333
   

3. 为何要有闭包函数=》闭包函数的应用

   两种为函数体传参的方式

   1. 方式一：直接把函数体需要的参数定义成形参

      def f2(x):
          print(x)
      
      f2(1)
      f2(2)
      f2(3)
      

   2. 使用闭包函数

      def f1(x): # x=3
          x=3
          def f2():
              print(x)
          return f2
      
      x=f1(3)
      print(x)
      
      x()
      
      # 结果
      <function f1.<locals>.f2 at 0x00000243F0BB7040>
      3