欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页  >  IT编程

【2020Python修炼记18】Python语法入门—函数对象+函数的嵌套+闭包函数

程序员文章站 2022-03-10 16:16:16
目录 1、函数对象 2、函数嵌套 3、闭包函数 3.1 什么是闭包函数 3.2 如何定义闭包函数 3.3 为何要有闭包函数——闭包函数的应用场景 1、函数对象 函数对象:指的是函数可以被当做’数据’来处理。 具体可以分为四个方面的使用: (1)函数可以被引用 (2)函数可以作为容器类型的元素 (3) ......

 

目录

1、函数对象

2、函数嵌套

3、闭包函数

3.1 什么是闭包函数

3.2 如何定义闭包函数

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

 

1、函数对象

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

# func=内存地址

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

func()

输出结果: from func

 

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

(1)函数可以被引用

# func=内存地址
def func():
    print('from func')

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

print(f,func)  #输出的是 f func 的内存地址
f() #调用函数 f


输出结果:
<function func at 0x000001cf11cca0d0> <function func at 0x000001cf11cca0d0>
from func

 

(2)函数可以作为容器类型的元素

 

# func=内存地址
def func():
    print('from func')

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

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

输出结果:
[<function func at 0x000001b6bc12a0d0>]
from func
{'k1': <function func at 0x000001b6bc12a0d0>}
from func

 

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

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

def foo(x):      #  foo(func),  x = func的内存地址
    print(x)      #先输出func 的内存地址
    x()             # x=func的内存地址,x()相当于 func()

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


输出结果:
<function func at 0x000001c3aef4a0d0>
from func

 

# func=内存地址
def func():
    print('from func')

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

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

输出结果:
from func

 

(4)函数的返回值可以是一个函数 

# func=内存地址
def func():
    print('from func')

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

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

res()

输出结果:
<function func at 0x000001c3aef4a0d0>
from func

 

2、函数的嵌套

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

def f1():
    def f2():
        pass

 

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

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)

好大一颗栗子:

# 圆形
# 求圆形的求周长: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)

 

3、闭包函数

【大前提】

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

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

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

 

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

 

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

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

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

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

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

x=1
def outer():
    x=2
    def inner():
        print(x)
    return inner

func=outer()
func() # 结果为2

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

>>> func.__closure__
(<cell at 0x10212af78: int object at 0x10028cca0>,)
>>> func.__closure__[0].cell_contents
2

 

(2) 如何定义闭包函数

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

def f1():
    x = 33333333333333333333
    def f2():
        print(x)
    f2()


x=11111
def bar():
    x=444444
    f1()

def foo():
    x=2222
    bar()

foo()


输出结果:
33333333333333333333

 

2)闭包函数:函数对象

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

f=f1()
# print(f)

# x=4444
# f()
def foo():
    x=5555
    f()

foo()

输出结果:
函数f2: 33333333333333333333

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

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

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

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()


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