Dieser Artikel vermittelt Ihnen relevantes Wissen über Python. Er organisiert hauptsächlich Probleme im Zusammenhang mit fortgeschrittener Programmierung, einschließlich Rückgabefunktionen, Schließungen, Dekoratoren, Teilfunktionen usw. Wir hoffen, dass es allen hilft.
【Verwandte Empfehlung: Python3-Video-Tutorial】
Funktionen höherer Ordnung können nicht nur Funktionen als Parameter akzeptieren, sondern auch Funktionen als Ergebniswerte zurückgeben. Wenn wir eine Funktion ausführen und diese nicht sofort summieren müssen, können wir sie nach Bedarf im folgenden Code berechnen. Zum Beispiel unten:
# -*- coding: utf-8 -*-# python 全栈# author : a wei # 开发时间: 2022/6/23 22:41def sum_fun_a(*args): a = 0 for n in args: a = a + n return a
# -*- coding: utf-8 -*-# python 全栈# author : a wei # 开发时间: 2022/6/23 22:41def sum_fun_b(*args): def sum_a(): a = 0 for n in args: a = a + n return a return sum_a
Und wir sehen, dass sich die beiden erstellten Methoden nicht gegenseitig beeinflussen, die Adressen und Werte unterschiedlich sind
Die Funktion sum_a ist in der Funktion sum_fun_b definiert, und die interne Funktion sum_a kann auf die Parameter und lokalen Variablen von verweisen externe Funktion sum_fun_b: Wenn sum_fun_b die Funktion sum_a zurückgibt, werden die entsprechenden Parameter und Variablen in der zurückgegebenen Funktion gespeichert, die als Abschluss bezeichnet wird.
2. Schließung
Der Abschluss muss hier drei Bedingungen haben
f1 = sum_fun_b(1, 2, 3, 4, 5)# 此时f为一个对象实例化，并不会直接生成值print(f1()) # 15f2 = sum_fun_b(1, 2, 3, 4, 5)f3 = sum_fun_b(1, 2, 3, 4, 5)print(f2, f3)<function>.sum_a at 0x0000016E1E1EFD30> <function>.sum_a at 0x0000016E1E1EF700>print(id(f2), id(f3))1899067537152 1899067538880</function></function>
# 定义一个函数def fun_a(num_a):# 在函数内部再定义⼀个函数# 并且这个内部函数⽤到了外部的变量，这个函数以及⽤到外部函数的变量及参数叫 闭包
def fun_b(num_b):
print('内嵌函数fun_b的参数是:%s,外部函数fun_a的参数是:%s' % (num_b, num_a))
return num_a + num_b
# 这里返回的就是闭包的结果
return fun_b# 给fun_a函数赋值，这个10就是传参给fun_aret = fun_a(10)# 注意这里的10其实是赋值给fun_bprint(ret(10))# 注意这里的90其实是赋值给fun_bprint(ret(90))Wenn eine Funktion eine Variablendeklaration im lokalen Bereich nicht finden kann, sucht sie danach in der äußeren Funktion. Dies kommt bei Funktionsabschlüssen sehr häufig vor, wird aber in verwendet lokaler Bereich. Wenn Sie nach dem Hinzufügen der Variablen die Zuweisung zu dieser Variablen ändern möchten, wird ein Fehler gemeldet
Code内嵌函数fun_b的参数是:10,外部函数fun_a的参数是:1020内嵌函数fun_b的参数是:90,外部函数fun_a的参数是:10100
Die von nonlocal deklarierte Variable ist keine lokale Variable, keine globalen Variablen, sondern Variablen innerhalb externer verschachtelter Funktionen.
Wenn Sie es aus einer anderen Perspektive betrachten, haben wir dieser Funktion die Funktion zum Aufzeichnen des Funktionsstatus hinzugefügt. Dies kann natürlich auch durch die Deklaration globaler Variablen zur Erhöhung des Funktionsstatus erreicht werden. In diesem Fall treten die folgenden Probleme auf:
""" 三个条件，缺一不可： 1)必须有一个内嵌函数(函数里定义的函数）——这对应函数之间的嵌套 2)内嵌函数必须引用一个定义在闭合范围内(外部函数里)的变量——内部函数引用外部变量 3)外部函数必须返回内嵌函数——必须返回那个内部函数 """
Der Vorteil der Verwendung von
nonlocal besteht darin, dass beim Hinzufügen des Status zur Funktion keine zusätzlichen globalen Variablen hinzugefügt werden müssen, sodass diese Funktion in großer Zahl aufgerufen und mehrere aufgezeichnet werden kann Funktionsstatus gleichzeitig. Jede Funktion ist unabhängig und einzigartig. Tatsächlich gibt es eine andere Methode für diese Funktion: Durch die Definition von __call__ können Sie sie wie eine Funktion in einer Instanz aufrufen. Der Code lautet wie folgt:
"python# python交互环境编辑器 >>> def counter(start=0): count = [start] def incr(): count[0] += 1 return count[0] return incr >>> c1 = counter(5)>>> print(c1()) 6>>> print(c1()) 7>>> c2=counter(50) >>> print(c2()) 51>>> print(c2()) >52>>>
def test(): count = 1 def add(): print(count) count += 1 return add a = test() a()
Traceback (most recent call last): ...... UnboundLocalError: local variable 'count' referenced before assignment
Aber wir wissen, dass interne Funktionen auf externe Funktionsparameter oder -werte verweisen und keine Funktion vollständig zurückgeben, sondern auch einen Wert in einer externen Funktion haben können Sie müssen wissen, was zurückgegeben wird. Die Funktion wird nicht sofort ausgeführt, sondern erst, wenn die Funktion aufgerufen wird.
Schauen Sie sich den Code an: Hier wird eine Funktion fun_a erstellt. Der Parameter fun_list der externen Funktion definiert eine Liste. Während des Durchlaufs verweist die Schleifenfunktion fun_b auf die externe Variable i, um das Rückgabeergebnis zu berechnen und hinzuzufügen Bei jeder Schleife wird eine neue Funktion erstellt und dann alle drei erstellten Funktionen zurückgegeben. Aber die tatsächlichen Ergebnisse sind nicht die 1,4,9, die wir wollen, sondern 9,9,9 Das? # -*- coding: UTF-8 -*- # def test():
# count不是局部变量，介于全局变量和局部变量之间的一种变量，nonlocal标识
count = 1
def add():
nonlocal count
print(count)
count += 1
return count return add
a = test() a() # 1 a() # 2
Nach dem Login kopieren
Das liegt daran, dass die zurückgegebene Funktion auf die Variable i verweist, aber nicht sofort ausgeführt wird. Wenn alle drei Funktionen zurückkehren, ist die Variable i, auf die sie verweisen, zu 3 geworden. Das von jeder unabhängigen Funktion referenzierte Objekt ist dieselbe Variable, aber wenn der Wert zurückgegeben wird und alle drei Funktionen zurückkehren, ist der Wert Der Vorgang ist abgeschlossen und Wenn die Funktion aufgerufen wird, wird der generierte Wert nicht das erreichen, was Sie möchten. Die Rückgabefunktion sollte keine Schleifenvariablen oder Variablen referenzieren, die sich in Zukunft ändern werden.
Wir können es lösen, indem wir den Wert von i hier _ zuweisen
def test3(): func_list = [] for i in range(1, 4): def test4(i_= i): return i_**2 func_list.append(test4) return func_list f1, f2, f3 = test3()print(f1(), f2(), f3())
可以再创建一个函数，用该函数的参数绑定循环变量当前的值，无论该循环变量后续如何更改，已绑定到函数参数的值不变，那我们就可以完成下面的代码
# -*- coding: UTF-8 -*- # def fun_a(): def fun_c(i): def fun_b(): return i * i return fun_b fun_list = [] for i in range(1, 4): # f(i)立刻被执行，因此i的当前值被传入f() fun_list.append(fun_c(i)) return fun_list f1, f2, f3 = fun_a() print(f1(), f2(), f3()) # 1 4 9
什么是装饰器？
看一段代码：
# -*- coding: utf-8 -*-# python 全栈# author : a wei # 开发时间: 2022/6/24 17:03def eat():
print('吃饭')def test1(func):
def test2():
print('做饭')
func()
print('洗碗')
return test2
eat() # 调用eat函数# 吃饭test1(eat)()# 做饭# 吃饭# 洗碗由于函数也是一个对象，而且函数对象可以被赋值给变量，所以，通过变量也能调用该函数。也可以将函数赋值变量，做参传入另一个函数。
""" 装饰器本质上是一个Python函数，它可以让其他函数在不需要做任何代码变动的前提下增加额外功能，装饰器的返回值 也是一个函数对象。 它经常用于有以下场景，比如：插入日志、性能测试、事务处理、缓存、权限校验等场景。装饰器是解决这类问题的绝 佳设计 """
装饰器的作用就是为已经存在的对象添加额外的功能
先看代码：
# -*- coding: utf-8 -*-# python 全栈# author : a wei # 开发时间: 2022/6/24 17:03def test1(func):
def test2():
print('做饭')
func()
print('洗碗')
return test2@test1 # 装饰器def eat():
print('吃饭')eat()# 做饭# 吃饭# 洗碗我们没有直接将eat函数作为参数传入test1中，只是将test1函数以@方式装饰在eat函数上。
也就是说，被装饰的函数，函数名作为参数，传入到装饰器函数上，不影响eat函数的功能，再此基础上可以根据业务或者功能增加条件或者信息。
(注意：@在装饰器这里是作为Python语法里面的语法糖写法，用来做修饰。)
但是我们这里就存在一个问题这里引入魔术方法 name 这是属于 python 中的内置类属性，就是它会天生就存在与一个 python 程序中，代表对应程序名称，一般一段程序作为主线运行程序时其内置名称就是 main ,当自己作为模块被调用时就是自己的名字
代码：
print(eat.__name__)# test2
这并不是我们想要的！输出应该是" eat"。这里的函数被test2替代了。它重写了我们函数的名字和注释文档，那怎么阻止变化呢，Python提供functools模块里面的wraps函数解决了问题
代码：
-*- coding: utf-8 -*-
from functools import wrapsdef test1(func):
@wraps(func)
def test2():
print('做饭')
func()
print('洗碗')
return test2@test1 # 装饰器def eat():
print('吃饭')eat()# 做饭# 吃饭# 洗碗print(eat.__name__)# eat我们在装饰器函数内，作用eat的test2函数上也增加了一个装饰器wraps还是带参数的。
这个装饰器的功能就是不改变使用装饰器原有函数的结构。
我们熟悉了操作，拿来熟悉一下具体的功能实现，我们可以写一个打印日志的功能
# -*- coding: utf-8 -*-# python 全栈# author : a wei # 开发时间: 2022/6/24 17:42import timefrom functools import wrapsdef logger(func):
@wraps(func)
def write_log():
print('[info]--时间:%s' % time.strftime('%Y-%m-%d %H:%M:%S'))
func()
return write_log@loggerdef work():
print('我在工作')work()# [info]--时间:2022-06-24 17:52:11# 我在工作print(work.__name__)#work我们也看到装饰器wraps也是带参数的，那我们是不是也可以定义带参数的装饰器呢，我们可以使用一个函数来包裹装饰器，调入这个参数。
# -*- coding: utf-8 -*-# python 全栈# author : a wei # 开发时间: 2022/6/24 17:42import timefrom functools import wrapsdef logs(func):
@wraps(func)
def write_log(*args, **kwargs):
print('[info]--时间:%s' % time.strftime('%Y-%m-%d %H:%M:%S'))
func(*args, **kwargs)
return write_log@logsdef work():
print('我在工作')@logsdef work2(name1, name2):
print('%s和%s在工作' % (name1, name2))work2('张三', '李四')# [info]--时间:2022-06-24 18:04:04# 张三和李四在工作把日志写入文件
# -*- coding: utf-8 -*-# python 全栈# author : a wei# 开发时间: 2022/6/20 0:06import timefrom functools import wrapsdef logger(file):
def logs(fun):
@wraps(fun)
def write_log(*args, **kwargs):
log = '[info] 时间是:%s' % time.strftime('%Y-%m-%d %H:%M:%S')
print(log)
with open(file, 'a+') as f:
f.write(log)
fun(*args, **kwargs)
return write_log return logs@logger('work.log') # 使用装饰器来给 work函数增加记录日志的功能def work(name, name2): # 1.当前 work可能有多个参数 2.自定义日志文件的名字和位置，记录日志级别
print(f'{name}和{name2}在工作')work('张三', '李四')终端输出：
这里生成里work.log日志文件
里面记录日志
这里我们将带参数的带入进去根据代码流程执行生成了文件并将文件打印进去现在我们有了能用于正式环境的logs装饰器，但当我们的应用的某些部分还比较脆弱时，异常也许是需要更紧急关注的事情。
比方说有时你只想打日志到一个文件。而有时你想把引起你注意的问题发送到一个email，同时也保留
日志，留个记录。
这是一个使用继承的场景，但目前为止我们只看到过用来构建装饰器的函数。
# -*- coding: utf-8 -*-# python 全栈# author : a wei# 开发时间: 2022/6/20 0:06import timefrom functools import wraps# 不使用函数做装饰器，使用类做装饰器class Logs(object):
def __init__(self, log_file='out.log', level='info'):
# 初始化一个默认文件和默认日志级别
self.log_file = log_file
self.level = level def __call__(self, fun): # 定义装饰器，需要一个接受函数
@wraps(fun)
def write_log(name, name2):
log = '[%s] 时间是:%s' % (self.level, time.strftime('%Y-%m-%d %H:%M:%S'))
print(log)
with open(self.log_file, 'a+') as f:
f.write(log)
fun(name, name2)
return write_log@Logs() # 使用装饰器来给 work函数增加记录日志的功能def work(name, name2): # 1.当前 work可能有多个参数 2.自定义日志文件的名字和位置，记录日志级别
print(f'{name}和{name2}在工作')work('张三', '李四') # 调用work函数这个实现有一个优势，在于比嵌套函数的方式更加整洁，而且包裹一个函数还是使用跟以前一样的语法
Python的 functools 模块提供了很多有用的功能，其中一个就是偏函（Partial function）。要注意，这里的偏函数和数学意义上的偏函数不一样。
在介绍函数参数的时候，我们讲到，通过设定参数的默认值，可以降低函数调用的难度。而偏函数也可以做到这一点。
例如：int() 函数可以把字符串转换为整数，当仅传入字符串时， int() 函数默认按十进制转换
>>> int('123') 123但 int() 函数还提供额外的 base 参数，默认值为 10 。如果传入 base 参数，就可以做进制的转换
>>> int('12345', base=8) 5349 >>> int('12345', 16) 74565如果要转换大量的二进制字符串，每次都传入 int(x, base=2) 非常麻烦，于是，我们想到，可以定义一个int2() 的函数，默认把 base=2 传进去：
代码：
# 定一个转换义函数 >>> def int_1(num, base=2):
return int(num, base)
>>> int_1('1000000') 64>>> int_1('1010101') 85把一个函数的某些参数给固定住（也就是设置默认值），返回一个新的函数，调用这个新函数会更简单
继续优化，functools.partial 就是帮助我们创建一个偏函数的，不需要我们自己定义 int_1() ，可以直接使用下面的代码创 建一个新的函数 int_1
# 导入 >>> import functools
# 偏函数处理 >>> int_2 = functools.partial(int, base=2) >>> int_2('1000000') 64>>> int_2('1010101') 85理清了 functools.partial 的作用就是，把一个函数的某些参数给固定住（也就是设置默认值），返回一个新的函数，调用这个新函数会更简单。
注意到上面的新的 int_2 函数，仅仅是把 base 参数重新设定默认值为 2 ，但也可以在函数调用时传入其他值实际上固定了int()函数的关键字参数 base
int2('10010')相当于是：
kw = { base: 2 } int('10010', **kw)当函数的参数个数太多，需要简化时，使用 functools.partial 可以创建一个新的函数，这个新函数可以固定住原函数的部分参数，从而在调用时更简单
【相关推荐：Python3视频教程 】
Das obige ist der detaillierte Inhalt vonBeherrschen Sie Python-Rückgabefunktionen, Schließungen, Dekoratoren und Teilfunktionen in einem Artikel. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!
