共计 6669 个字符,预计需要花费 17 分钟才能阅读完成。
提到元这个字,你兴许会想到元数据,元数据就是形容数据自身的数据,元类就是类的类,相应的元编程就是形容代码自身的代码,元编程就是对于创立操作源代码 (比方批改、生成或包装原来的代码) 的函数和类。次要技术是应用装璜器、元类、描述符类。
本文的次要目标是向大家介绍这些元编程技术,并且给出实例来演示它们是怎么定制化源代码的行为。
装璜器
装璜器就是函数的函数,它承受一个函数作为参数并返回一个新的函数,在不扭转原来函数代码的状况下为其减少新的性能,比方最罕用的计时装璜器:
from functools import wraps
def timeit(logger=None):
"""耗时统计装璜器,单位是秒,保留 4 位小数"""
def decorator(func):
@wraps(func)
def wrapper(*args, **kwargs):
start = time.time()
result = func(*args, **kwargs)
end = time.time()
if logger:
logger.info(f"{func.__name__} cost {end - start :.4f} seconds")
else:
print(f"{func.__name__} cost {end - start :.4f} seconds")
return result
return wrapper
return decorator
(注:比方下面应用 @wraps(func)
注解是很重要的,它能保留原始函数的元数据) 只须要在原来的函数下面加上 @timeit()
即可为其减少新的性能:
@timeit()
def test_timeit():
time.sleep(1)
test_timeit()
#test_timeit cost 1.0026 seconds
下面的代码跟上面这样写的成果是一样的:
test_timeit = timeit(test_timeit)
test_timeit()
装璜器的执行程序
当有多个装璜器的时候,他们的调用程序是怎么样的?
如果有这样的代码,请问是先打印 Decorator1 还是 Decorator2 ?
from functools import wraps
def decorator1(func):
@wraps(func)
def wrapper(*args, **kwargs):
print('Decorator 1')
return func(*args, **kwargs)
return wrapper
def decorator2(func):
@wraps(func)
def wrapper(*args, **kwargs):
print('Decorator 2')
return func(*args, **kwargs)
return wrapper
@decorator1
@decorator2
def add(x, y):
return x + y
add(1,2)
# Decorator 1
# Decorator 2
答复这个问题之前,我先给你打个形象的比喻,装璜器就像函数在穿衣服,离它最近的最先穿,离得远的最初穿,上例中 decorator1 是外套,decorator2 是内衣。
add = decorator1(decorator2(add))
在调用函数的时候,就像脱衣服,先解除最里面的 decorator1,也就是先打印 Decorator1,执行到 return func(*args, **kwargs)
的时候会去解除 decorator2,而后打印 Decorator2,再次执行到 return func(*args, **kwargs)
时会真正执行 add()
函数。
须要留神的是打印的地位,如果打印字符串的代码位于调用函数之后,像上面这样,那输入的后果正好相同:
def decorator1(func):
@wraps(func)
def wrapper(*args, **kwargs):
result = func(*args, **kwargs)
print('Decorator 1')
return result
return wrapper
def decorator2(func):
@wraps(func)
def wrapper(*args, **kwargs):
result = func(*args, **kwargs)
print('Decorator 2')
return result
return wrapper
装璜器不仅能够定义为函数,也能够定义为类,只有你确保它实现了__call__()
和 __get__()
办法。
元类
Python 中所有类(object)的元类,就是 type
类,也就是说 Python 类的创立行为由默认的 type
类管制,打个比喻,type
类是所有类的先人。咱们能够通过编程的形式来实现自定义的一些对象创立行为。
定一个类继承 type
类 A,而后让其余类的元类指向 A,就能够管制 A 的创立行为。典型的就是应用元类实现一个单例:
class Singleton(type):
def __init__(self, *args, **kwargs):
self._instance = None
super().__init__(*args, **kwargs)
def __call__(self, *args, **kwargs):
if self._instance is None:
self._instance = super().__call__(*args, **kwargs)
return self._instance
else:
return self._instance
class Spam(metaclass=Singleton):
def __init__(self):
print("Spam!!!")
元类 Singleton 的 __init__
和__new__
办法会在定义 Spam 的期间被执行,而 __call__
办法会在实例化 Spam 的时候执行。
descriptor 类(描述符类)
descriptor 就是任何一个定义了 __get__()
,__set__()
或 __delete__()
的对象,形容器让对象可能自定义属性查找、存储和删除的操作。这里举官网文档 [1] 一个自定义验证器的例子。
定义验证器类,它是一个描述符类,同时还是一个抽象类:
from abc import ABC, abstractmethod
class Validator(ABC):
def __set_name__(self, owner, name):
self.private_name = '_' + name
def __get__(self, obj, objtype=None):
return getattr(obj, self.private_name)
def __set__(self, obj, value):
self.validate(value)
setattr(obj, self.private_name, value)
@abstractmethod
def validate(self, value):
pass
自定义验证器须要从 Validator 继承,并且必须提供 validate() 办法以依据须要测试各种束缚。
这是三个实用的数据验证工具:
OneOf 验证值是一组受约束的选项之一。
class OneOf(Validator):
def __init__(self, *options):
self.options = set(options)
def validate(self, value):
if value not in self.options:
raise ValueError(f'Expected {value!r} to be one of {self.options!r}')
Number 验证值是否为 int 或 float。依据可选参数,它还能够验证值在给定的最小值或最大值之间。
class Number(Validator):
def __init__(self, minvalue=None, maxvalue=None):
self.minvalue = minvalue
self.maxvalue = maxvalue
def validate(self, value):
if not isinstance(value, (int, float)):
raise TypeError(f'Expected {value!r} to be an int or float')
if self.minvalue is not None and value < self.minvalue:
raise ValueError(f'Expected {value!r} to be at least {self.minvalue!r}'
)
if self.maxvalue is not None and value > self.maxvalue:
raise ValueError(f'Expected {value!r} to be no more than {self.maxvalue!r}'
)
String 验证值是否为 str。依据可选参数,它能够验证给定的最小或最大长度。它还能够验证用户定义的 predicate。
class String(Validator):
def __init__(self, minsize=None, maxsize=None, predicate=None):
self.minsize = minsize
self.maxsize = maxsize
self.predicate = predicate
def validate(self, value):
if not isinstance(value, str):
raise TypeError(f'Expected {value!r} to be an str')
if self.minsize is not None and len(value) < self.minsize:
raise ValueError(f'Expected {value!r} to be no smaller than {self.minsize!r}'
)
if self.maxsize is not None and len(value) > self.maxsize:
raise ValueError(f'Expected {value!r} to be no bigger than {self.maxsize!r}'
)
if self.predicate is not None and not self.predicate(value):
raise ValueError(f'Expected {self.predicate} to be true for {value!r}'
)
理论利用时这样写:
class Component:
name = String(minsize=3, maxsize=10, predicate=str.isupper)
kind = OneOf('wood', 'metal', 'plastic')
quantity = Number(minvalue=0)
def __init__(self, name, kind, quantity):
self.name = name
self.kind = kind
self.quantity = quantity
形容器阻止有效实例的创立:
>>> Component('Widget', 'metal', 5) # Blocked: 'Widget' is not all uppercase
Traceback (most recent call last):
...
ValueError: Expected <method 'isupper' of 'str' objects> to be true for 'Widget'
>>> Component('WIDGET', 'metle', 5) # Blocked: 'metle' is misspelled
Traceback (most recent call last):
...
ValueError: Expected 'metle' to be one of {'metal', 'plastic', 'wood'}
>>> Component('WIDGET', 'metal', -5) # Blocked: -5 is negative
Traceback (most recent call last):
...
ValueError: Expected -5 to be at least 0
>>> Component('WIDGET', 'metal', 'V') # Blocked: 'V' isn't a number
Traceback (most recent call last):
...
TypeError: Expected 'V' to be an int or float
>>> c = Component('WIDGET', 'metal', 5) # Allowed: The inputs are valid
最初的话
对于 Python 的元编程,总结如下:
如果心愿某些函数领有雷同的性能,心愿不扭转原有的调用形式、不写反复代码、易保护,能够应用装璜器来实现。
如果心愿某一些类领有某些雷同的个性,或者在类定义实现对其的管制,咱们能够自定义一个元类,而后让它类的元类指向该类。
如果心愿实例的属性领有某些独特的特点,就能够自定义一个描述符类。
以上就是本次分享的所有内容,如果你感觉文章还不错,欢送关注公众号:Python 编程学习圈,每日干货分享,发送“J”还可支付大量学习材料。或是返回编程学习网,理解更多编程技术常识。