Ruang nama menyediakan cara untuk mengelakkan konflik nama dalam projek. Setiap ruang nama adalah bebas dan tidak mempunyai hubungan, jadi tidak boleh ada nama pendua dalam satu ruang nama, tetapi ruang nama yang berbeza boleh mempunyai nama pendua tanpa sebarang kesan.
1. Secara amnya terdapat tiga ruang nama:
): menyimpan nama terbina dalam, seperti sebagai len/eval/enumerate/bytes/max/min/sorted/map/filter....
: Nama yang ditakrifkan dalam modul merekodkan pembolehubah modul, termasuk fungsi, kelas, modul lain yang diimport , dan pembolehubah tahap modul dan pemalar.
: Nama di dalam fungsi adalah semua ruang nama tempatan dan nama di dalam fungsi berbeza tidak mengganggu satu sama lain.
2. Susunan carian ruang nama:
NameError: name 'runoob' is not defined。
.
Oleh itu, kami tidak boleh mengakses objek ruang nama dalaman dari ruang nama luar.
Seperti yang ditunjukkan dalam rajah di bawah, nama objek yang sama boleh wujud dalam berbilang ruang nama.
2. Skop:
Dalam Python, pembolehubah program tidak boleh diakses di mana-mana Kebenaran akses bergantung pada tempat pembolehubah diberikan nilai.
Skop pembolehubah menentukan bahagian program yang boleh mengakses nama pembolehubah tertentu.
Terdapat 4 jenis skop dalam Python, iaitu:
: Tahap paling dalam, termasuk pembolehubah setempat, seperti Di dalam fungsi/kaedah.
: Mengandungi pembolehubah bukan tempatan dan bukan global. Contohnya, jika terdapat dua fungsi bersarang, dan fungsi (atau kelas) A mengandungi fungsi B, maka skop dalam A adalah bukan tempatan untuk nama dalam B.
: Lapisan paling luar skrip semasa, seperti pembolehubah global modul semasa.
: Mengandungi pembolehubah/kata kunci terbina dalam, dsb. , dan akhirnya dicari
Jika ia tidak ditemui secara tempatan, ia akan mencarinya secara setempat (seperti penutupan Jika ia tidak menemuinya, ia akan mencarinya secara global, dan kemudian ia akan mencarinya dalam). terbina dalam.
Contoh:
x = 1
def func():
print(x) #10
x = 10
func()Skop terbina dalam dilaksanakan melalui modul standard yang dipanggil builtin, tetapi nama pembolehubah itu sendiri tidak dimasukkan ke dalam bina- dalam skop, jadi fail ini mesti diimport untuk menggunakannya.
Dalam Python3.0, anda boleh menggunakan kod berikut untuk melihat pembolehubah yang dipratakrifkan:
import builtins print(dir(builtins))
Hanya terdapat modul, kelas dan fungsi (def, lambda) akan memperkenalkan skop baharu, blok kod lain (seperti if/elif/else/, try/except, for/while, dsb.) tidak akan memperkenalkan skop baharu, iaitu, nilai yang ditakrifkan dalam pernyataan ini Pembolehubah juga boleh diakses daripada bahagian luar.
Kod berikut: Dalam contoh, pembolehubah msg ditakrifkan dalam blok pernyataan if, tetapi ia masih boleh diakses dari luar. Jika msg ditakrifkan dalam fungsi, ia adalah pembolehubah tempatan dan tidak boleh diakses dari luar.
if True:
msg = 'I am from Runoob'
print(msg)
# 'I am from Runoob'3. Pembolehubah global dan pembolehubah setempat
局部变量只能在其被声明的函数内部访问，而全局变量可以在整个程序范围内访问。调用函数时，所有在函数内声明的变量名称都将被加入到作用域中。
# 作用域注意点
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 calledAtas ialah kandungan terperinci Bagaimana untuk menggunakan ruang nama, skop dan penghias Python?. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!
![[Web front-end] Permulaan pantas Node.js](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
