函数对象与闭包函数

一 函数对象

函数对象：可以把函数当成变量去使用

本质：func = 内存地址

1、函数可以作赋值

def func():
    print('from func')

f=func
print(f,func) #<function func at 0x108c0fe18> <function func at 0x108c0fe18>
f() #from func

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

​ python 中的传递其实就是内存地址的传递

def foo(x): # x = func的内存地址
    # print(x)
    x()

foo(func) # foo(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() #from func

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

def func(): 
    print('from func')
l=[func,]
# print(l)
l[0]() #from func

def func():
		print('from func')
    
dic = {'k1':func}
dic['k1']() #from func

二 函数嵌套

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():
      	def f3():
          	pass

示例：

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

三 闭包函数

1、大前提

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

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

2、什么是闭包函数

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

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

只有同时满足'闭'和'包',才能叫闭包函数

闭包函数：名称空间与作用域的应用 + 函数嵌套

def f1():
		x= 1
		def f2():
				print(x) #1
		f2()
x =111
def bar():
    x=4444
   	f1()    
def foo():
    x= 222
    bar()
    
foo() #1

闭包函数：函数对象

def f1():
  	x = 3333
    def f2():
      	print('函数f2:', x) #3333
    return f2

f =f1()
print(f) #f2的内存地址 <function f1.<locals>.f2 at 0x103730400>
x =444
#f()
def foo():
		x = 555
  	f()
foo()

3、为何要有闭包函数=>闭包函数的应用

闭包函数可以打破函数的层级关系，将闭包函数的名字加载到全局名称空间内，所以无论在什么位置，都可以调用到该函数。

两种为函数体传参的方式

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

def f2(x): #为x形参传参时就相当于向f2的名称空间内的投入x名字
		print(x)
    
f2(1)
f2(2)
f2(3)
		

方式二：使用闭包函数方式传参

def f1(x):  #为x形参传参时就相当于向f1名称空间内的投入x名字
    #x = 3
		def f2():
				print(x)
		return f2
  
x = f1(3)
print(x) #f2的内存地址
x() #3 

import requests

传参的方案一：

直接将函数体需要的参数定义成形参

def get(url):
		response = request.get(url)
    print(len(response.txt))

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

传参的方案二：

使用闭包函数的方式传参

def outer(url):
  	# url = 'https://www、baidu/com'
    def get():
      	response = request.get(url)
        print(len(response.txt))
    return get
  
baidu=outer('https://www.baidu.com')
baidu()
cnblogs=outer('https://www.cnblogs.com/linhaifeng')
cnblogs()
zhihu=outer('https://zhuanlan.zhihu.com/p/109056932')
zhihu()