命名空間是從名稱到物件的映射，大部分的命名空間都是透過Python 字典來實現的。
命名空間提供了在專案中避免名字衝突的一種方法。各個命名空間是獨立的，沒有任何關係的，所以一個命名空間中不能有重名，但不同的命名空間是可以重名而沒有任何影響。
內建名稱空間（built-in names）：存放內建的名字，如len/eval/enumerate/bytes/max/min/sorted/map/filter....
#全域名稱空間（global names） ：模組中定義的名稱，記錄了模組的變量，包括函數、類別、其它導入的模組、模組級的變數和常數。
局部名稱空間（local names）：函數內部的名字都是局部名稱空間，不同函數內部的名字互不干涉。
如果找不到變數runoob，它將放棄尋找並引發一個NameError 異常:
NameError: name 'runoob' is not defined。
查找順序：假設我們要使用變數runoob，則Python 的查找順序為：局部的命名空間去-> 全域命名空間-> 內建命名空間。
執行順序：先內建（Python解釋器啟動的時候才會產生）-> 全域（檔案執行的時候才會產生）-> 局部（函數呼叫的時候才會產生）
命名空間的生命週期取決於物件的作用域，如果物件執行完成，則該命名空間的生命週期就結束。
因此，我們無法從外部命名空間存取內部命名空間的物件。
如下圖所示，相同的物件名稱可以存在於多個命名空間中。
作用域就是一個 Python 程式可以直接存取命名空間的正文區域。
全域名稱空間和局部名稱空間中可能會存在名字相同的變量，但這兩個變數互不影響。
Python 中，程式的變數並不是在哪個位置都可以存取的，存取權限決定於這個變數是在哪裡賦值的。
變數的作用域決定了在哪一部分程式可以存取哪個特定的變數名稱。
Python的作用域一共有4種，分別是：
L（Local）：最內層，包含局部變量，例如一個函數/方法內部。
E（Enclosing）：包含了非局部(non-local)也非全域(non-global)的變數。例如兩個巢狀函數，一個函數（或類別） A 裡面又包含了一個函數 B ，那麼對於 B 中的名稱來說 A 中的作用域就為 nonlocal。
G（Global）：目前腳本的最外層，例如目前模組的全域變數。
B（Built-in）： 包含了內建的變數/關鍵字等。 ，最後被搜尋
對於變數作用域，變數的存取以： #L –> E –> G –>B 的 規則尋找。
在局部找不到，便會去局部外的局部找（例如閉包），再找不到就會去全域找，再者去內建找。
舉例：
x = 1
def func():
print(x) #10
x = 10
func()內建作用域是透過一個名為builtin 的標準模組來實現的，但是這個變數名稱本身並沒有放入內建作用域內，所以必須匯入這個檔案才能夠使用它。
在Python3.0中，可以使用以下的程式碼來查看到底預先定義了哪些變數:
import builtins print(dir(builtins))
Python 中只有模組（module），類別（class）以及函數（def、 lambda）才會引入新的作用域，其它的程式碼區塊（如if/elif/else/、try/except、for/while等）是不會引入新的作用域的，也就是說這些語句內定義的變量，外部也可以訪問，
如下程式碼：實例中msg 變數定義在if 語句區塊中，但外部還是可以存取的。如果將 msg 定義在函數中，則它是局部變量，外部不能存取。
if True:
msg = 'I am from Runoob'
print(msg)
# 'I am from Runoob'定義在函數內部的變數擁有一個局部作用域，定義在函數外的擁有全域作用域。
局部变量只能在其被声明的函数内部访问，而全局变量可以在整个程序范围内访问。调用函数时，所有在函数内声明的变量名称都将被加入到作用域中。
# 作用域注意点
x = 1
def f1(): # 定义阶段x=1
print(x) #1
def f2():
x = 2 #此x为f2函数的局部变量，f1无法直接访问
f1()
f2()def f1():
def inner():
print('from inner')
return inner
f = f1() # from inner 。把局部定义的函数inner()放在全局之中
def bar():
f()
bar()函数内可以访问全局变量，但不能直接更新(修改)其值，可以加上 global 引用以更新变量值 :
x = 1
def f1():
x = 2
def f2():
global x # 修改全局
x = 3
f2()
f1()
print(x) # 3如果要修改嵌套作用域（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()如果原始的被装饰函数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: 123如果原始的被装饰函数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: egondef deco(func):
def wrapper(*args,**kwargs):
res = func(*args,**kwargs)
return res
return wrapper在被装饰函数正上方，并且是单独一行写上@装饰器名
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()在函数中嵌入装饰器
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)))
现在我们来看一下装饰器在哪些地方特别耀眼，以及使用它可以让一些事情管理起来变得更简单。
装饰器能有助于检查某个人是否被授权去使用一个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日志是装饰器运用的另一个亮点。这是个例子：
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 called以上是如何使用Python的命名空間、作用域和裝飾器？的詳細內容。更多資訊請關注PHP中文網其他相關文章！
