Le décorateur en Python est un obstacle pour entrer en Python. Il est là, que vous le franchissiez ou non. Le concept de décorateurs en Python confond souvent les gens, je vais donc aujourd'hui analyser les décorateurs en Python
1. Portée
En python, la portée est divisée en deux types : portée mondiale et portée locale.
La portée globale est la variable et le nom de la fonction définis au niveau du fichier. La portée locale se trouve à l'intérieur de la fonction définie .
Concernant la portée, je dois comprendre deux points : a. Les variables définies localement ne sont pas accessibles globalement. b Les variables définies globalement sont accessibles localement, mais les variables définies globalement ne peuvent pas être modifiées (bien sûr, il existe des méthodes qui peuvent être utilisées). modifié)
Regardons l'exemple suivant :
x = 1 def funx(): x = 10 print(x) # 打印出10 funx() print(x) # 打印出1
S'il n'y a pas de variable définie x localement, alors la fonction En interne, elle recherchera x de l'intérieur vers l'extérieur. S'il n'est pas trouvé, une erreur sera signalée. Les variables globales peuvent être référencées n'importe où dans le fichier, mais les modifications ne peuvent être effectuées globalement que si la variable requise l'est. introuvable localement, il sera recherché en externe et une erreur sera signalée s'il n'est pas trouvé.
2. Fonctions avancées
x = 1
def funx():
print(x) # 打印出1
funx()
print(x) # 打印出1
x = 1
def funx():
def func1():
print(x) # 打印出1
func1()
funx()
print(x) # 打印出1Nous savons que le nom de la fonction pointe en fait vers l'adresse d'un espace mémoire, puisqu'il s'agit d'une adresse, nous pouvons utiliser cette fonctionnalité.
un nom de fonction peut être utilisé comme valeur
b.
def delete(ps):
import os
filename = ps[-1]
delelemetns = ps[1]
with open(filename, encoding='utf-8') as f_read,\
open('tmp.txt', 'w', encoding='utf-8') as f_write:
for line in iter(f_read.readline, ''):
if line != '\n': # 处理非空行
if delelemetns in line:
line = line.replace(delelemetns,'')
f_write.write(line)
os.remove(filename)
os.rename('tmp.txt',filename)
def add(ps):
filename = ps[-1]
addelemetns = ps[1]
with open(filename, 'a', encoding='utf-8') as fp:
fp.write("\n", addelemetns)
def modify(ps):
import os
filename = ps[-1]
modify_elemetns = ps[1]
with open(filename, encoding='utf-8') as f_read, \
open('tmp.txt', 'w', encoding='utf-8') as f_write:
for line in iter(f_read.readline, ''):
if line != '\n': # 处理非空行
if modify_elemetns in line:
line = line.replace(modify_elemetns, '')
f_write.write(line)
os.remove(filename)
os.rename('tmp.txt', filename)
def search(cmd):
filename = cmd[-1]
pattern = cmd[1]
with open(filename, 'r', encoding="utf-8") as f:
for line in f:
if pattern in line:
print(line, end="")
else:
print("没有找到")
dic_func ={'delete': delete, 'add': add, 'modify': modify, 'search': search}
while True:
inp = input("请输入您要进行的操作:").strip()
if not inp:
continue
cmd_1 = inp.split()
cmd = cmd_1[0]
if cmd in dic_func:
dic_func[cmd](cmd_1)
else:
print("Error")def outer():
def inner():
pass
return inner
s = outer()
print(s)
######输出结果为#######
<function outer.<locals>.inner at 0x000000D22D8AB8C8>def index():
print("index func")
def outer(index):
s = index
s()
outer(index)
######输出结果#########
index funcCe qui suit illustre la fonction de fermeture à travers quelques exemples :
Exemple 1 : Ce qui suit définit uniquement une fonction à l'intérieur de la fonction, mais ce n'est pas une fermeture function.
Exemple 2 : Ce qui suit définit une fonction à l'intérieur de la fonction et fait également référence à une variable externe x. Est-ce donc une fonction de fermeture ? 🎜>
En repensant à la définition de la fonction de fermeture, est-ce qu'elle satisfait les deux ? Si vous êtes intelligent, vous devez constater que la seconde n'est pas satisfaite. Oui, la variable x ici est une variable globale, pas une variable qui agit de l'extérieur sur le domaine. Regardons l'exemple suivant :
def outer():
def inner():
print("inner func excuted")
inner() # 调用执行inner()函数
print("outer func excuted")
outer() # 调用执行outer函数
####输出结果为##########
inner func excuted
outer func excuted
Évidemment, l'exemple ci-dessus satisfait aux conditions de la fonction de fermeture. Or, sachez qu’en tant que fonction de fermeture, il doit remplir les deux conditions ci-dessus, dont l’une est indispensable. Cependant, dans des circonstances normales, nous renverrons une valeur à la fonction de fermeture. Ne parlons pas de pourquoi ici. Dans le contenu suivant, vous verrez l'utilisation de cette valeur de retour
x = 1
def outer():
def inner():
print("x=%s" %x) # 引用了一个非inner函数内部的变量
print("inner func excuted")
inner() # 执行inner函数
print("outer func excuted")
outer()
#####输出结果########
x=1
inner func excuted
outer func excuted
Définissons maintenant la fonction de fermeture de manière abstraite. C'est une entité composée d'une fonction et de son environnement de référence associé. Lors de l'implémentation de contraintes profondes, vous devez créer quelque chose qui représente explicitement l'environnement de référence et le regrouper avec le sous-programme approprié, afin que le bundle devienne une fermeture. Dans l'exemple ci-dessus, nous pouvons constater que la fonction de fermeture doit contenir sa propre fonction et une variable externe pour être véritablement appelée fonction de fermeture. Si aucune variable externe n’y est liée, alors la fonction ne peut pas être considérée comme une fonction de fermeture.
def outer():
x = 1
def inner():
print("x=%s" %x)
print("inner func excuted")
inner()
print("outer func excuted")
outer()
#####输出结果#########
x=1
inner func excuted
outer func excuteddef outer():
x = 1
def inner():
print("x=%s" %x)
print("inner func excuted")
print("outer func excuted")
return inner # 返回内部函数名
outer()
Puis fermeture. Que fait la fonction package ? Nous savons clairement que lorsque la fonction de fermeture est définie, elle sera liée à un environnement externe. Tout cela peut être considéré comme une fonction de fermeture, nous pouvons alors utiliser cette fonction de liaison pour compléter certaines fonctions spéciales.
def outer():
x = 1
y = 2
def inner():
print("x= %s" %x)
print("y= %s" %y)
print(inner.closure)
return inner
outer()
######输出结果#######
(<cell at 0x000000DF9EA965B8: int object at 0x000000006FC2B440>, <cell at 0x000000DF9EA965E8: int object at 0x000000006FC2B460>)4. Décorateur
Avec la base ci-dessus, il est facile de comprendre le décorateur
from urllib.request import urlopen
def index(url)
def get()
return urlopen(url).read()
return get
python = index("http://www.python.org") # 返回的是get函数的地址
print(python()) # 执行get函数《并且将返回的结果打印出来
baidu = index("http://www.baidu.com")
print(baidu())a. Décorateur sans argument
Il existe les exemples suivants : nous devons calculer le temps d'exécution du code.import time, random
def index():
time.sleep(random.randrange(1, 5))
print("welcome to index page")根据装饰器的特点，我们不能对index()进行任何修改,而且调用方式也不能变。这时候，我们就可以使用装饰器来完成如上功能.
import time, random
def outer(func): # 将index的地址传递给func
def inner():
start_time = time.time()
func() # fun = index 即func保存了外部index函数的地址
end_time = time.time()
print("运行时间为%s"%(end_time - start_time))
return inner # 返回inner的地址
def index():
time.sleep(random.randrange(1, 5))
print("welcome to index page")
index = outer(index) # 这里返回的是inner的地址，并重新赋值给index
index()但是，有些情况，被装饰的函数需要传递参数进去，有些函数又不需要参数，那么如何来处理这种变参数函数呢？下面来看看有参数装饰器的使用情况.
b.有参装饰器
def outer(func): # 将index的地址传递给func
def inner(*args, **kwargs):
start_time = time.time()
func(*args, **kwargs) # fun = index 即func保存了外部index函数的地址
end_time = time.time()
print("运行时间为%s"%(end_time - start_time))
return inner # 返回inner的地址下面来说说一些其他情况的实例。
如果被装饰的函数有返回值
def timmer(func):
def wrapper(*args,**kwargs):
start_time = time.time()
res=func(*args,**kwargs) #res来接收home函数的返回值
stop_time=time.time()
print('run time is %s' %(stop_time-start_time))
return res
return wrapper
def home(name):
time.sleep(random.randrange(1,3))
print('welecome to %s HOME page' %name)
return 123123123123123123123123123123123123123123这里补充一点,加入我们要执行被装饰后的函数,那么应该是如下调用方式:
home = timmer(home) # 等式右边返回的是wrapper的内存地址,再将其赋值给home，这里的home不在是原来的的那个函数,而是被装饰以后的函数了。像home = timmer(home)这样的写法,python给我们提供了一个便捷的方式------语法糖@.以后我们再要在被装饰的函数之前写上@timmer,它的效果就和home = timmer(home)是一样的。
如果一个函数被多个装饰器装饰,那么执行顺序是怎样的。
import time
import random
def timmer(func):
def wrapper():
start_time = time.time()
func()
stop_time=time.time()
print('run time is %s' %(stop_time-start_time))
return wrapper
def auth(func):
def deco():
name=input('name: ')
password=input('password: ')
if name == 'egon' and password == '123':
print('login successful')
func() #wrapper()
else:
print('login err')
return deco
@auth # index = auth(timmer(index))
@timmer # index = timmer(index)
def index():
time.sleep(3)
print('welecome to index page')
index()实验结果表明,多个装饰器装饰一个函数,其执行顺序是从下往上。
关于装饰器，还有一些高级用法,有兴趣的可以自己研究研究。
Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!
![[Web front-end] Démarrage rapide de Node.js](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
