大家好呀，我是阿潘。
首先，每个开发人员的目标都是让事情正常进行。慢慢地，我们担心可读性和可扩展性。这是我们第一次开始考虑装饰器的时候。
装饰器是为函数提供额外行为的绝佳方式。
使用装饰器，你会惊讶地发现可以减少代码重复并提高可读性。
以下是我在几乎每个数据密集型项目中使用的五个最常用的方法。
1.重试装饰器
在数据科学项目和软件开发项目中，有很多我们依赖外部系统的情况。事情并不总是在我们的控制之中。
当意外事件发生时，我们可能希望我们的代码等待一段时间，让外部系统自行纠正并重新运行。
我更喜欢在 python 装饰器中实现这个重试逻辑，这样我就可以注释任何函数来应用重试行为。
这是重试装饰器的代码。
import time
from functools import wraps
def retry(max_tries=3, delay_seconds=1):
def decorator_retry(func):
@wraps(func)
def wrapper_retry(*args, **kwargs):
tries = 0
while tries < max_tries:
try:
return func(*args, **kwargs)
except Exception as e:
tries += 1
if tries == max_tries:
raise e
time.sleep(delay_seconds)
return wrapper_retry
return decorator_retry
@retry(max_tries=5, delay_seconds=2)
def call_dummy_api():
response = requests.get("https://jsonplaceholder.typicode.com/todos/1")
return response
在上面的代码中，我们尝试获取 API 响应。如果失败，我们将重试相同的任务 5 次。在每次重试之间，我们等待 2 秒。
2.缓存函数结果
我们代码库的某些部分很少改变它们的行为。然而，它可能会占用我们很大一部分计算能力。在这种情况下，我们可以使用装饰器来缓存函数调用。
如果输入相同，该函数将只运行一次。在随后的每次运行中，结果将从缓存中提取。因此，我们不必一直执行昂贵的计算。
def memoize(func):
cache = {}
def wrapper(*args):
if args in cache:
return cache[args]
else:
result = func(*args)
cache[args] = result
return result
return wrapper
装饰器使用字典，存储函数参数，并返回值。当我们执行此功能时，装饰器将检查字典中的先前结果。只有在之前没有存储值时才会调用实际函数。
下面是一个计算斐波那契数列的函数。由于这是一个循环函数，所以调用的同一个函数会执行多次。但是通过缓存，我们可以加快这个过程。
@memoize
def fibonacci(n):
if n <= 1:
return n
else:
return fibonacci(n-1) + fibonacci(n-2)
以下是使用和不使用缓存时此函数的执行时间。请注意，缓存版本只需要几分之一毫秒即可运行，而非缓存版本几乎需要一分钟。
Function slow_fibonacci took 53.05560088157654 seconds to run.
Function fast_fibonacci took 7.772445678710938e-05 seconds to run.
使用字典来保存以前的执行数据是一种直接的方法。但是，有一种更复杂的方法来存储缓存数据。您可以使用内存数据库，例如 Redis。
3.计时功能
这一点并不奇怪。在处理数据密集型函数时，我们渴望了解运行需要多长时间。
通常的做法是收集两个时间戳，一个在函数的开头，另一个在函数的结尾。然后我们可以计算持续时间并将其与返回值一起打印。
但是一次又一次地为多个函数这样做是一件麻烦事。
相反，我们可以让装饰者来做。我们可以注释任何需要打印持续时间的函数。
这是一个 Python 装饰器示例，它在调用函数时打印函数的运行时间：
import time
def timing_decorator(func):
def wrapper(*args, **kwargs):
start_time = time.time()
result = func(*args, **kwargs)
end_time = time.time()
print(f"Function {func.__name__} took {end_time - start_time} seconds to run.")
return result
return wrapper
您可以使用此装饰器来计时函数的执行：
@timing_decorator
def my_function():
# some code here
time.sleep(1) # simulate some time-consuming operation
return
调用该函数将打印运行所需的时间。
my_function()
>>> Function my_function took 1.0019128322601318 seconds to run.
4.记录函数调用这个在很大程度上是前一个装饰器的扩展。但它有一些特殊用途。
如果您遵循软件设计原则，您会喜欢单一职责原则。这实质上意味着每个功能将承担其唯一的责任。
当您以这种方式设计代码时，您还希望记录函数的执行信息。这就是日志装饰器派上用场的地方。
下面的例子说明了这一点。
import logging
import functools
logging.basicConfig(level=logging.INFO)
def log_execution(func):
@functools.wraps(func)
def wrapper(*args, **kwargs):
logging.info(f"Executing {func.__name__}")
result = func(*args, **kwargs)
logging.info(f"Finished executing {func.__name__}")
return result
return wrapper
@log_execution
def extract_data(source):
# extract data from source
data = ...
return data
@log_execution
def transform_data(data):
# transform data
transformed_data = ...
return transformed_data
@log_execution
def load_data(data, target):
# load data into target
...
def main():
# extract data
data = extract_data(source)
# transform data
transformed_data = transform_data(data)
# load data
load_data(transformed_data, target)
上面的代码是 ETL 管道的简化版本。我们有三个独立的函数来处理每个提取、转换和加载。我们已经使用我们的 log_execution 装饰器包装了它们中的每一个。
现在，无论何时执行代码，您都会看到类似这样的输出：
INFO:root:Executing extract_data
INFO:root:Finished executing extract_data
INFO:root:Executing transform_data
INFO:root:Finished executing transform_data
INFO:root:Executing load_data
INFO:root:Finished executing load_data
我们还可以在这个装饰器中打印执行时间。但我希望将它们都放在不同的装饰器中。这样，我就可以选择将哪一个（或两者）用于一个函数。
以下是如何在单个函数上使用多个装饰器。
@log_execution
@timing_decorator
def my_function(x, y):
time.sleep(1)
return x + y
5.通知装饰器
最后，生产系统中一个非常有用的装饰器是通知装饰器。
再一次，即使重试几次，即使是经过良好测试的代码库也会失败。当发生这种情况时，我们需要通知相关人员以迅速采取行动。
如果您曾经构建过数据管道并希望它能永远正常工作，那么这并不是什么新鲜事。
每当内部函数执行失败时，以下装饰器都会发送一封电子邮件。在您的案例中，它不一定是电子邮件通知。您可以将其配置为发送 Teams/slack 通知。
import smtplib
import traceback
from email.mime.text import MIMEText
def email_on_failure(sender_email, password, recipient_email):
def decorator(func):
def wrapper(*args, **kwargs):
try:
return func(*args, **kwargs)
except Exception as e:
# format the error message and traceback
err_msg = f"Error: {str(e)}\n\nTraceback:\n{traceback.format_exc()}"
# create the email message
message = MIMEText(err_msg)
message['Subject'] = f"{func.__name__} failed"
message['From'] = sender_email
message['To'] = recipient_email
# send the email
with smtplib.SMTP_SSL('smtp.gmail.com', 465) as smtp:
smtp.login(sender_email, password)
smtp.sendmail(sender_email, recipient_email, message.as_string())
# re-raise the exception
raise
return wrapper
return decorator
@email_on_failure(sender_email='your_email@gmail.com', password='your_password', recipient_email='recipient_email@gmail.com')
def my_function():
# code that might fail
结论装饰器是将新行为应用于我们的函数的一种非常方便的方法。没有它们，就会有很多代码重复。
在这篇文章中，我讨论了我最常用的装饰器。您可以根据您的特定需求扩展这些。例如，您可以使用 Redis 服务器来存储缓存响应而不是字典。这将使您能够更好地控制数据，例如持久性。或者您可以调整代码以逐步增加重试装饰器中的等待时间。
在我所有的项目中，我都使用了这些装饰器的某些版本。尽管它们的行为略有不同，但这些是我经常使用装饰器的共同目标。
我希望这篇文章对你有所帮助。
本篇文章翻译自：https://towardsdatascience.com/python-decorators-for-data-science-6913f717669a
