classDiagram
    class Singleton {
        -instance: Singleton
        +getInstance(): Singleton
        +operation()
    }
    
    note for Singleton "Only one instance exists"

class DatabaseConnection:
    _instance = None
    _lock = threading.Lock()
    
    def __new__(cls):
        if cls._instance is None:
            with cls._lock:
                if cls._instance is None:
                    cls._instance = super().__new__(cls)
                    cls._instance.connection = None
        return cls._instance
    
    def connect(self):
        if self.connection is None:
            self.connection = "Connected to Database"
            print("Database connection established")
        return self.connection
 
# Usage
db1 = DatabaseConnection()
db2 = DatabaseConnection()
print(db1 is db2)  # True - Same instance

classDiagram
    class AnimalFactory {
        +createAnimal(type: String): Animal
    }
    
    class Animal {
        <<interface>>
        +makeSound()
    }
    
    class Dog {
        +makeSound()
    }
    
    class Cat {
        +makeSound()
    }
    
    AnimalFactory --> Animal
    Dog ..|> Animal
    Cat ..|> Animal

from abc import ABC, abstractmethod
 
class Animal(ABC):
    @abstractmethod
    def make_sound(self):
        pass
 
class Dog(Animal):
    def make_sound(self):
        return "Woof!"
 
class Cat(Animal):
    def make_sound(self):
        return "Meow!"
 
class AnimalFactory:
    @staticmethod
    def create_animal(animal_type):
        if animal_type.lower() == "dog":
            return Dog()
        elif animal_type.lower() == "cat":
            return Cat()
        else:
            raise ValueError(f"Unknown animal type: {animal_type}")
 
# Usage
factory = AnimalFactory()
dog = factory.create_animal("dog")
cat = factory.create_animal("cat")
print(dog.make_sound())  # Woof!
print(cat.make_sound())  # Meow!

classDiagram
    class Pizza {
        +size: String
        +crust: String
        +toppings: List
    }
    
    class PizzaBuilder {
        -pizza: Pizza
        +setSize(size: String): PizzaBuilder
        +setCrust(crust: String): PizzaBuilder
        +addTopping(topping: String): PizzaBuilder
        +build(): Pizza
    }
    
    class Director {
        +makeMargherita(): Pizza
        +makePepperoni(): Pizza
    }
    
    Director --> PizzaBuilder
    PizzaBuilder --> Pizza

class Pizza:
    def __init__(self):
        self.size = None
        self.crust = None
        self.toppings = []
    
    def __str__(self):
        return f"{self.size} {self.crust} pizza with {', '.join(self.toppings)}"
 
class PizzaBuilder:
    def __init__(self):
        self.pizza = Pizza()
    
    def set_size(self, size):
        self.pizza.size = size
        return self
    
    def set_crust(self, crust):
        self.pizza.crust = crust
        return self
    
    def add_topping(self, topping):
        self.pizza.toppings.append(topping)
        return self
    
    def build(self):
        return self.pizza
 
# Usage
pizza = (PizzaBuilder()
         .set_size("Large")
         .set_crust("Thin")
         .add_topping("Pepperoni")
         .add_topping("Mushrooms")
         .build())
 
print(pizza)  # Large Thin pizza with Pepperoni, Mushrooms