Python：带有装饰器的策略模式

Question

I need to create an algorithm which is executed as a sequence of functions chosen at run-time, a bit like the strategy pattern. I want to avoid creating many single method classes (100+), but use simple functions, and assemble them using a decorator.

actions = []

def act(specific_fn):
    actions.append(specific_fn)
    return specific_fn


@act
def specific_fn1():
    print("specific_fn1")

@act
def specific_fn2():
    print("specific_fn2")

def execute_strategy():
    [f() for f in actions]

I have a couple of questions:

1. How can I modify the decorator function act to take the list actions as a parameter, so that it adds the decorated function into the list?
2. How do I use specific_fnX defined in another file? Currently, I just import the file inside the calling function - but that seems odd. Any other options?

Also, any other ideas on implementing this pattern?

Answer 1

This is a pretty good tutorial on using decorators, both with and without arguments. Others may know of others.

The trick is to remember that a decorator is a function call, but when applied to a function definition, it magically replaces the function with the returned result. If you want @my_decorator(my_list) to be a decorator, then my_decorator(my_list) must either return a function or an object with a __call__ method, and that function is then called on called on specific_fn1 .

So yes, you need a function that returns a function that returns a function. Looking at some examples in a tutorial will make this clearer.

As to your second question, you can just call my_decorator(my_list)(specific_fn1) without using a decorator, and then ignorning the result.