Pythonで極める！生成パターン入門：オブジェクト設計をスマートに

product_a = Product(name="Product A", price=100, category="A")
product_b = Product(name="Product B", price=200, category="B")
product_c = Product(name="Product C", price=300, category="C")

class Singleton:
    _instance = None
    def __new__(cls, *args, **kwargs):
        if not cls._instance:
            cls._instance = super().__new__(cls, *args, **kwargs)
        return cls._instance

class Product:
    pass

class ProductA(Product):
    pass

class ProductB(Product):
    pass

class Factory:
    @staticmethod
    def create_product(product_type):
        if product_type == "A":
            return ProductA()
        elif product_type == "B":
            return ProductB()

class Product:
    def __init__(self):
        self.feature1 = None
        self.feature2 = None

class ProductBuilder:
    def __init__(self):
        self.product = Product()

    def set_feature1(self, value):
        self.product.feature1 = value
        return self

    def set_feature2(self, value):
        self.product.feature2 = value
        return self

    def build(self):
        return self.product

# 使用例
builder = ProductBuilder()
product = builder.set_feature1("Value1").set_feature2("Value2").build()

# settings.py (モジュール)
config = {
    "theme": "dark",
    "language": "en"
}

# 使用例
import settings

print(settings.config["theme"])  # "dark"
settings.config["theme"] = "light"
print(settings.config["theme"])  # "light"

def product_factory(product_type):
    class Product:
        def __init__(self, name):
            self.name = name

    if product_type == "A":
        class ProductA(Product):
            def info(self):
                return f"{self.name} - Type A"
        return ProductA
    elif product_type == "B":
        class ProductB(Product):
            def info(self):
                return f"{self.name} - Type B"
        return ProductB
    else:
        raise ValueError("Invalid product type")

# 使用例
ProductA = product_factory("A")
product_a = ProductA("Product A")
print(product_a.info())  # "Product A - Type A"

def log_creation(cls):
    def wrapper(*args, **kwargs):
        instance = cls(*args, **kwargs)
        print(f"Created instance of {cls.__name__} with args: {args}, kwargs: {kwargs}")
        return instance
    return wrapper

@log_creation
class Product:
    def __init__(self, name, price):
        self.name = name
        self.price = price

# 使用例
product = Product("Widget", 19.99)
# 出力: Created instance of Product with args: ('Widget', 19.99), kwargs: {}

class Resource:
    def __init__(self, name):
        self.name = name

    def __enter__(self):
        print(f"Allocating resource: {self.name}")
        return self

    def __exit__(self, exc_type, exc_value, traceback):
        print(f"Releasing resource: {self.name}")

# 使用例
with Resource("Database Connection") as resource:
    print(f"Using resource: {resource.name}")
# 出力:
# Allocating resource: Database Connection
# Using resource: Database Connection
# Releasing resource: Database Connection

class AppConfig:
    _instance = None

    def __new__(cls, *args, **kwargs):
        if not cls._instance:
            cls._instance = super().__new__(cls, *args, **kwargs)
            cls._instance.settings = {"theme": "dark", "language": "en"}
        return cls._instance

# 使用例
config1 = AppConfig()
config2 = AppConfig()
print(config1 is config2)  # True (同じインスタンス)

# 設定の変更
config1.settings["theme"] = "light"
print(config2.settings["theme"])  # "light" (全体に影響)

class Product:
    def __init__(self, name):
        self.name = name

class ProductA(Product):
    def info(self):
        return f"{self.name} is a Type A product."

class ProductB(Product):
    def info(self):
        return f"{self.name} is a Type B product."

class ProductFactory:
    @staticmethod
    def create_product(product_type, name):
        if product_type == "A":
            return ProductA(name)
        elif product_type == "B":
            return ProductB(name)
        else:
            raise ValueError("Invalid product type")

# 使用例
product1 = ProductFactory.create_product("A", "Widget")
product2 = ProductFactory.create_product("B", "Gadget")

print(product1.info())  # "Widget is a Type A product."
print(product2.info())  # "Gadget is a Type B product."

class Character:
    def __init__(self):
        self.name = None
        self.role = None
        self.weapon = None

    def __str__(self):
        return f"Character(name={self.name}, role={self.role}, weapon={self.weapon})"

class CharacterBuilder:
    def __init__(self):
        self.character = Character()

    def set_name(self, name):
        self.character.name = name
        return self

    def set_role(self, role):
        self.character.role = role
        return self

    def set_weapon(self, weapon):
        self.character.weapon = weapon
        return self

    def build(self):
        return self.character

# 使用例
builder = CharacterBuilder()
character = (builder.set_name("Arthur")
                   .set_role("Knight")
                   .set_weapon("Sword")
                   .build())

print(character)  # Character(name=Arthur, role=Knight, weapon=Sword)