[디자인패턴] Week 28: 파이썬 디자인 패턴 III - 행동 패턴

Day 1: 행동 패턴 개요

• 강의 내용:
  • 행동 패턴의 개념
    • 행동 패턴이란 무엇인가?
    • 행동 패턴의 중요성
  • 주요 행동 패턴
    • 전략 패턴 (Strategy)
    • 옵저버 패턴 (Observer)
    • 상태 패턴 (State)
    • 커맨드 패턴 (Command)
    • 템플릿 메서드 패턴 (Template Method)
  • 행동 패턴의 응용 사례
    • 객체의 상호작용 관리, 동작의 캡슐화
• 실습:
  • 간단한 행동 패턴 예제

# Strategy 패턴 예제
class Strategy:
    def execute(self):
        pass

class ConcreteStrategyA(Strategy):
    def execute(self):
        return "ConcreteStrategyA"

class ConcreteStrategyB(Strategy):
    def execute(self):
        return "ConcreteStrategyB"

class Context:
    def __init__(self, strategy: Strategy):
        self._strategy = strategy

    def set_strategy(self, strategy: Strategy):
        self._strategy = strategy

    def execute_strategy(self):
        return self._strategy.execute()

context = Context(ConcreteStrategyA())
print(context.execute_strategy())  # ConcreteStrategyA

context.set_strategy(ConcreteStrategyB())
print(context.execute_strategy())  # ConcreteStrategyB

 

Day 2: 전략 패턴 (Strategy Pattern)

• 강의 내용:
  • 전략 패턴의 개념
    • 전략 패턴이란 무엇인가?
    • 동작을 캡슐화하여 교체 가능하게 만드는 패턴
  • 전략 패턴의 구현 방법
    • 전략 인터페이스와 구체적인 전략 클래스
  • 전략 패턴의 응용 사례
    • 알고리즘 선택, 동작의 유연한 변경
• 실습:
  • 파이썬을 사용한 전략 패턴 구현 예제

# Strategy 패턴 예제
class Strategy:
    def execute(self):
        pass

class ConcreteStrategyA(Strategy):
    def execute(self):
        return "ConcreteStrategyA"

class ConcreteStrategyB(Strategy):
    def execute(self):
        return "ConcreteStrategyB"

class Context:
    def __init__(self, strategy: Strategy):
        self._strategy = strategy

    def set_strategy(self, strategy: Strategy):
        self._strategy = strategy

    def execute_strategy(self):
        return self._strategy.execute()

context = Context(ConcreteStrategyA())
print(context.execute_strategy())  # ConcreteStrategyA

context.set_strategy(ConcreteStrategyB())
print(context.execute_strategy())  # ConcreteStrategyB

 

Day 3: 옵저버 패턴 (Observer Pattern)

• 강의 내용:
  • 옵저버 패턴의 개념
    • 옵저버 패턴이란 무엇인가?
    • 객체의 상태 변화를 감시하고 통지하는 패턴
  • 옵저버 패턴의 구현 방법
    • 주제와 옵저버 인터페이스
  • 옵저버 패턴의 응용 사례
    • 이벤트 처리, 데이터 변경 통지
• 실습:
  • 파이썬을 사용한 옵저버 패턴 구현 예제

# Observer 패턴 예제
class Subject:
    def __init__(self):
        self._observers = []

    def attach(self, observer):
        self._observers.append(observer)

    def detach(self, observer):
        self._observers.remove(observer)

    def notify(self):
        for observer in self._observers:
            observer.update(self)

class Observer:
    def update(self, subject):
        pass

class ConcreteObserverA(Observer):
    def update(self, subject):
        print("ConcreteObserverA: Reacted to the event")

class ConcreteObserverB(Observer):
    def update(self, subject):
        print("ConcreteObserverB: Reacted to the event")

subject = Subject()
observer_a = ConcreteObserverA()
observer_b = ConcreteObserverB()
subject.attach(observer_a)
subject.attach(observer_b)

subject.notify()

 

Day 4: 상태 패턴 (State Pattern)

• 강의 내용:
  • 상태 패턴의 개념
    • 상태 패턴이란 무엇인가?
    • 객체의 내부 상태에 따라 행동을 변경하는 패턴
  • 상태 패턴의 구현 방법
    • 상태 인터페이스와 구체적인 상태 클래스
  • 상태 패턴의 응용 사례
    • 상태 전환 관리, 객체 행동 변경
• 실습:
  • 파이썬을 사용한 상태 패턴 구현 예제

# State 패턴 예제
class Context:
    def __init__(self, state):
        self._state = state

    def set_state(self, state):
        self._state = state

    def request(self):
        self._state.handle()

class State:
    def handle(self):
        pass

class ConcreteStateA(State):
    def handle(self):
        print("ConcreteStateA: Handling request")

class ConcreteStateB(State):
    def handle(self):
        print("ConcreteStateB: Handling request")

context = Context(ConcreteStateA())
context.request()  # ConcreteStateA: Handling request
context.set_state(ConcreteStateB())
context.request()  # ConcreteStateB: Handling request

 

Day 5: 커맨드 패턴 (Command Pattern)

• 강의 내용:
  • 커맨드 패턴의 개념
    • 커맨드 패턴이란 무엇인가?
    • 요청을 객체로 캡슐화하여 분리하는 패턴
  • 커맨드 패턴의 구현 방법
    • 커맨드 인터페이스와 구체적인 커맨드 클래스
  • 커맨드 패턴의 응용 사례
    • 요청의 큐잉, 취소 작업 구현
• 실습:
  • 파이썬을 사용한 커맨드 패턴 구현 예제

# Command 패턴 예제
class Command:
    def execute(self):
        pass

class SimpleCommand(Command):
    def __init__(self, payload):
        self._payload = payload

    def execute(self):
        print(f"SimpleCommand: See, I can do simple things like printing ({self._payload})")

class ComplexCommand(Command):
    def __init__(self, receiver, a, b):
        self._receiver = receiver
        self._a = a
        self._b = b

    def execute(self):
        print("ComplexCommand: Complex stuff should be done by a receiver object")
        self._receiver.do_something(self._a)
        self._receiver.do_something_else(self._b)

class Receiver:
    def do_something(self, a):
        print(f"Receiver: Working on ({a}.)")

    def do_something_else(self, b):
        print(f"Receiver: Also working on ({b}.)")

class Invoker:
    _on_start = None
    _on_finish = None

    def set_on_start(self, command):
        self._on_start = command

    def set_on_finish(self, command):
        self._on_finish = command

    def do_something_important(self):
        if isinstance(self._on_start, Command):
            self._on_start.execute()
        if isinstance(self._on_finish, Command):
            self._on_finish.execute()

invoker = Invoker()
invoker.set_on_start(SimpleCommand("Say Hi!"))
receiver = Receiver()
invoker.set_on_finish(ComplexCommand(receiver, "Send email", "Save report"))

invoker.do_something_important()

 

Day 6: 템플릿 메서드 패턴 (Template Method Pattern)

• 강의 내용:
  • 템플릿 메서드 패턴의 개념
    • 템플릿 메서드 패턴이란 무엇인가?
    • 알고리즘의 골격을 정의하고 세부 사항을 서브클래스에 위임하는 패턴
  • 템플릿 메서드 패턴의 구현 방법
    • 템플릿 메서드와 추상 메서드
  • 템플릿 메서드 패턴의 응용 사례
    • 알고리즘 재사용, 코드 중복 감소
• 실습:
  • 파이썬을 사용한 템플릿 메서드 패턴 구현 예제

# Template Method 패턴 예제
class AbstractClass:
    def template_method(self):
        self.base_operation1()
        self.required_operations1()
        self.base_operation2()
        self.hook1()
        self.required_operations2()
        self.base_operation3()
        self.hook2()

    def base_operation1(self):
        print("AbstractClass says: I am doing the bulk of the work")

    def base_operation2(self):
        print("AbstractClass says: But I let subclasses override some operations")

    def base_operation3(self):
        print("AbstractClass says: But I am doing the bulk of the work anyway")

    def required_operations1(self):
        pass

    def required_operations2(self):
        pass

    def hook1(self):
        pass

    def hook2(self):
        pass

class ConcreteClass1(AbstractClass):
    def required_operations1(self):
        print("ConcreteClass1 says: Implemented Operation1")

    def required_operations2(self):
        print("ConcreteClass1 says: Implemented Operation2")

class ConcreteClass2(AbstractClass):
    def required_operations1(self):
        print("ConcreteClass2 says: Implemented Operation1")

    def required_operations2(self):
        print("ConcreteClass2 says: Implemented Operation2")

    def hook1(self):
        print("ConcreteClass2 says: Overridden Hook1")

concrete1 = ConcreteClass1()
concrete1.template_method()

concrete2 = ConcreteClass2()
concrete2.template_method()

 

Day 7: 행동 패턴 종합 연습

• 강의 내용:
  • 종합 연습 문제 풀이
    • 전략 패턴, 옵저버 패턴, 상태 패턴, 커맨드 패턴, 템플릿 메서드 패턴 문제 해결
  • 행동 패턴의 응용
    • 다양한 실생활 문제에서의 응용 사례
• 실습:
  • 종합 연습 문제 해결 및 결과 분석

### 종합 연습 문제 예시
1. 전략 패턴을 사용하여 다양한 정렬 알고리즘을 구현하세요.
2. 옵저버 패턴을 사용하여 이벤트 처리 시스템을 구현하세요.
3. 상태 패턴을 사용하여 상태 전환을 관리하세요.
4. 커맨드 패턴을 사용하여 요청의 큐잉과 취소 작업을 구현하세요.
5. 템플릿 메서드 패턴을 사용하여 알고리즘의 골격을 정의하세요.

 

이 강의는 파이썬의 디자인 패턴, 특히 행동 패턴의 기본 개념과 구현을 익히는 것을 목표로 하며, 각 강의는 이론과 실습을 포함합니다. 다음 주차에 대한 상세 강의를 원하시면 말씀해 주세요!