개발자를 위한 파이썬 디자인 패턴 가이드: 싱글톤, 팩토리, 옵저버

            
class SingletonMeta(type):
    """A metaclass for creating a Singleton class."""
    _instances = {}

    def __call__(cls, *args, **kwargs):
        # This method is called when an instance is created, e.g., MyClass()
        if cls not in cls._instances:
            instance = super().__call__(*args, **kwargs)
            cls._instances[cls] = instance
        return cls._instances[cls]

class GlobalConfig(metaclass=SingletonMeta):
    def __init__(self):
        # This will only be executed the first time the instance is created.
        print("Initializing GlobalConfig...")
        self.settings = {"api_key": "default_key", "timeout": 30}

    def get_setting(self, key):
        return self.settings.get(key)

# --- Usage ---
config1 = GlobalConfig()
config2 = GlobalConfig()

print(f"config1 settings: {config1.settings}")
config1.settings["api_key"] = "new_secret_key_12345"

print(f"config2 settings: {config2.settings}") # Will show the updated key

# Verify they are the same object
print(f"Are config1 and config2 the same instance? {config1 is config2}")

            

              
                Copy
              
            
          

            
def singleton(cls):
    """A decorator to turn a class into a Singleton."""
    instances = {}
    def get_instance(*args, **kwargs):
        if cls not in instances:
            instances[cls] = cls(*args, **kwargs)
        return instances[cls]
    return get_instance

@singleton
class DatabaseConnection:
    def __init__(self):
        print("Connecting to the database...")
        # Simulate a database connection setup
        self.connection_id = id(self)

# --- Usage ---
db1 = DatabaseConnection()
db2 = DatabaseConnection()

print(f"DB1 Connection ID: {db1.connection_id}")
print(f"DB2 Connection ID: {db2.connection_id}")
print(f"Are db1 and db2 the same instance? {db1 is db2}")

            

              
                Copy
              
            
          

            
if export_format == 'pdf':
    exporter = PDFExporter()
elif export_format == 'csv':
    exporter = CSVExporter()
else:
    exporter = JSONExporter()

exporter.export(data)

            

              
                Copy
              
            
          

            
from abc import ABC, abstractmethod

# --- Product Interface and Concrete Products ---
class Button(ABC):
    """Product Interface: Defines the interface for buttons."""
    @abstractmethod
    def render(self):
        pass

class WindowsButton(Button):
    """Concrete Product: A button with Windows OS style."""
    def render(self):
        print("Rendering a button in Windows style.")

class MacOSButton(Button):
    """Concrete Product: A button with macOS style."""
    def render(self):
        print("Rendering a button in macOS style.")

# --- Creator (Abstract) and Concrete Creators ---
class Dialog(ABC):
    """Creator: Declares the factory method.
       It also contains business logic that uses the product.
    """
    @abstractmethod
    def create_button(self) -> Button:
        """The factory method."""
        pass

    def show_dialog(self):
        """The core business logic that isn't aware of concrete button types."""
        print("Showing a generic dialog box.")
        button = self.create_button()
        button.render()

class WindowsDialog(Dialog):
    """Concrete Creator for Windows."""
    def create_button(self) -> Button:
        return WindowsButton()

class MacOSDialog(Dialog):
    """Concrete Creator for macOS."""
    def create_button(self) -> Button:
        return MacOSButton()

# --- Client Code ---
def initialize_app(os_name: str):
    if os_name == "Windows":
        dialog = WindowsDialog()
    elif os_name == "macOS":
        dialog = MacOSDialog()
    else:
        raise ValueError(f"Unsupported OS: {os_name}")
    
    dialog.show_dialog()

# Simulate running the app on different OS
print("--- Running on Windows ---")
initialize_app("Windows")

print("\n--- Running on macOS ---")
initialize_app("macOS")

            

              
                Copy
              
            
          

            
from abc import ABC, abstractmethod

# --- Abstract Product Interfaces ---
class Button(ABC):
    @abstractmethod
    def paint(self):
        pass

class Checkbox(ABC):
    @abstractmethod
    def paint(self):
        pass

# --- Concrete Products for the 'Light' Theme ---
class LightButton(Button):
    def paint(self):
        print("Painting a light theme button.")

class LightCheckbox(Checkbox):
    def paint(self):
        print("Painting a light theme checkbox.")

# --- Concrete Products for the 'Dark' Theme ---
class DarkButton(Button):
    def paint(self):
        print("Painting a dark theme button.")

class DarkCheckbox(Checkbox):
    def paint(self):
        print("Painting a dark theme checkbox.")

# --- Abstract Factory Interface ---
class UIFactory(ABC):
    @abstractmethod
    def create_button(self) -> Button:
        pass
    
    @abstractmethod
    def create_checkbox(self) -> Checkbox:
        pass

# --- Concrete Factories for each theme ---
class LightThemeFactory(UIFactory):
    def create_button(self) -> Button:
        return LightButton()
    
    def create_checkbox(self) -> Checkbox:
        return LightCheckbox()

class DarkThemeFactory(UIFactory):
    def create_button(self) -> Button:
        return DarkButton()
    
    def create_checkbox(self) -> Checkbox:
        return DarkCheckbox()

# --- Client Code ---
class Application:
    def __init__(self, factory: UIFactory):
        self.factory = factory
        self.button = None
        self.checkbox = None

    def create_ui(self):
        self.button = self.factory.create_button()
        self.checkbox = self.factory.create_checkbox()

    def paint_ui(self):
        self.button.paint()
        self.checkbox.paint()

# --- Main application logic ---
def get_factory_for_theme(theme_name: str) -> UIFactory:
    if theme_name == "light":
        return LightThemeFactory()
    elif theme_name == "dark":
        return DarkThemeFactory()
    else:
        raise ValueError(f"Unknown theme: {theme_name}")

# Create and run the application with a specific theme
current_theme = "dark"
ui_factory = get_factory_for_theme(current_theme)
app = Application(ui_factory)
app.create_ui()
app.paint_ui()

            

              
                Copy
              
            
          

            
from abc import ABC, abstractmethod
from typing import List

# --- Observer Interface and Concrete Observers ---
class Observer(ABC):
    @abstractmethod
    def update(self, subject):
        pass

class EmailNotifier(Observer):
    def __init__(self, email_address: str):
        self.email_address = email_address

    def update(self, subject):
        print(f"Sending Email to {self.email_address}: New story available! Title: '{subject.latest_story}'")

class SMSNotifier(Observer):
    def __init__(self, phone_number: str):
        self.phone_number = phone_number

    def update(self, subject):
        print(f"Sending SMS to {self.phone_number}: News Alert: '{subject.latest_story}'")

# --- Subject (Observable) Class ---
class NewsAgency:
    def __init__(self):
        self._observers: List[Observer] = []
        self._latest_story: str = ""

    def attach(self, observer: Observer) -> None:
        print("News Agency: Attached an observer.")
        self._observers.append(observer)

    def detach(self, observer: Observer) -> None:
        print("News Agency: Detached an observer.")
        self._observers.remove(observer)

    def notify(self) -> None:
        print("News Agency: Notifying observers...")
        for observer in self._observers:
            observer.update(self)

    @property
    def latest_story(self) -> str:
        return self._latest_story

    def add_new_story(self, story: str) -> None:
        print(f"\nNews Agency: Publishing new story: '{story}'")
        self._latest_story = story
        self.notify()

# --- Client Code ---
# Create the subject
agency = NewsAgency()

# Create observers
email_subscriber1 = EmailNotifier("reader1@example.com")
sms_subscriber1 = SMSNotifier("+15551234567")
email_subscriber2 = EmailNotifier("another.reader@example.com")

# Attach observers to the subject
agency.attach(email_subscriber1)
agency.attach(sms_subscriber1)
agency.attach(email_subscriber2)

# The subject's state changes, and all observers are notified
agency.add_new_story("Global Tech Summit Begins Next Week")

# Detach an observer
agency.detach(email_subscriber1)

# Another state change occurs
agency.add_new_story("Breakthrough in Renewable Energy Announced")

            

              
                Copy