Python在重写方法中访问父类的“ with”语句

如何解决Python在重写方法中访问父类的“ with”语句

我有一个基类，其方法使用with语句。在子类中，我重写了相同的方法，并希望随后访问相同的with语句（而不是具有两个with语句）。

解决此问题的标准方法是什么？

有关示例和可能的解决方案，请参见下文。

---

样本，使用threading.Lock

from threading import Lock


class BaseClass:
    def __init__(self):
        self.lock = Lock()
        self._data = 0

    def do_something_locked(self) -> None:
        with self.lock:
            self._data += 5


class ChildClass(BaseClass):
    def do_something_locked(self) -> None:
        super().do_something_locked()
        # ObvIoUsly the parent class's self.lock's __exit__ method has 
        # already been called.  What are accepted methods to add more 
        # functionality inside parent class's "with" statement?
        with self.lock:
            self._data += 1

---

可能的解决方案

我的第一个倾向是在BaseClass中定义一个私有方法，如下所示：

    def do_something_locked(self) -> None:
        with self.lock:
            self._do_something()

    def _do_something(self) -> None:
        self._data += 5

然后ChildClass可以覆盖_do_something。这会很好。

我想知道，还有其他解决此问题的常见模式吗？

解决方法

我的第一个倾向是像这样...在BaseClass中定义一个私有方法，然后ChildClass可以覆盖_do_something。这会很好。

这是解决问题的好方法even when you don't have a special requirement（就像需要保留在with块上下文中一样）。我不会在“ hook”方法名称中使用前导下划线，因为从逻辑上讲，您希望在派生类中重写的任何内容都是类接口的一部分。另外，如果self._data += 5部分总是需要发生，则将其保留在do_something_locked中。

还有其他解决此问题的常用模式吗？

针对该问题，您可以使用另一个答案中所示的重入锁。您还可以忽略类之间相关的事实，并使用依赖项注入-在基类中创建一个通用方法，使用锁来接受可调用对象并执行该方法：

# in base class
def do_locked(self,what,*args,**kwargs):
    with self.lock:
        what(*args,**kwargs)

# in derived class
def _implementation(self):
    pass
def do_interesting_thing(self):
    # pass in our own bound method,which takes no arguments
    self._do_locked(self._implementation)

这种方式允许客户端代码以自定义方式使用锁。如果您不需要或不需要该功能，可能不是一个好主意。

,

使用可重入锁。这将自动“连接”嵌套的with语句，仅在最外面的with之后释放锁。

from threading import RLock


class BaseClass:
    def __init__(self):
        self.lock = RLock()
        self._data = 0

    def do_something_locked(self) -> None:
        with self.lock:
            self._data += 5


class ChildClass(BaseClass):
    def do_something_locked(self) -> None:
        with self.lock:
            super().do_something_locked()
            self._data += 1

通常，reentrant context managers模式明确存在以允许可能嵌套的上下文。

这些上下文管理器不仅可以在多个with语句中使用，而且还可以在已经在使用同一上下文管理器的with语句中使用。