Maison > Article > développement back-end > Comment utiliser les espaces de noms, les portées et les décorateurs de Python ?
Comment utiliser les espaces de noms, les portées et les décorateurs de Python ?
- PHPzavant
- 2023-05-09 19:04:17739parcourir
1. Espace de noms et portée
1 Espace de noms (espace de noms)
L'espace de noms est un mappage des noms aux objets. La plupart des espaces de noms sont implémentés via des dictionnaires Python.
Les espaces de noms permettent d'éviter les conflits de noms dans les projets. Chaque espace de noms est indépendant et n'a aucune relation. Il ne peut donc pas y avoir de noms en double dans un espace de noms, mais différents espaces de noms peuvent avoir des noms en double sans aucun impact.
1 Le nom enregistre les variables du module, y compris les fonctions, les classes, les autres modules importés, les variables et constantes au niveau du module.- Espace de noms local
(noms locaux) : Les noms à l'intérieur de la fonction sont tous des espaces de noms locaux, et les noms à l'intérieur des différentes fonctions n'interfèrent pas les uns avec les autres.
len/eval/enumerate/bytes/max/min/sorted/map/filter.... -
2. Ordre de recherche de l'espace de noms :
Si la variable runoob n'est pas trouvée, elle abandonnera la recherche et déclenchera une exception NameError :
NameError: name 'runoob' is not defined。
Ordre de recherche : Supposons que nous voulions utiliser la variable runoob, puis Python L'ordre de recherche est le suivant : Allez dans l'espace de noms local -> espace de noms global -> espace de noms intégré
.
Ordre d'exécution : Intégré en premier (sera généré au démarrage de l'interpréteur Python) -> Global (sera généré lors de l'exécution du fichier) ->
- Ainsi, nous ne pouvons pas accéder aux objets de l'espace de noms interne à partir de l'espace de noms externe.
Comme le montre la figure ci-dessous, le même nom d'objet peut exister dans plusieurs espaces de noms.
2. Scope :
Scope est la zone du corps d'un espace de noms à laquelle un programme Python peut accéder directement.
En Python, les variables du programme ne sont pas accessibles partout. Les autorisations d'accès dépendent de l'endroit où la variable reçoit une valeur.
La portée d'une variable détermine quelle partie du programme peut accéder à quel nom de variable spécifique.
Python a 4 types de portées, qui sont : 
L (Local)
: La couche la plus interne, y compris les variables locales, comme à l'intérieur d'une fonction/méthode.
E (Enclosing)
: Contient des variables non locales et non globales. Par exemple, s’il existe deux fonctions imbriquées et qu’une fonction (ou classe) A contient une fonction B, alors la portée dans A n’est pas locale pour le nom dans B.- G (Global)
- : La couche la plus externe du script actuel, telle que les variables globales du module actuel.
- : Contient des variables/mots-clés intégrés, etc. , et enfin recherché
Pour la portée des variables, l'accès aux variables est recherché selon les règles de :
L –> E –> S'il ne peut pas être trouvé localement, il le recherchera localement (comme les fermetures). S'il ne le trouve pas, il le recherchera globalement, puis il le recherchera dans le module intégré.
Exemple :
x = 1 def func(): print(x) #10 x = 10 func()La portée intégrée est implémentée via un module standard appelé intégré, mais le nom de la variable lui-même n'est pas placé dans la portée intégrée, ce fichier doit donc être importé pour l'utiliser. En Python3.0, vous pouvez utiliser le code suivant pour voir quelles variables sont prédéfinies :
import builtins print(dir(builtins))
En Python, seuls les modules, classes et fonctions (def, lambda) introduiront de nouvelles fonctions Domain, d'autres blocs de code (comme si /elif/else/, try/sauf, for/while, etc.) n'introduira pas de nouveaux scopes, ce qui signifie que les variables définies dans ces instructions sont également accessibles de l'extérieur, Le code suivant : Dans l'exemple, la variable msg est définie dans le bloc d'instruction if, mais elle est toujours accessible de l'extérieur. Si msg est défini dans une fonction, il s'agit d'une variable locale et n'est pas accessible de l'extérieur.
if True:
msg = 'I am from Runoob'
print(msg)
# 'I am from Runoob'3. Variables globales et variables locales
Les variables définies à l'intérieur de la fonction ont une portée locale et les variables définies en dehors de la fonction ont une portée globale. 
局部变量只能在其被声明的函数内部访问，而全局变量可以在整个程序范围内访问。调用函数时，所有在函数内声明的变量名称都将被加入到作用域中。
# 作用域注意点
x = 1
def f1(): # 定义阶段x=1
print(x) #1
def f2():
x = 2 #此x为f2函数的局部变量，f1无法直接访问
f1()
f2()4、函数对象+作用域应用
def f1():
def inner():
print('from inner')
return inner
f = f1() # from inner 。把局部定义的函数inner()放在全局之中
def bar():
f()
bar()5、global关键字修改全局作用域中的变量
函数内可以访问全局变量，但不能直接更新(修改)其值，可以加上 global 引用以更新变量值 :
x = 1
def f1():
x = 2
def f2():
global x # 修改全局
x = 3
f2()
f1()
print(x) # 36、nonlocal关键字修改嵌套作用域中的变量。
如果要修改嵌套作用域（enclosing 作用域，外层非全局作用域）中的变量则需要 nonlocal 关键字了
x = 1
def f1():
x = 2
def f2():
nonlocal x
x = 3
f2()
print(x) # 3
f1()二、闭包函数
闭包：闭是封闭（函数内部函数），包是包含（该内部函数对外部作用域而非全局作用域的变量的引用）。
闭包指的是：函数内部函数对外部作用域而非全局作用域的引用。
def outter(x):
x = 1
def inner():
print(x)
return inner #返回的是函数名（函数对象）
f = outter(2)
f() # 1
f() # 1
f() # 1
# 查看闭包的元素
print(f.__closure__[0].cell_contents) # 1闭包的意义：返回的函数对象，不仅仅是一个函数对象，在该函数外还包裹了一层作用域，这使得，该函数无论在何处调用，优先使用自己外层包裹的作用域。
应用领域：
延迟计算（原来我们是传参，现在我们是包起来）、爬虫领域。
import requests
def outter(url):
def get():
response = requests.get(url)
print(f"done: {url}")
return get
baidu = outter('https://www.baidu.com')
python = outter('https://www.python.org')
baidu()
baidu()
python()
python()三、函数装饰器
装饰器指的是为被装饰器对象添加额外功能。因此定义装饰器就是定义一个函数，只不过该函数的功能是用来为其他函数添加额外的功能。装饰器的实现必须遵循两大原则：
不修改被装饰对象的源代码
不修改被装饰对象的调用方式
装饰器其实就是在遵循以上两个原则的前提下为被装饰对象添加新功能。
不改变函数体代码，并且不改变函数调用方式，它本质就是一个闭包函数。
def f1(x):
def f2():
print(x) # 10
return f2
f2 = f1()
f2() # f2()在不改变当前函数的情况下, 给其增加新的功能:
def log(pr): # 将被装饰函数传入
def wrapper():
print("**********")
return pr() # 执行被装饰的函数
return wrapper # 将装饰完之后的函数返回（返回的是函数名）
@log
def pr():
print("我是小小洋")
pr()
# **********
# 我是小小洋回调函数和返回函数的实例就是装饰器。
四、无参装饰器
举例：
import time
def index():
print('welcome to index')
time.sleep(1)
def time_count(func):
# func = 最原始的index
def wrapper():
start = time.time()
func()
end = time.time()
print(f"{func} time is {start - end}") # time is -1.0038220882415771
return wrapper
index = time_count(index) # index为被装饰函数index的内存地址，即index = wrapper
index() # wrapper()1、被装饰函数有返回值：
如果原始的被装饰函数index()有返回值的时候，wrapper()函数的返回值应该和index()的返回值相同，也就是说，我们需要同步原始的index()和wrapper()方法的返回值。
import time
def index():
print('welcome to index')
time.sleep(1)
return 123
def time_count(func):
# func = 最原始的index
def wrapper():
start = time.time()
res1 = func()
end = time.time()
print(f"{func} time is {start - end}") # time is -1.0050289630889893
return res1
return wrapper
index = time_count(index)
res = index()
print(f"res: {res}") #
res: 1232、被装饰函数需要传参：
如果原始的被装饰函数index()方法需要传参，那么我们之前的装饰器是无法实现该功能的，由于有wrapper()=index()，所以给wrapper()方法传参即可。
import time
def index():
print('welcome to index')
time.sleep(1)
return 123
def home(name):
print(f"welcome {name} to home page")
time.sleep(1)
return name
def time_count(func):
def wrapper(*args, **kwargs):
start = time.time()
res = func(*args, **kwargs)
end = time.time()
print(f"{func} time is {start-end}") # time is -1.0039079189300537
return res
return wrapper
home = time_count(home)
res = home('egon')
print(f"res: {res}") #res: egon3、装饰器模板
def deco(func):
def wrapper(*args,**kwargs):
res = func(*args,**kwargs)
return res
return wrapper4、装饰器语法糖:
在被装饰函数正上方，并且是单独一行写上@装饰器名
import time
def time_count(func): #装饰器
# func = 最原始的index
def wrapper(*args, **kwargs):
start = time.time()
res = func(*args, **kwargs)
end = time.time()
print(f"{func} time is {start-end}") # time is -1.0005171298980713
return res
return wrapper
@time_count # home = time_count(home)
def home(name):
print(f"welcome {name} to home page") #welcome egon to home page
time.sleep(1)
return name
res = home('egon')
print(f"res: {res}") #res: egon五、带参数的装饰器
注意无参装饰器只套两层。
import time
current_user = {'username': None}
def login(func):
# func = 最原始的index
def wrapper(*args, **kwargs):
if current_user['username']:
res1 = func(*args, **kwargs)
return res1
user = input('username: ').strip()
pwd = input('password: ').strip()
if user == 'nick' and pwd == '123':
print('login successful')
current_user['username'] = user
res1 = func(*args, **kwargs)
return res1
else:
print('user or password error')
return wrapper
@login
def index():
print('welcome to index')
time.sleep(1)
res = index()
#username: nick
#password: 123
#login successful
#welcome to index我们首先看看三层闭包怎么运用。
def f1(y):
def f2():
x = 1
def f3():
print(f"x: {x}") # x: 1
print(f"y: {y}") # x: 1
return f3
return f2
f2 = f1(2)
f3 = f2()
f3()3、有参三层装饰器:
在函数中嵌入装饰器
import time
current_user = {'username': None}
def auth(engine='file'):
def login(func):
def wrapper(*args, **kwargs):
if current_user['username']:
res = func(*args, **kwargs)
return res
user = input('username: ').strip()
pwd = input('password: ').strip()
if engine == 'file':
print('base of file')
if user == 'nick' and pwd == '123':
print('login successful')
current_user['username'] = user
res = func(*args, **kwargs)
return res
else:
print('user or password error')
elif engine == 'mysql':
print('base of mysql, please base of file')
return wrapper
return login
@auth(engine='file')
def index():
print('welcome to index')
time.sleep(1)
res = index()username: nick
password: 123
base of file
login successful
welcome to index
六、类装饰器
没错，装饰器不仅可以是函数，还可以是类，相比函数装饰器，类装饰器具有灵活度大、高内聚、封装性等优点。使用类装饰器主要依靠类的__call__方法，当使用 @ 形式将装饰器附加到函数上时，就会调用此方法。
class Foo(object):
def __init__(self, func):
self._func = func
def __call__(self):
print ('class decorator runing')
self._func()
print ('class decorator ending')
@Foo
def bar():
print ('bar')
bar()
functools.wraps使用装饰器极大地复用了代码，但是他有一个缺点就是原函数的元信息不见了，比如函数的docstring、__name__、参数列表，先看例子：
# 装饰器
def logged(func):
def with_logging(*args, **kwargs):
print func.__name__ # 输出 'with_logging'
print func.__doc__ # 输出 None
return func(*args, **kwargs)
return with_logging
# 函数
@logged
def f(x):
"""does some math"""
return x + x * x
logged(f)不难发现，函数 f 被with_logging取代了，当然它的docstring，__name__就是变成了with_logging函数的信息了。好在我们有functools.wraps，wraps本身也是一个装饰器，它能把原函数的元信息拷贝到装饰器里面的 func 函数中，这使得装饰器里面的 func 函数也有和原函数 foo 一样的元信息了。
from functools import wraps
def logged(func):
@wraps(func)
def with_logging(*args, **kwargs):
print func.__name__ # 输出 'f'
print func.__doc__ # 输出 'does some math'
return func(*args, **kwargs)
return with_logging
@logged
def f(x):
"""does some math"""
return x + x * x七、装饰器顺序
一个函数还可以同时定义多个装饰器，比如：
@a
@b
@c
def f ():
pass它的执行顺序是从里到外，最先调用最里层的装饰器，最后调用最外层的装饰器，它等效于
f = a(b(c(f)))
八、装饰器使用场景
现在我们来看一下装饰器在哪些地方特别耀眼，以及使用它可以让一些事情管理起来变得更简单。
授权(Authorization)
装饰器能有助于检查某个人是否被授权去使用一个web应用的端点(endpoint)。它们被大量使用于Flask和Django web框架中。这里是一个例子来使用基于装饰器的授权：
from functools import wraps
def requires_auth(f):
@wraps(f)
def decorated(*args, **kwargs):
auth = request.authorization
if not auth or not check_auth(auth.username, auth.password):
authenticate()
return f(*args, **kwargs)
return decorated日志(Logging)
日志是装饰器运用的另一个亮点。这是个例子：
from functools import wraps
def logit(func):
@wraps(func)
def with_logging(*args, **kwargs):
print(func.__name__ + " was called")
return func(*args, **kwargs)
return with_logging
@logit
def addition_func(x):
"""Do some math."""
return x + x
result = addition_func(4)
# Output: addition_func was calledCe 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!