Python——函数对象与闭包

一、函数对象

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

1.1函数可以被引用

def func():
    pass
# func=内存地址
f=func
print(f,func)
f()

1.2 函数可以作为容器类型的元素

def func():
    print('111')

l=[func,]
l[0]()

dic={'k1':func}
print(dic)

# 函数对象引用示范
'''
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]
}

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.3 函数可以作为参数传入另外一个函数

def func():
    pass

def foo(x):
    print(x)

print(func)
foo(func)

1.4 函数的返回值可以是一个函数

def func():
    print('111')

def foo(x):
    return x

print(func)
res = foo(func) # foo(func的内存地址)
print(res)
res()

1.5 函数嵌套

• 1.5.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)
  

• 1.5.2 函数的嵌套定义：在函数内定义函数

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

二、闭包函数

• 闭包函数=名称空间与作用域+函数嵌套+函数对象
• 核心点：名字的查找关系是以函数定义阶段为准

2.1 闭与包

• “闭”函数：该函数是内嵌函数

• "包"函数：该函数包含对外层函数作用域名字的引用(不是对全局作用域)

  # 闭包函数：名称空间与作用域的应用+函数嵌套
  def f1():
      x = 2333
      def f2():
          print(x)
      f2()
      
  # 闭包函数：函数对象
  def f1():
      x = 2333
      def f2():
          print(x)
      return f2
  
  f = f1()
  f()
  

2.2 闭包的用途

• 向函数传参的另一种方式

# 两种为函数体传参的方式
# 方式一：直接把函数体需要的参数定义成形参
def f2(x):
    print(x)

f2(1)
f2(2)
f2(3)

# 方式二：
def f1(x): # x=3
    x=3
    def f2():
        print(x)
    return f2

x=f1(3)
print(x)

x()

# 应用场景
import requests

# 传参的方案一：
def get(url):
    response=requests.get(url)
    print(len(response.text))

get('https://www.baidu.com')
get('https://www.cnblogs.com/linhaifeng')
get('https://zhuanlan.zhihu.com/p/109056932')


# 传参的方案二：
def outter(url):
    # url='https://www.baidu.com'
    def get():
        response=requests.get(url)
        print(len(response.text))
    return get

baidu=outter('https://www.baidu.com')
baidu()

cnblogs=outter('https://www.cnblogs.com/linhaifeng')
cnblogs()

zhihu=outter('https://zhuanlan.zhihu.com/p/109056932')
zhihu()