[디자인패턴] Week 27: 파이썬 디자인 패턴 II - 구조 패턴

Day 1: 구조 패턴 개요

• 강의 내용:
  • 구조 패턴의 개념
    • 구조 패턴이란 무엇인가?
    • 구조 패턴의 중요성
  • 주요 구조 패턴
    • 어댑터 (Adapter)
    • 데코레이터 (Decorator)
    • 퍼사드 (Facade)
    • 플라이웨이트 (Flyweight)
    • 프록시 (Proxy)
  • 구조 패턴의 응용 사례
    • 코드 재사용성 향상, 시스템 구조 단순화
• 실습:
  • 간단한 구조 패턴 예제

# Adapter 패턴 예제
class Target:
    def request(self):
        return "Target: The default target's behavior."

class Adaptee:
    def specific_request(self):
        return ".eetpadA eht fo roivaheb laicepS"

class Adapter(Target):
    def __init__(self, adaptee):
        self.adaptee = adaptee

    def request(self):
        return f"Adapter: (TRANSLATED) {self.adaptee.specific_request()[::-1]}"

adaptee = Adaptee()
adapter = Adapter(adaptee)
print(adapter.request())  # Adapter: (TRANSLATED) Special behavior of the Adaptee.

 

Day 2: 어댑터 패턴 (Adapter Pattern)

• 강의 내용:
  • 어댑터 패턴의 개념
    • 어댑터 패턴이란 무엇인가?
    • 호환되지 않는 인터페이스를 맞추는 패턴
  • 어댑터 패턴의 구현 방법
    • 클래스 어댑터와 객체 어댑터
  • 어댑터 패턴의 응용 사례
    • 기존 클래스 재사용, 인터페이스 통합
• 실습:
  • 파이썬을 사용한 어댑터 패턴 구현 예제

# Adapter 패턴 예제
class EuropeanSocketInterface:
    def voltage(self): pass
    def live(self): pass
    def neutral(self): pass
    def earth(self): pass

class Socket(EuropeanSocketInterface):
    def voltage(self):
        return 230
    def live(self):
        return 1
    def neutral(self):
        return -1
    def earth(self):
        return 0

class USASocketInterface:
    def voltage(self): pass
    def live(self): pass
    def neutral(self): pass

class Adapter(USASocketInterface):
    def __init__(self, socket):
        self.socket = socket

    def voltage(self):
        return 110

    def live(self):
        return self.socket.live()

    def neutral(self):
        return self.socket.neutral()

socket = Socket()
adapter = Adapter(socket)
print(f"Voltage: {adapter.voltage()}V")  # Voltage: 110V

 

Day 3: 데코레이터 패턴 (Decorator Pattern)

• 강의 내용:
  • 데코레이터 패턴의 개념
    • 데코레이터 패턴이란 무엇인가?
    • 객체에 동적으로 새로운 책임을 추가하는 패턴
  • 데코레이터 패턴의 구현 방법
    • 데코레이터 클래스와 데코레이터 체인
  • 데코레이터 패턴의 응용 사례
    • 기능 확장, 코드 유연성 향상
• 실습:
  • 파이썬을 사용한 데코레이터 패턴 구현 예제

# Decorator 패턴 예제
class Component:
    def operation(self):
        pass

class ConcreteComponent(Component):
    def operation(self):
        return "ConcreteComponent"

class Decorator(Component):
    def __init__(self, component):
        self._component = component

    def operation(self):
        return self._component.operation()

class ConcreteDecoratorA(Decorator):
    def operation(self):
        return f"ConcreteDecoratorA({self._component.operation()})"

class ConcreteDecoratorB(Decorator):
    def operation(self):
        return f"ConcreteDecoratorB({self._component.operation()})"

simple = ConcreteComponent()
decorator1 = ConcreteDecoratorA(simple)
decorator2 = ConcreteDecoratorB(decorator1)
print(decorator2.operation())  # ConcreteDecoratorB(ConcreteDecoratorA(ConcreteComponent))

 

Day 4: 퍼사드 패턴 (Facade Pattern)

• 강의 내용:
  • 퍼사드 패턴의 개념
    • 퍼사드 패턴이란 무엇인가?
    • 복잡한 서브시스템에 대한 단순한 인터페이스 제공
  • 퍼사드 패턴의 구현 방법
    • 퍼사드 클래스와 서브시스템 클래스
  • 퍼사드 패턴의 응용 사례
    • 시스템 복잡성 감소, 코드 가독성 향상
• 실습:
  • 파이썬을 사용한 퍼사드 패턴 구현 예제

# Facade 패턴 예제
class Subsystem1:
    def operation1(self):
        return "Subsystem1: Ready!"

    def operation_n(self):
        return "Subsystem1: Go!"

class Subsystem2:
    def operation1(self):
        return "Subsystem2: Get ready!"

    def operation_z(self):
        return "Subsystem2: Fire!"

class Facade:
    def __init__(self, subsystem1, subsystem2):
        self._subsystem1 = subsystem1
        self._subsystem2 = subsystem2

    def operation(self):
        results = []
        results.append(self._subsystem1.operation1())
        results.append(self._subsystem2.operation1())
        results.append(self._subsystem1.operation_n())
        results.append(self._subsystem2.operation_z())
        return "\n".join(results)

subsystem1 = Subsystem1()
subsystem2 = Subsystem2()
facade = Facade(subsystem1, subsystem2)
print(facade.operation())

 

Day 5: 플라이웨이트 패턴 (Flyweight Pattern)

• 강의 내용:
  • 플라이웨이트 패턴의 개념
    • 플라이웨이트 패턴이란 무엇인가?
    • 메모리 사용을 최소화하기 위한 패턴
  • 플라이웨이트 패턴의 구현 방법
    • 플라이웨이트 팩토리와 공유 객체
  • 플라이웨이트 패턴의 응용 사례
    • 대량의 객체 생성 최적화, 메모리 절약
• 실습:
  • 파이썬을 사용한 플라이웨이트 패턴 구현 예제

# Flyweight 패턴 예제
class Flyweight:
    def __init__(self, shared_state):
        self._shared_state = shared_state

    def operation(self, unique_state):
        s = self._shared_state
        u = unique_state
        print(f"Flyweight: Displaying shared ({s}) and unique ({u}) state.")

class FlyweightFactory:
    _flyweights = {}

    def get_flyweight(self, shared_state):
        if shared_state not in self._flyweights:
            self._flyweights[shared_state] = Flyweight(shared_state)
        return self._flyweights[shared_state]

factory = FlyweightFactory()

flyweight1 = factory.get_flyweight("SharedState1")
flyweight2 = factory.get_flyweight("SharedState1")
flyweight3 = factory.get_flyweight("SharedState2")

flyweight1.operation("UniqueStateA")
flyweight2.operation("UniqueStateB")
flyweight3.operation("UniqueStateC")

 

Day 6: 프록시 패턴 (Proxy Pattern)

• 강의 내용:
  • 프록시 패턴의 개념
    • 프록시 패턴이란 무엇인가?
    • 접근 제어 및 객체의 대리자 역할을 하는 패턴
  • 프록시 패턴의 구현 방법
    • 가상 프록시, 보호 프록시, 원격 프록시
  • 프록시 패턴의 응용 사례
    • 객체 접근 제어, 리소스 관리
• 실습:
  • 파이썬을 사용한 프록시 패턴 구현 예제

# Proxy 패턴 예제
class Subject:
    def request(self):
        pass

class RealSubject(Subject):
    def request(self):
        print("RealSubject: Handling request.")

class Proxy(Subject):
    def __init__(self, real_subject):
        self._real_subject = real_subject

    def request(self):
        if self.check_access():
            self._real_subject.request()
            self.log_access()

    def check_access(self):
        print("Proxy: Checking access prior to firing a real request.")
        return True

    def log_access(self):
        print("Proxy: Logging the time of request.")

real_subject = RealSubject()
proxy = Proxy(real_subject)
proxy.request()

 

Day 7: 구조 패턴 종합 연습

• 강의 내용:
  • 종합 연습 문제 풀이
    • 어댑터 패턴, 데코레이터 패턴, 퍼사드 패턴, 플라이웨이트 패턴, 프록시 패턴 문제 해결
  • 구조 패턴의 응용
    • 다양한 실생활 문제에서의 응용 사례
• 실습:
  • 종합 연습 문제 해결 및 결과 분석

### 종합 연습 문제 예시
1. 어댑터 패턴을 사용하여 두 개의 호환되지 않는 인터페이스를 맞추세요.
2. 데코레이터 패턴을 사용하여 기본 기능에 추가 기능을 동적으로 추가하세요.
3. 퍼사드 패턴을 사용하여 복잡한 서브시스템을 단순화하세요.
4. 플라이웨이트 패턴을 사용하여 메모리 사용을 최적화하세요.
5. 프록시 패턴을 사용하여 객체에 대한 접근을 제어하세요.

 

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