python 策略模式的实现是否应该在 init 方法中使用私有变量？

Question

我正在学习策略设计模式，以及 Python 中的属性装饰器。我遇到了这个例子：

from __future__ import annotations
from abc import ABC, abstractmethod
from typing import List


class Context():
    """
    The Context defines the interface of interest to clients.
    """

    def __init__(self, strategy: Strategy) -> None:
        """
        Usually, the Context accepts a strategy through the constructor, but
        also provides a setter to change it at runtime.
        """

        self._strategy = strategy

    @property
    def strategy(self) -> Strategy:
        """
        The Context maintains a reference to one of the Strategy objects. The
        Context does not know the concrete class of a strategy. It should work
        with all strategies via the Strategy interface.
        """

        return self._strategy

    @strategy.setter
    def strategy(self, strategy: Strategy) -> None:
        """
        Usually, the Context allows replacing a Strategy object at runtime.
        """

        self._strategy = strategy

    def do_some_business_logic(self) -> None:
        """
        The Context delegates some work to the Strategy object instead of
        implementing multiple versions of the algorithm on its own.
        """

        # ...

        print("Context: Sorting data using the strategy (not sure how it'll do it)")
        result = self._strategy.do_algorithm(["a", "b", "c", "d", "e"])
        print(",".join(result))

        # ...


class Strategy(ABC):
    """
    The Strategy interface declares operations common to all supported versions
    of some algorithm.

    The Context uses this interface to call the algorithm defined by Concrete
    Strategies.
    """

    @abstractmethod
    def do_algorithm(self, data: List):
        pass


"""
Concrete Strategies implement the algorithm while following the base Strategy
interface. The interface makes them interchangeable in the Context.
"""


class ConcreteStrategyA(Strategy):
    def do_algorithm(self, data: List) -> List:
        return sorted(data)


class ConcreteStrategyB(Strategy):
    def do_algorithm(self, data: List) -> List:
        return reversed(sorted(data))


if __name__ == "__main__":
    # The client code picks a concrete strategy and passes it to the context.
    # The client should be aware of the differences between strategies in order
    # to make the right choice.

    context = Context(ConcreteStrategyA())
    print("Client: Strategy is set to normal sorting.")
    context.do_some_business_logic()
    print()

    print("Client: Strategy is set to reverse sorting.")
    context.strategy = ConcreteStrategyB()
    context.do_some_business_logic()

我对属性 method/decorator的理解是，@property在这种情况下提供了一个设置属性（温度）的接口。在 __init__ 方法中命名属性 _strategy 意味着它应该是一个私有变量。这是错误的还是多余的？我认为这个变量应该命名为strategy，但它的接口应该使用私有变量实现（即在getter/setter）

取自https://refactoring.guru/design-patterns/strategy/python/example

编辑：

澄清我的推理：难道不能像这样在运行时更改策略：

a = Context()
a.strategy = somestrategy

Answer 1

属性没有命名为 _strategy，而是命名为 strategy，但是保存其值的内部变量被命名为 _strategy.

这个：

    def __init__(self, strategy: Strategy) -> None:
        self._strategy = strategy

允许：

c = Context(some_strategy)

但是将其命名为 _strategy 会在您尝试 c._strategy 时发出警告。

还有这个：

    @property
    def strategy(self) -> Strategy:
        return self._strategy

然后允许：

my_strategy = c.strategy

getter returns访问属性时self._strategy的值。

最后是这个：

     @strategy.setter
     def strategy(self, strategy: Strategy) -> None:
        self._strategy = strategy

允许：

c.strategy = another_strategy

使 strategy 不只是 read-only 属性而是 read/write 属性.

注意：下面的代码没有错，但它在做其他事情：

class Complex:
    def __init__(self, strategy: int) -> None:
        self.strategy = strategy

    @property
    def strategy(self) -> int:
        return self._strategy

    @strategy.setter
    def strategy(self, strategy: int) -> None:
        self._strategy = strategy


c = Complex(1)
print(c.strategy)

不同的是，现在构造器（__init__）不是直接设置隐藏属性，而是自己为属性调用setter。

如果有人现在覆盖 class，它仍然使用它，比较：

class MyClass:
    def __init__(self, a, b: int) -> None:
        self.a = a
        self._b = b

    @property
    def a(self) -> int:
        return self._a

    @a.setter
    def a(self, a: int) -> None:
        self._a = a

    @property
    def b(self) -> int:
        return self._b

    @b.setter
    def b(self, b: int) -> None:
        self._b = b


class MySubClass(MyClass):
    @MyClass.a.setter
    def a(self, a: int) -> None:
        self._a = a + 10

    @MyClass.b.setter
    def b(self, b: int) -> None:
        self._b = b + 10


c = MyClass(1, 2)
print(c.a)
print(c.b)

s = MySubClass(1, 2)
print(s.a)
print(s.b)

结果：

因此，这取决于您是否希望继承您 class 的人能够改变该行为。

python 策略模式的实现是否应该在 init 方法中使用私有变量？

should this python implementation of strategy pattern use private variable in init method?

python

getter

decorator

strategy-pattern