Python 类模仿 makefile 依赖关系

Question

问：有没有更好的方法可以做到这一点，或者想法本身就是错误的

我有一个处理类，它创建具有多个构造步骤的东西，这样下一个函数取决于前面的函数。

我想要像

makefile

中那样指定依赖项，当依赖项不存在时，构造它。

我目前使用装饰器来实现它，但感觉不是Pythonic。

请看一下

from typing import *
from functools import wraps

def step_method(dependency: Optional[dict[str, Callable]] = None):
    if dependency is None:
        dependency = {}

    def decorator(method):
        @wraps(method)
        def wrapper(self, *args, **kwargs):
            for attr, func in dependency.items():
                if not getattr(self, attr):
                    func(self)
            ret = method(self, *args, **kwargs)
            return ret
        return wrapper
    return decorator

class StepClass:
    def __init__(self, base_val:int):
        self.base_val: int = base_val
        self.a = None
        self.b = []
        self.c = None
        self.d = []
    
    @step_method({})
    def gen_a(self):
        self.a = self.base_val * 2
        
    @step_method({'a': gen_a})
    def create_b(self):
        self.b = [self.a] * 3
        
    @step_method({
        'a': gen_a,
        'b': create_b
    })
    def gen_c(self):
        self.c = sum(self.b) * self.a

    @step_method({'c': gen_c})
    def generate_d(self):
        self.d = list(range(self.c))
        
        
sc = StepClass(10)
sc.base_val = 7   # allow changes before generating starts
sc.b = [1, 2, 3]  # allow dependency value injection
sc.generate_d()
print(sc.a, sc.b, sc.c, sc.d, sep='\n')

我还想知道是否可以自动检测变量的使用情况，并通过预先指定的函数生成它们（如果它们尚不存在）

Answer 1

dict

这样：

class StepClass:
    def __init__(self, base_val):
        self.base_val = base_val
        self._a = self._b = self._c = None

    @property
    def a(self):
        if self._a is None:
            self._a = self.base_val * 2
        return self._a

    @a.setter
    def a(self, value):
        self._a = value

    @property
    def b(self):
        if self._b is None:
            self._b = [self.a] * 3
        return self._b

    @b.setter
    def b(self, value):
        self._b = value

    @property
    def c(self):
        if self._c is None:
            self._c = sum(self.b) * self.a
        return self._c

    @c.setter
    def c(self, value):
        self._c = value

输出：

sc = StepClass(10)
sc.base_val = 7   # allow changes before generating starts
sc.b = [1, 2, 3]  # allow dependency value injection
print(sc.a, sc.b, sc.c, sep='\n')