[英]should this python implementation of strategy pattern use private variable in init method?
I'm learning about the strategy design pattern, as well as the property decorator in Python.我正在学习策略设计模式,以及 Python 中的属性装饰器。 I came across this example:我遇到了这个例子:
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()
The way I understand the property method/decorator is that @property
provides an interface for setting the property (temperature) in this case.我理解属性方法/装饰器的方式是@property
在这种情况下提供了一个用于设置属性(温度)的接口。 Naming the property _strategy
in the __init__
method implies it should be a private variable.在__init__
方法中命名属性_strategy
意味着它应该是一个私有变量。 Is this wrong or redundant?这是错误的还是多余的? I would think that this variable should be named strategy
, but its interface should be implemented using private variables (ie in the getter/setter)我认为这个变量应该命名为strategy
,但它的接口应该使用私有变量来实现(即在 getter/setter 中)
taken from https://refactoring.guru/design-patterns/strategy/python/example取自https://refactoring.guru/design-patterns/strategy/python/example
Edit:编辑:
To clarify my reasoning: shouldn't it be possible to change the strategy at runtime like this:为了澄清我的推理:不应该像这样在运行时更改策略:
a = Context()
a.strategy = somestrategy
The property isn't named _strategy
, it's named strategy
, but the internal variable that holds its value is named _strategy
.该属性未命名为_strategy
,而是命名为strategy
,但保存其值的内部变量名为_strategy
。
This:这个:
def __init__(self, strategy: Strategy) -> None:
self._strategy = strategy
Allows:允许:
c = Context(some_strategy)
But naming it _strategy
causes warnings when you try c._strategy
.但是当您尝试c._strategy
时,将其命名为_strategy
会导致警告。
And this:和这个:
@property
def strategy(self) -> Strategy:
return self._strategy
Then allows:然后允许:
my_strategy = c.strategy
The getter returns the value of self._strategy
when the property is accessed.当属性被访问时,getter 返回self._strategy
的值。
And finally this:最后这个:
@strategy.setter
def strategy(self, strategy: Strategy) -> None:
self._strategy = strategy
Allows:允许:
c.strategy = another_strategy
Making strategy
not just a read-only property but a read/write property.使strategy
不仅是只读属性,而且是读/写属性。
Note: the code below is not wrong, but it's doing something else:注意:下面的代码没有错,但它在做其他事情:
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)
The difference is that now, the constructor ( __init__
) is not setting the hidden attribute directly, but it is itself calling the setter for the property.不同的是,现在构造函数 ( __init__
) 不是直接设置隐藏属性,而是它本身调用属性的设置器。
If someone now overrides the class, it still uses that, compare:如果现在有人覆盖了这个类,它仍然使用它,比较:
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)
Result:结果:
1
2
11
2
So, it depends if you want someone that inherits your class to be able to change that behaviour.因此,这取决于您是否希望继承您的类的人能够改变这种行为。
声明:本站的技术帖子网页,遵循CC BY-SA 4.0协议,如果您需要转载,请注明本站网址或者原文地址。任何问题请咨询:yoyou2525@163.com.