编程高手之路——闭包函数

最新推荐文章于 2021-12-13 20:15:07 发布
最新推荐文章于 2021-12-13 20:15:07 发布
阅读量655 收藏 4
点赞数
分类专栏： python编程高手之路
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_37388085/article/details/104454292
版权

目录

一、函数嵌套调用

1.1函数嵌套调用

函数嵌套指的是在函数内部又调用了其它的函数。

# 求三个数的最大值
def max2(x, y):
    if x > y:
        return x
    else
        return y

def max3(x, y, z):
    res1 = max2(x, y)
    res2 = max2(res1, z)
    return res2

print(max3(11, 199, 2))

1.2 函数嵌套定义

函数的嵌套定义指的是在函数内又定义了其它函数。

def func1():
    print('from func1')
    def func2():
        print('from func2')
    print(func2)  # 输出函数func2的地址
    func2()

二、名称空间

2.1 名称空间说明

名称空间从字面意思理解就是存放名字的地方，在学习变量的时候知道：定义一个变量就是开辟一块内存空间，这个内存空间存放的就是变量的值，除了变量值之外，还有变量名。

变量名和变量值的绑定关系这个数据要在内存中存储。变量名是名字，函数名也是名字，名称空间就是存放名字与值的绑定关系的地方。

2.2 名称空间的分类

名称空间分为三类

  1. 内置名称空间：存放python解释器自带的名字，在解释器启动时就生效，解释器关闭就失败。
  2. 全局名称空间：文件级别的名字，在执行文件的时候生效，在文件结束或者在文件执行时被删除则失效。有些全局名称空间可能一眼看上去不像全局名称空间。我们只需要记住，只要不是内置名称空间和局部名称空间，那么就是全局名称空间。
  3. 局部名称空间：存放函数定义的名称（函数的参数以及函数内的名字都存放于局部名称空间），在函数调用时临时生效，函数结束则失效。
# 内置
print(print)
print(len)

#全局
x = 1  # 全局

def func():  # func是全局名称空间
    name = 'Albert'  # name是局部名称空间

if 10>3:
    y = 2  # 全局

while True：
    z = 5  # 全局
    break

内置名称空间与全局名称空间的结束的生命周期基本上是一致的，程序执行结束或者文件关闭（手动强制关闭写python代码的这个文件），内置或者全局名称空间生命周期结束。局部名称空间生命周期是从函数调用开始到函数结束，即函数生命周期终止。

加载顺序：内置名称空间->全局名称空间->局部名称空间
查找名字：局部名称空间->全局名称空间->内置名称空间

# 加载顺序很好理解，查找顺序是以当前位置为起始点

len = 0

def f1():
    len = 1
    def f2():
        len = 2
        print(len)

    len = 3
    f2()

f1()  # 输出为2

三、作用域

3.1 变量作用域

变量作用域是指一个变量可以使用的范围，例如在函数中定义的变量只允许本函数使用，称之为局部变量；而在代码非函数中定义的变量则称为全局变量，允许在多个函数或者代码中共同访问。

Python为了进行全局变量的标注，提供了global关键字，只需要在变量使用前利用global进行声明就可以自动将函数中操作的变量设置为全局变量。

关于变量名称解析的LEGB原则

  • L(Local)：函数内部变量名称；
  • E(Enclosing Function Locals)：外部嵌套函数变量名称；
  • G(Global)：函数所在模块或程序文件的变量名称；
  • B(Builtin)：内置模块的变量名称；

如果按照以上顺序都无法找到指定的变量名称，那么在程序执行时就会报错。

3.1.1 参数名称的另一种定义形式：

在代码开发中常常会出现同一变量名被重复使用的情况，为避免使用时出现问题，项目开发定义变量时往往使用一些标记结合变量名称一起进行定义，例如：

  1. 函数局部变量（本地变量，使用local_var_作为前缀）：local_var_name;
  2. 函数参数（使用function_parameter_作为前缀）：function_parameter_name;
  3. 全局变量（字母大写，使用GLOBAL_VAR_作为前缀）：GLOBAL_VAR_NAME；

采用此类方法可以从根本上杜绝变量名重名的影响。而是否采用这种命名方式，还需要取决于开发者所处的开发公司的命名要求来决定。

3.2全局作用域

全局作用域包含的是内置名称空间与全局名称空间的名字，它的特点是：

  1. 在任何位置都能够访问到；
  2. 该范围的名字会伴随程序整个生命周期；

如果在局部使用全部作用域的变量是没有问题的，但是如果在局部修改全局作用域的变量则不能直接修改，而要使用global关键字才能修改。

global_count = 0

def global_check():
    print(global_count)  # 直接使用全局变量

def global_modify():
    global global_count  # 修改前需要先使用global
    global_count += 1
    print(global_count)

global_check()
global_modify()

3.3 局部作用域

局部作用域包含的是局部名称空间的名字，它的特点是

  1. 只能在函数中使用；
  2. 调用函数时生效，调用结束失效；

如果在局部使用的是嵌套在函数内部的局部变量，可以直接使用，而修改需要使用nonlocal关键字。

 def make_counter():
    count = 0

    def check_counter():
        print(count)

    check_counter()

    def modify_counter():
        nonlocal count
        count += 1
        print(count)

    modify_counter()

make_counter()

四、函数对象

4.1 函数对象说明

函数在python中是第一类对象，这个话可以通俗理解为函数也是一个对象，就是int，字符串，列表和字典一样都是对象，等学到面向对象就能有进一步的理解，现在可以暂时理解为函数对象可以像int或者字符串一样使用。

# 1、函数可以被引用

# int示例
x = 1
y = x

# 函数示例
def bar():
    print('from bar')
f = bar
f()

# 2、可以当参数传入

# int示例
x = 1

def func(a):
    print(a)

func(x)

# 函数示例
def bar():
    print('from bar')

def wrapper(func):
    func()

wrapper(bar)

# 3、可以当函数的返回值

# int示例
x = 1

def foo()
    return x

res = foo()
print(res)

# 函数示例
def bar()
    print('from bar')

def foo(func)
    return func

f = foo(bar)
f()

# 4、可以当容器类型的元素

# int示例
z = 1
l = [z, ]

print(l)

# 函数示例

def get():
    print('from get')

def put():
    print('from put')

l1 = [get, put]

l1[0]{}

4.2 函数对象应用（重点）

利用这一特性，可以优雅的取代原来的if多分支（elif这种多分支是我们写代码要尽可能避免的）。

def auth():
    print('登录。。。。')

def register():
	print('注册。。。。')

def check():
	print('查看。。。。')

def transfer():
	print('转账。。。。')

def pay():
	print('支付。。。。')

fun_dict = {
	'1':auth,
	'2':register,
	'3':check,
	'4':transfer,
	'5':pay}

def interactive():
	while True:
		print(
		"""
		1 登录
		2 注册
		3 查看
		4 转账
		5 支付
		""")
		choice = input('>>').strip()
		if choice in fun_dict:
			fun_dict[choice]()
		else:
			print('非法操作')

interactive()

五、闭包函数

5.1 闭包函数说明

闭包函数就是定义在函数内部的函数，也就是函数的嵌套定义。根据字面意思理解，闭包函数有两个关键字闭和包，分别是封闭和包裹。需要注意的重点是：闭包函数的作用域关系在函数定义阶段就固定死了，与调用位置无关。

def outer():
    x = 1

    def inner():
    	# 注意和nonlocal的区别
    	# nonlocal x
    	# x += 1
        x = 2
        print('from inner',x)

    return inner  # outer函数返回inner函数对象

f = outer()  # 现在f是一个全局变量，同时是inner函数对象

print(f)

x = 3  # 这个x = 3并不能改变inner函数外层的x
f()

def foo():
    x = 4  # 这个x = 4同样也不能改变
    f()  # 全局作用域在任意位置都可以调用

foo()

闭包函数可以用外层函数来调用内部的函数，打破了函数的层级限制，与此同时该函数包含对外部函数作用域中名字的引用。

def outer():
	name = 'Albert'

	def inner():
		print('my name is %s' % name)
	return inner

f = outer()
f()

5.2 为函数体传值的两种方式

（1）以参数的形式传入

import requests  # requests模块就是模拟浏览器向目标站点发请求

def get(url)
	response = requests.get(url)  # get方法获取请求返回对象
	print(response)
	if response.status_code == 200:  # 200是一个状态码，代表请求成功
		print(response.text)  # text方法是获取返回对象的内容

get('https://www.baidu.com')

（2）以闭包函数的形式

闭包函数就是在函数外再包裹一层作用域，由于这个作用域在外层函数内部，所以只作用在内层函数上。

def outer(url)  # 给外层参数传参相当于 url='https://www.baidu.com'

    def get():
        response = request.get(url)
        if response.status_code == 200:
            print(response.text)
    return get

baidu = outer('https://www.baidu.com')
python = outer('https://www.python.org')

baidu()
python()

5.3 nonlocal关键字

使用闭包结构的最大特点是可以保持外部函数操作的状态，但是如果要想在内部函数中修改外部函数中定义的局部变量或者参数的内容，则必须使用nonlocal关键字。

def print_data(count):
    def out(data):
        nonlocal count
        count += 1
        print("count:{},\ndata:{}".format(count,data))
    return out
    
oa = print_data(1)
oa("www.baidu")

六、装饰器

6.1 装饰器说明

器指的工具（只要是工具，就应该想到函数），装饰指的是为被装饰对象添加新功能。需要注意的是：项目一旦上线之后，就应该遵循开发封闭的原则。开放封闭指的是对修改函数内的源代码和调用方式是封闭的，对功能的扩展是开放的。

看起来有点矛盾，但这就是我们要做的。在这样的要求下，我们必须找到一种解决方案，能够在不修改一个功能源代码以及调用方式的前提下，为其添加新功能。这就用到了装饰器，它能够在不修改被装饰对象源代码与调用方式的前提下，为被装饰器对象添加新功能。

6.2 无参装饰器

（1）无参装饰器实现过程

无参修饰器指的是装饰器本身没有参数

# 要求：为index函数添加一个统计时间的功能
import time  # 这是一个与时间相关的模块

def index():
    time.sleep(3)  # 睡3秒
    print('welcome to index page')

index()

# 版本一（只有index函数可以使用）
import time  # 这是一个与时间相关的模块

def index():
    time.sleep(3)  # 睡3秒
    print('welcome to index page')

start_time = time.time()  # 从1970年开始计时的时间戳
index()
end_time = time.time()
print('run time is %s' % (end_time - start_time))

% 版本二（两个函数都可以使用，但是有大量重复代码）
def index():
    time.sleep(3)  # 睡3秒
    print('welcome to index page')

def home(name):
    time.sleep(5)
    print('welcome %s to home page' % name)

start_time = time.time()
index()
stop_time = time.time()
print('run time is %s' % (end_time - start_time))

start_time = time.time()
home('Albert')
stop_time = time.time()
print('run time is %s' % (end_time - start_time))

# 版本三(修改了源函数的调用方式)
import time

def index():
    time.sleep(3)  # 睡3秒
    print('welcome to index page')

def home(name):
    time.sleep(5)
    print('welcome %s to home page' % name)

def wrapper(func):
	start_time = time.time()
	func()
	stop_time = time.time()
	print('run time is %s' % (stop_time - start_time))

wrapper(index)

# 版本四（使用闭包函数，不修改源函数调用方式）
import time

def index():
    time.sleep(3)  # 睡3秒
    print('welcome to index page')

def outer(func):
	def wrapper():
		start_time = time.time()
		func()
		stop_time = time.time()
		print(stop_time - start_time)
    return wrapper

index = outer(index)  # 赋值给index覆盖原来的index，index = wrapper

index()  # wrapper()

# 版本五（解决原函数返回值无效）
import time

def index():
	time.sleep(1)
	print('welcome to index page')
	return 1  # 假设源函数有一个返回值

def outer(func):
	def wrapper():
		start_time = time.time()
		res = func()
		stop_time = time.time()
		print(stop_time - start_time)
		return res
    return wrapper

index = outer(index)
res = index()
print(res)

# 版本六（终极版，解决有参函数和无参函数通用的问题）
import time

def index():
	time.sleep(1)
	print('welcome to index page')
	return 1  # 假设源函数有一个返回值

def home(name):
    time.sleep(5)
    print('welcome %s to home page' % name)

def timer(func):  # 装饰器也是一个函数，起一个好听的名字
	def wrapper(*args, **kwargs):
		start_time = time.time()
		res = func(*args, **kwargs)
		stop_time = time.time()
		print(stop_time - start_time)
		return res
    return wrapper

index = timer(index)  # 新的index=wrapper
home  = timer(home)  # 新的home=wrapper

home(name='Albert')  # wrapper(name='Albert')
home('Albert')  # wrapper('Albert')
index()  # wrapper()

#  无参装饰器模板
def outer(func):
	def inner(*args, **kwargs):
		"""
		这里写装饰器逻辑
		：param args:任意位置参数
		：param kwargs：任意关键字参数
		：return：一个函数对象
		"""
		res = func(*args, **kwargs)
		return res
	return inner

（2）装饰器语法糖

import time

# 装饰器也是一个函数，使用函数必须先定义，所以装饰器放在最上方
def timer(func):
	def wrapper(*args, **kwargs):
		start_time = time.time()
		res = func(*args, **kwargs)
		stop_time = time.time()
		print(stop_time - start_time)
		return res

@timer  # 在被装饰对象正上方单独一行添加，相当于执行index=timer(index)
def index():
	time.sleep(1):
	print('welcome to index page')
	return 1

（3）用户认证装饰器

import time

current_user = {'username': None}


def auth(func):
    def wrapper(*args, **kwargs):
        if current_user['username']:
            print('已经登陆过了')
            res = func(*args, **kwargs)
            return res

        name = input('用户名>>').strip()
        pwd = input('密码>>').strip()
        if name == 'Albert' and pwd == '1':
            print('登录成功')
            current_user['username'] = name
            res = func(*args, **kwargs)
            return res

        else:
            print('用户名或密码错误')

    return  wrapper

@auth

def index():
    time.sleep(1)
    print('welcome to index page')

@auth
def home(name):
    time.sleep(2)
    print('welcome %s to home page' % name)

index()
home('Albert')

总结

  1. 知道在局部修改全局作用域的变量需要使用关键字global；
  2. 知道在局部中修改嵌套在函数内部的局部变量需要使用关键字nonlocal；
  3. 知道在嵌套函数中对局部变量重新赋值和修改的区别（是否使用nonlocal）；
  4. 知道函数对象的应用，这可以有效减少if-else的使用；
  5. 知道闭包函数的使用；
  6. 知道为函数体传值的两种方式（以参数形式和以闭包形式）；
  7. 使用@表示对该函数执行装饰函数；
然后就去远行吧
关注
  • 0
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C语言实现三种闭包算法（传递，自反，对称闭包）
11-01
C语言实现三种闭包算法，能够实现传递，自反，对称闭包
如何手写一个闭包函数
weixin_48962287的博客
09-15 581
【简单认识】什么是闭包，理解闭包是什么，弄懂闭包，程序开发知识，编程知识点。，侯捷谈堆、栈与内存管理（上），【简单认识】什么是匿名函数，理解匿名函数，匿名函数跟一般函数的区别，程序开发知识，编程知识点。，JavaScript闭包怎么理解呢，1、编程思想介绍（重要），一期学会做小程序 - vue+uni-app+uniCloud 前端后端全栈一体开发以及留言板小案例演示，【简单认识】foreach和map，foreach怎么用，map怎么用，foreach和map的区别，程序开发知识，编程知识点。
手写闭包函数
weixin_53093309的博客
06-03 515
1： 闭包函数 定时器循环是异步编程， 每一轮循环设置定时器, 无需等定时器触发执行， 继续下一轮循环。 （定时器触发的时候，循环已经结束）； 十次循环都已经结束了， 设置了十次定时器， 循环已经结束， 定时器还没有开始。 循环结束 i = 10； for(var i=0, i<10, i++) { setTimeout(()=> { console.log(i); }, 1000) } 1: 修改为： let 存在块级作用域， 每一次
闭包的使用
08-25 312
闭包 学习目标 能够知道闭包的构成条件 能够知道定义闭包的语法格式 1. 闭包的介绍 我们前面已经学过了函数，我们知道当函数调用完，函数内定义的变量都销毁了，但是我们有时候需要保存函数内的这个变量，每次在这个变量的基础上完成一些列的操作，比如: 每次在这个变量的基础上和其它数字进行求和计算，那怎么办呢? 我们就可以通过咱们今天学习的闭包来解决这个需求。 闭包的定义: 在函数嵌套的前提下，内部函...
闭包,手写一个闭包函数
Erictezx的博客
12-13 423
闭包（closure）指有权访问另一个函数作用域中变量的函数。简单理解就是 ，一个作用 域可以访问另外一个函数内部的局部变量。 function fn() { var num = 10; function fun() { console.log(num); } return fun; } var f = fn(); f(); 作用：延长变量作用域、在函数的外部可以访问函数内部的局部变量，容易造成内层泄露，因为闭包中的局部变量永远不会被回收 ...
javascript高级编程之函数表达式 递归和闭包函数
10-23
主要介绍了javascript高级编程之函数表达式 递归和闭包函数的相关资料,需要的朋友可以参考下
Java函数式编程(五)：闭包
09-04
主要介绍了Java函数式编程(五)：闭包,本文是系列文章的第5篇,其它篇章请参阅相关文章,需要的朋友可以参考下
PHP编程之高级技巧——利用Mysql函数
12-17
Mysql为我们提供了不少此类的函数。是否可以利用Mysql函数来处理PHP程序呢？笔者做了以下的尝试。 <?php  $data_time="1998-12-31 23:59:59"; $connect_id=mysql_connect(‘localhost’); $query_id=mysql_query...
PHP匿名函数(闭包函数)详解
01-03
在PHP中匿名函数（Anonymous functions），也叫闭包函数（ closures ），允许临时创建一个没有指定名称的函数。经常用作回调函数（callback）的参数。 当然，也有其他应用的情况。 注：php闭包是PHP5.3版本之后才有...
计算机C语言编程——函数-综合文档
05-14
计算机C语言编程——函数C语言是一种计算机程序设计语言。它既有高级语言的特点，又具有汇编语言的特点。它可以作为系统设计语言，编写工作系统应用程序，也可以作为应用程序设计语言，编写不依赖计算机硬件的应用...
python中的闭包函数
01-20
闭包函数初探 通常我们定义函数都是这样定义的 def foo(): pass 其实在函数式编程中，函数里面还可以嵌套函数，如下面这样 def foo(): print(hello world in foo) def bar(): print(hello world in bar) 此时...
Python闭包之返回函数的函数用法示例
12-25
闭包就是由其他函数动态生成并返回的函数，通俗地讲，在一个函数的内部，还有一个“内层”的函数，这个“内层”的函数是被返回的，它可以访问其创建者的局部命名空间中的变量。 下面是一个非常简单的例子： # ...
计算机C语言编程——函数.ppt-综合文档
05-22
计算机C语言编程——函数.ppt
PHP闭包函数传参及使用外部变量的方法
12-19
在Laravel控制器写两个方法，一个是在内部创建一个闭包函数，一个是执行传过来的闭包函数，测试闭包的写法，use使用外部变量，及闭包函数的传参。如下： //测试闭包传参及use使用外部变量 public function ...
LabView图形化编程语言之上位机——数字键盘功能.zip
04-02
LabView-图形编程-虚拟仪器-源码-测试测量
一段代码理解闭包
weixin_30703911的博客
01-01 198
在JavaScript中很多人都会遇到的问题，什么是闭包？其实闭包没想象中的那么难 一句话总结就是子函数能够调用父函数的局部变量，就叫闭包 给大家看一段代码 function sugar(){ var a = 'sugar' // 在父函数我们声明了一个局部变量 function huasheng(){ // 同时我们在su...
函数式编程（二）：闭包
qiyuancoder的博客
01-03 338
闭包这词估计已经听烂了，这里随便再复习下它的概念。 闭包 (Closure)：函数和其周围的状态(词法环境)的引用捆绑在一起形成闭包。 特点1：可以在另一个作用域中调用一个函数的内部函数并访问到该函数的作用域中的成员。 上文提到的，函数作为返回值和那个支付的例子，就是闭包： function makeFn() { let msg = 'Hello function' return function () { console.log(msg) } } const fn
手写闭包
weixin_45677987的博客
05-13 1365
1： 闭包函数 定时器循环是异步编程， 每一轮循环设置定时器, 无需等定时器触发执行， 继续下一轮循环。 （定时器触发的时候，循环已经结束）； 十次循环都已经结束了， 设置了十次定时器， 循环已经结束， 定时器还没有开始。 循环结束 i = 10； for(var i=0, i<10, i++) { setTimeout(()=> { console.log(i); }, 1000) } 1: 修改为： le...
go语言的闭包函数和函数式编程
最新发布
07-27
闭包函数是指内部函数可以访问外部函数的局部变量，并且在外部函数执行结束后，依然可以访问和修改这些变量。在Go语言中，函数也可以作为返回值返回，形成闭包。闭包函数可以用来实现函数式编程的一些特性。 函数式编程是一种编程范式，它将计算过程看作是一系列函数的应用。在函数式编程中，函数被视为一等公民，可以像其他数据类型一样传递、赋值和返回。函数式编程强调使用纯函数，即不依赖于外部状态和副作用的函数，这样可以提高代码的可读性、可维护性和并发性。 在Go语言中，闭包函数和函数式编程可以结合使用。通过闭包函数，我们可以在函数内部定义其他函数，并且这些内部函数可以访问外部函数的局部变量。这样就可以实现一些函数式编程的特性，例如高阶函数、柯里化和函数组合等。 以下是一个示例代码，演示了Go语言中闭包函数和函数式编程的用法： ```go package main import "fmt" // 返回一个闭包函数，用于累加计数 func counter() func() int { count := 0 return func() int { count++ return count } } // 使用高阶函数将一个整数加倍 func double(n int) int { return n * 2 } // 使用高阶函数将两个整数相加 func add(a, b int) int { return a + b } func main() { // 使用闭包函数创建一个计数器 c := counter() // 调用计数器函数，并打印结果 fmt.Println(c()) // 输出: 1 fmt.Println(c()) // 输出: 2 // 使用高阶函数将整数加倍，并打印结果 fmt.Println(double(5)) // 输出: 10 // 使用高阶函数将两个整数相加，并打印结果 fmt.Println(add(3, 4)) // 输出: 7 } ``` 在上面的示例中，`counter`函数返回了一个闭包函数，用于实现简单的计数器。`double`函数和`add`函数都是高阶函数，可以作为参数传递给其他函数使用。这些示例展示了Go语言中闭包函数和函数式编程的一些用法。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值