问题描述
我正在学习策略设计模式以及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,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()
我了解属性方法/装饰器的方式是,在这种情况下,@property
提供了用于设置属性(温度)的界面。在_strategy
方法中命名属性__init__
意味着它应该是一个私有变量。这是错误的还是多余的?我认为该变量应命名为strategy
,但应使用私有变量(即在getter / setter中)实现其接口
取自https://refactoring.guru/design-patterns/strategy/python/example
编辑:
要阐明我的理由:应该不能像这样在运行时更改策略:
a = Context()
a.strategy = somestrategy
解决方法
该属性未命名为_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返回self._strategy
的值。
最后是这个
@strategy.setter
def strategy(self,strategy: Strategy) -> None:
self._strategy = strategy
允许:
c.strategy = another_strategy
设置strategy
不仅是只读属性,还包括读/写属性。
注意:下面的代码没有错,但是它在做其他事情:
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__
)并没有直接设置hidden属性,而是它本身在调用该属性的setter。
如果现在有人重写了该类,它仍然使用该类,请进行比较:
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)
结果:
1
2
11
2
因此,这取决于您是否希望继承您班级的人能够更改该行为。