是否有任何设计模式用于实施抽象类儿童类方法的装饰？

Question

这种情况使我有一个抽象课程和一些儿童课程实施。

class Parent(metaclass=ABCMeta):

    @abstract_method
    def first_method(self, *args, **kwargs):
        raise NotImplementedError()

    @abstract_method
    def second_method(self, *args, **kwargs):
        raise NotImplementedError()


class Child(Parent):

    def first_method(self, *args, **kwargs):
        print('First method of the child class called!')

    def second_method(self, *args, **kwargs):
        print('Second method of the child class called!')

我的目标是制作某种装饰器，该装饰师将用于父母班级的任何孩子的方法。我需要这个，因为每种方法在实际做某事之前都进行了某种准备，并且在父母班级的所有孩子的所有方法中，此准备绝对相同。像：

class Child(Parent):

    def first_method(self, *args, **kwargs):
        print('Preparation!')
        print('First method of the child class called!')

    def second_method(self, *args, **kwargs):
        print('Preparation!')
        print('Second method of the child class called!')

第一件事是使用父类方法实现：只需删除“提高notimplementedError（）”并放置一些功能，然后在我称之为的子类中，例如super（）。 *args，** kwargs）在每种方法的开头。这很好，但是我也想从父方法返回一些数据，当父级方法和儿童方法返回声明中的某些内容时，看起来很奇怪。更不用说我可能想在方法之后做一些后处理工作，因此我需要2个不同的功能：对于执行脚本的开始和之后。

我想到的下一件事是制作元口。 只需在创建课程过程中实现新元类中方法的所有装饰，然后将新生成的数据传递给儿童方法中的数据。

这是最接近我目标的解决方案，但无论如何都感觉不对。因为并不明确地说，某些夸尔格会传递给儿童方法，如果您是该代码的新手，那么您需要进行一些研究以了解其工作原理。我觉得我过度工程左右。

因此，问题是：这些线上是否有任何模式或其他内容来实现此功能？ 也许您可以为我的情况提供更好的建议？ 预先感谢您！

Answer 1

因此，现有模式分开：我不知道这是否具有特定的名称，您需要什么，那将是“模式”是使用“插槽”：就是 - 您记录了被称为特殊名称的方法，被称为执行另一种方法的一部分。然后，此另一种方法执行其设置代码，检查是否存在插槽方法（通常可以按名称识别），请使用简单的简单方法调用来调用它们，即使调用特殊方法，它将运行最专业的版本老虎机处于基础类别，您处于一个较大的班级构建层次结构。

此模式的一个简单示例是Python实例化对象的方式：实际上是使用用于函数调用的相同语法调用类的方式（myClass（））是该类的类（其Metaclass） __调用__方法。 （使用usally 类型.__调用__）。在Python的类型中的代码中。第一个调用，返回到__新的__。自定义元素可以修改__调用__以运行以前，之间或之后的任何代码。

因此，如果这不是Python，那么您所需要的只是将其规定，并记录不应直接调用这些方法，而是通过“入口点”方法来调用这些方法 - 它可以简单地具有“ EP_”前缀。这些将必须在基础上修复并进行硬编码，并且您需要为每个前缀/Postfix代码的每个方法都需要一种。

class Base(ABC):
    def ep_first_method(self, *args, **kw);
        # prefix code...
        ret_val = self.first_method(*args, **kw)
        # postfix code...
        return ret_val

    @abstractmethod
    def first_method(self):
        pass
    
class Child(Base):
    def first_method(self, ...):
        ...

这是Python，更容易添加更多魔术以避免代码重复并保持简洁。

一件事是拥有一个特殊的类，该类别在检测儿童类中的方法时，该方法应称为包装器方法的插槽，如上所述，以自动重命名 方法：这样入口点方法可以具有与儿童方法相同的名称 - 更好的是，一个简单的装饰器可以标记为“入口点”的方法，并且继承甚至对他们有用。

基本上，当构建新类时，我们会检查所有方法：如果其中任何一个在调用层次结构中具有通讯部分，该部分标记为入口点，则将进行重命名。

如果将任何入门点方法作为第二个参数（第一个为self），则更为实用，这是要调用插入的方法的引用。

经过一番摆弄之后：好消息是不需要Custommetaclass- __ Init_subclass __基本类中的特殊方法足以启用装饰器。

坏消息：由于在最终方法上触发了“超级（）”触发的入口点上的重新输入迭代，因此需要在中间类中调用原始方法。我还要注意一些多线程保护措施 - 尽管这不是100％防弹的。

import sys
import threading
from functools import wraps


def entrypoint(func):
    name = func.__name__
    slotted_name = f"_slotted_{name}"
    recursion_control = threading.local()
    recursion_control.depth = 0
    lock = threading.Lock()
    @wraps(func)
    def wrapper(self, *args, **kw):
        slotted_method = getattr(self, slotted_name, None)
        if slotted_method is None:
            # this check in place of abstractmethod errors. It is only raised when the method is called, though
            raise TypeError("Child class {type(self).__name__} did not implement mandatory method {func.__name__}")

        # recursion control logic: also handle when the slotted method calls "super",
        # not just straightforward recursion
        with lock:
            recursion_control.depth += 1
            if recursion_control.depth == 1:
                normal_course = True
            else:
                normal_course = False
        try:
            if normal_course:
                # runs through entrypoint
                result = func(self, slotted_method, *args, **kw)
            else:
                # we are within a "super()" call - the only way to get the renamed method
                # in the correct subclass is to recreate the callee's super, by fetching its
                # implicit "__class__" variable.
                try:
                    callee_super = super(sys._getframe(1).f_locals["__class__"], self)
                except KeyError:
                    # callee did not make a "super" call, rather it likely is a recursive function "for real"
                    callee_super = type(self)
                slotted_method = getattr(callee_super, slotted_name)
                result = slotted_method(*args, **kw)

        finally:
            recursion_control.depth -= 1
        return result

    wrapper.__entrypoint__ = True
    return wrapper


class SlottedBase:
    def __init_subclass__(cls, *args, **kw):
        super().__init_subclass__(*args, **kw)
        for name, child_method in tuple(cls.__dict__.items()):
            #breakpoint()
            if not callable(child_method) or getattr(child_method, "__entrypoint__", None):
                continue
            for ancestor_cls in cls.__mro__[1:]:
                parent_method = getattr(ancestor_cls, name, None)
                if parent_method is None:
                    break
                if not getattr(parent_method, "__entrypoint__", False):
                    continue
                # if the code reaches here, this is a method that
                # at some point up has been marked as having an entrypoint method: we rename it.
                delattr (cls, name)
                setattr(cls, f"_slotted_{name}", child_method)
                break
        # the chaeegs above are inplace, no need to return anything


class Parent(SlottedBase):
    @entrypoint
    def meth1(self, slotted, a, b):
        print(f"at meth 1 entry, with {a=} and {b=}")
        result = slotted(a, b)
        print("exiting meth1\n")
        return result

class Child(Parent):
    def meth1(self, a, b):
        print(f"at meth 1 on Child, with {a=} and {b=}")

class GrandChild(Child):
    def meth1(self, a, b):
        print(f"at meth 1 on grandchild, with {a=} and {b=}")
        super().meth1(a,b)

class GrandGrandChild(GrandChild):
    def meth1(self, a, b):
        print(f"at meth 1 on grandgrandchild, with {a=} and {b=}")
        super().meth1(a,b)

c = Child()
c.meth1(2, 3)


d = GrandChild()
d.meth1(2, 3)

e = GrandGrandChild()
e.meth1(2, 3)