python嵌套类的高级语法_【2020Python修炼记18】Python语法入门—函数对象+函数的嵌套+闭包函数...

目录

1、函数对象

2、函数嵌套

3、闭包函数

3.1 什么是闭包函数

3.2 如何定义闭包函数

3.3 为何要有闭包函数——闭包函数的应用场景

1、函数对象

函数对象：指的是函数可以被当做’数据’来处理。

#func=内存地址

deffunc():print('from func')

func()

输出结果： from func

具体可以分为四个方面的使用：

(1)函数可以被引用——f=func

#func=内存地址

deffunc():print('from func')

f=func #将func的内存地址传给 f

print(f,func) #输出的是 f func 的内存地址

f() #调用函数 f

输出结果：

from func

(2)函数可以作为容器类型的元素——l=[func,]

#func=内存地址

deffunc():print('from func')

l=[func,]print(l)

l[0]()

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

dic['k1']()

输出结果：

[]fromfunc

{'k1': }from func

(3)函数可以作为参数传入另外一个函数——foo(func)

deffunc():print('from func')def foo(x): #foo(func), x = func的内存地址

print(x) #先输出func 的内存地址

x() #x=func的内存地址，x()相当于 func()

foo(func)#foo(func的内存地址) #调用函数foo

输出结果：

from func

#func=内存地址

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

#print(x)

x()

foo(func)#即 foo(func的内存地址)

输出结果：from func

(4)函数的返回值可以是一个函数 ——return 函数名——注意：不加扩号噢

#func=内存地址

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

return x #return func的内存地址

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

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

res()

输出结果：

from func

2、函数的嵌套

(1)函数的嵌套定义:在函数内定义其他函数

deff1():deff2():pass

(2)函数的嵌套调用：在调用一个函数的过程中又调用其他函数

defmax2(x,y):if x >y:returnxelse:returnydefmax4(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)returnres3

res=max4(1,2,3,4)print(res)

好大一颗栗子：

#圆形#求圆形的求周长：2*pi*radius

def circle(radius,action=0):from math importpidefperimiter(radius):return 2*pi*radius#求圆形的求面积：pi*(radius**2)

defarea(radius):return pi*(radius**2)if action ==0:return 2*pi*radiuselif action == 1:returnarea(radius)

circle(33,action=0)

3、闭包函数

【大前提】

基于函数对象的概念，可以将函数返回到任意位置去调用，

但作用域的关系是在定义完函数时就已经被确定了的，与函数的调用位置无关。

也就是说函数被当做数据处理时，始终以自带的作用域为准。

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

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

(1)什么是【闭包函数】

函数被当做数据处理时，始终以自带的作用域为准。若内嵌函数包含对外部函数作用域(而非全局作用域)中变量的引用，那么该’内嵌函数’就是闭包函数，简称闭包(closures)。

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

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

因而无论在何处调用闭包函数，使用的仍然是包裹在其外层的变量。

x=1

defouter():

x=2

definner():print(x)returninner

func=outer()

func()#结果为2

可以通过函数的closure属性，查看到闭包函数所包裹的外部变量。

>>> func.__closure__(,)>>> func.__closure__[0].cell_contents2

(2) 如何定义闭包函数

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

deff1():

x= 33333333333333333333

deff2():print(x)

f2()

x=11111

defbar():

x=444444f1()deffoo():

x=2222bar()

foo()

输出结果：33333333333333333333

2)闭包函数：函数对象

deff1():

x= 33333333333333333333

deff2():print('函数f2：',x)returnf2

f=f1()#print(f)

#x=4444#f()

deffoo():

x=5555f()

foo()

输出结果：

函数f2：33333333333333333333

(3)为何要有闭包函数——闭包函数的应用

两种为函数体传参的方式：

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

deff2(x):print(x)

f2(1)

f2(2)

f2(3)

方式二：将值包给函数

def f1(x): #x=3

x=3

deff2():print(x)returnf2

x=f1(3)print(x)

x()

又有好大一颗栗子：

import requests #需要事先下载函数模板

传参的方案一：defget(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')

传参的方案二：defoutter(url):#url='https://www.baidu.com'

defget():

response=requests.get(url)print(len(response.text))returnget

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

baidu()

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

cnblogs()

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

zhihu()

闭包函数的这种特性有时又称为惰性计算。使用将值包给函数的方式，在下一篇博客介绍的装饰器中也将大有用处。