**Course Title:** Modern Python Programming: Best Practices and Trends **Section Title:** Object-Oriented Programming (OOP) in Python **Topic:** Design patterns in Python: Singleton, Factory, and others. ### Introduction to Design Patterns Design patterns are solutions to common problems that arise during software development, providing a proven and standardized approach to solving these problems. They are often language-agnostic but can be implemented in various programming languages. In this topic, we will discuss the Singleton, Factory, and other design patterns in Python. ### The Singleton Design Pattern The Singleton design pattern is a creational pattern that restricts a class from instantiating multiple objects. It ensures that only one instance of the class is created and provides a global point of access to that instance. ```python class Singleton: _instance = None def __new__(cls): if cls._instance is None: cls._instance = super(Singleton, cls).__new__(cls) return cls._instance # Usage obj1 = Singleton() obj2 = Singleton() # Both obj1 and obj2 will reference the same instance print(obj1 is obj2) # Output: True ``` ### The Factory Design Pattern The Factory design pattern is a creational pattern that provides a way to create objects without specifying the exact class of object that will be created. ```python class Animal: def __init__(self, name): self.name = name class Dog(Animal): pass class Cat(Animal): pass class AnimalFactory: @staticmethod def create_animal(animal_type, name): animals = { 'dog': Dog, 'cat': Cat } return animals[animal_type](name) # Usage dog = AnimalFactory.create_animal('dog', 'Fido') cat = AnimalFactory.create_animal('cat', 'Whiskers') print(dog.name) # Output: Fido print(cat.name) # Output: Whiskers ``` ### Other Design Patterns Some other design patterns commonly used in Python include: * Observer pattern: allows objects to notify other objects of state changes. * Strategy pattern: defines a family of algorithms and selects one at runtime. * Decorator pattern: allows behavior to be added to an individual object. * Command pattern: encapsulates a request as an object. Here is an example of the Observer pattern: ```python class Subject: def __init__(self): self.observers = [] def attach(self, observer): self.observers.append(observer) def detach(self, observer): self.observers.remove(observer) def notify(self, modifier=None): for observer in self.observers: if modifier != observer: observer.update(self) class Data(Subject): def __init__(self, name=''): super().__init__() self.name = name self._data = 0 @property def data(self): return self._data @data.setter def data(self, value): self._data = value self.notify() class HexViewer: def update(self, subject): print(f'HexViewer: {subject.name} has data 0x{subject.data:x}') class DecimalViewer: def update(self, subject): print(f'DecimalViewer: {subject.name} has data {subject.data}') # Usage data1 = Data('Data 1') data2 = Data('Data 2') view1 = DecimalViewer() view2 = HexViewer() data1.attach(view1) data1.attach(view2) data2.attach(view2) data2.attach(view1) print("Setting Data 1 = 10") data1.data = 10 print("Setting Data 2 = 15") data2.data = 15 print("Setting Data 1 = 3") data1.data = 3 print("Setting Data 2 = 5") data2.data = 5 ``` ### Conclusion and Takeaways Design patterns provide a proven approach to solving common problems in software development. By understanding and using these patterns, you can write more maintainable, flexible, and scalable code. Some key takeaways from this topic include: * Singleton pattern: restricts a class from instantiating multiple objects, providing a global point of access to that instance. * Factory pattern: provides a way to create objects without specifying the exact class of object that will be created. * Observer pattern: allows objects to notify other objects of state changes. **External Resources:** * [Official Design Patterns documentation](https://docs.python.org/3/tutorial/classes.html) * [Design Patterns in Python](https://refactoring.guru/design-patterns/python) **Help and Discussion:** Leave a comment below if you have any questions or need further clarification on any topic. The comment section is the place for discussion and asking for help.