Python Full Stack Web Developer Course

Common Design Patterns in Both Languages

Many classic design patterns can be implemented in both JavaScript and Python, though the implementation details may differ. Create a file named design_patterns.py for the Python code.

Singleton Pattern

JavaScript:

// JavaScript Singleton pattern
class Singleton {
    static instance;
    
    constructor() {
        if (Singleton.instance) {
            return Singleton.instance;
        }
        
        // Initialize the singleton instance
        this.timestamp = new Date();
        this.config = {
            apiUrl: "https://api.example.com",
            timeout: 5000
        };
        
        Singleton.instance = this;
    }
    
    getConfig() {
        return this.config;
    }
    
    setConfig(key, value) {
        this.config[key] = value;
    }
}

// Usage
const instance1 = new Singleton();
const instance2 = new Singleton();

console.log(instance1 === instance2);  // true, they are the same instance

instance1.setConfig("timeout", 10000);
console.log(instance2.getConfig().timeout);  // 10000, change reflects in all instances

Python:

# File: python_vs_js/design_patterns.py

class Singleton:
    _instance = None
    
    def __new__(cls, *args, **kwargs):
        if cls._instance is None:
            cls._instance = super().__new__(cls)
            # Initialize the singleton instance
            cls._instance.timestamp = __import__("datetime").datetime.now()
            cls._instance.config = {
                "api_url": "https://api.example.com",
                "timeout": 5000
            }
        return cls._instance
    
    def get_config(self):
        return self.config
    
    def set_config(self, key, value):
        self.config[key] = value


# Usage
instance1 = Singleton()
instance2 = Singleton()

print(instance1 is instance2)  # True, they are the same instance

instance1.set_config("timeout", 10000)
print(instance2.get_config()["timeout"])  # 10000, change reflects in all instances

Observer Pattern

JavaScript:

// JavaScript Observer pattern
class Subject {
    constructor() {
        this.observers = [];
    }
    
    addObserver(observer) {
        this.observers.push(observer);
    }
    
    removeObserver(observer) {
        const index = this.observers.indexOf(observer);
        if (index !== -1) {
            this.observers.splice(index, 1);
        }
    }
    
    notify(data) {
        this.observers.forEach(observer => observer.update(data));
    }
}

class Observer {
    constructor(name) {
        this.name = name;
    }
    
    update(data) {
        console.log(`${this.name} received: ${data}`);
    }
}

// Usage
const subject = new Subject();

const observer1 = new Observer("Observer 1");
const observer2 = new Observer("Observer 2");

subject.addObserver(observer1);
subject.addObserver(observer2);

subject.notify("Hello, observers!");
// Observer 1 received: Hello, observers!
// Observer 2 received: Hello, observers!

subject.removeObserver(observer1);
subject.notify("Hello again!");
// Observer 2 received: Hello again!

Python:

# Python Observer pattern
class Subject:
    def __init__(self):
        self.observers = []
    
    def add_observer(self, observer):
        self.observers.append(observer)
    
    def remove_observer(self, observer):
        if observer in self.observers:
            self.observers.remove(observer)
    
    def notify(self, data):
        for observer in self.observers:
            observer.update(data)


class Observer:
    def __init__(self, name):
        self.name = name
    
    def update(self, data):
        print(f"{self.name} received: {data}")


# Usage
subject = Subject()

observer1 = Observer("Observer 1")
observer2 = Observer("Observer 2")

subject.add_observer(observer1)
subject.add_observer(observer2)

subject.notify("Hello, observers!")
# Observer 1 received: Hello, observers!
# Observer 2 received: Hello, observers!

subject.remove_observer(observer1)
subject.notify("Hello again!")
# Observer 2 received: Hello again!

Factory Method Pattern

JavaScript:

// JavaScript Factory Method pattern
class Vehicle {
    constructor(make, model) {
        this.make = make;
        this.model = model;
    }
    
    getInfo() {
        return `${this.make} ${this.model}`;
    }
}

class Car extends Vehicle {
    constructor(make, model, doors) {
        super(make, model);
        this.doors = doors;
        this.type = "Car";
    }
    
    getInfo() {
        return `${super.getInfo()}, ${this.doors} doors, type: ${this.type}`;
    }
}

class Truck extends Vehicle {
    constructor(make, model, payload) {
        super(make, model);
        this.payload = payload;
        this.type = "Truck";
    }
    
    getInfo() {
        return `${super.getInfo()}, payload: ${this.payload}kg, type: ${this.type}`;
    }
}

// Factory class
class VehicleFactory {
    static createVehicle(type, make, model, option) {
        switch (type.toLowerCase()) {
            case "car":
                return new Car(make, model, option);  // option is doors
            case "truck":
                return new Truck(make, model, option);  // option is payload
            default:
                throw new Error(`Vehicle type not supported: ${type}`);
        }
    }
}

// Usage
const car = VehicleFactory.createVehicle("car", "Toyota", "Corolla", 4);
const truck = VehicleFactory.createVehicle("truck", "Ford", "F-150", 1500);

console.log(car.getInfo());   // Toyota Corolla, 4 doors, type: Car
console.log(truck.getInfo()); // Ford F-150, payload: 1500kg, type: Truck

Python:

# Python Factory Method pattern
class Vehicle:
    def __init__(self, make, model):
        self.make = make
        self.model = model
    
    def get_info(self):
        return f"{self.make} {self.model}"


class Car(Vehicle):
    def __init__(self, make, model, doors):
        super().__init__(make, model)
        self.doors = doors
        self.type = "Car"
    
    def get_info(self):
        return f"{super().get_info()}, {self.doors} doors, type: {self.type}"


class Truck(Vehicle):
    def __init__(self, make, model, payload):
        super().__init__(make, model)
        self.payload = payload
        self.type = "Truck"
    
    def get_info(self):
        return f"{super().get_info()}, payload: {self.payload}kg, type: {self.type}"


# Factory class
class VehicleFactory:
    @staticmethod
    def create_vehicle(type, make, model, option):
        if type.lower() == "car":
            return Car(make, model, option)  # option is doors
        elif type.lower() == "truck":
            return Truck(make, model, option)  # option is payload
        else:
            raise ValueError(f"Vehicle type not supported: {type}")


# Usage
car = VehicleFactory.create_vehicle("car", "Toyota", "Corolla", 4)
truck = VehicleFactory.create_vehicle("truck", "Ford", "F-150", 1500)

print(car.get_info())   # Toyota Corolla, 4 doors, type: Car
print(truck.get_info()) # Ford F-150, payload: 1500kg, type: Truck

Summary:

• Both languages can implement common design patterns with similar structures.
• The Singleton pattern works differently: JavaScript uses a static instance, while Python overrides __new__.
• The Observer pattern is nearly identical in both languages.
• The Factory Method pattern leverages class hierarchies and polymorphism in both languages.
• JavaScript's prototypal nature sometimes allows for more flexible patterns than Python's class-based approach.
• Python's multiple inheritance and more powerful class methods can simplify some patterns.