{"id":110,"date":"2023-09-22T22:32:26","date_gmt":"2023-09-22T17:02:26","guid":{"rendered":"https:\/\/farrukhnaveed.co\/blogs\/?p=110"},"modified":"2023-09-22T22:53:29","modified_gmt":"2023-09-22T17:23:29","slug":"design-patterns-in-python","status":"publish","type":"post","link":"https:\/\/farrukhnaveed.co\/blogs\/design-patterns-in-python\/","title":{"rendered":"Design Patterns in Python"},"content":{"rendered":"\n

Design patterns are essential tools for developers to create maintainable, efficient, and scalable software solutions. These patterns provide reusable solutions to common problems in software design. In Python, a versatile and dynamic language, you can implement various design patterns to enhance code organization and readability. In this article, we’ll explore some of the most commonly used design patterns in Python.<\/p>\n\n\n\n

1. Singleton Pattern<\/h2>\n\n\n\n

The Singleton pattern ensures that a class has only one instance and provides a global point of access to it. This is useful when you want to restrict the instantiation of a class to a single object, such as a configuration manager or a logging service.<\/p>\n\n\n\n

<\/circle><\/circle><\/circle><\/g><\/svg><\/span><\/path><\/path><\/svg><\/span>
class<\/span> <\/span>Singleton<\/span>:<\/span><\/span>\n    _instance <\/span>=<\/span> <\/span>None<\/span><\/span>\n<\/span>\n    <\/span>def<\/span> <\/span>__new__<\/span>(<\/span>cls<\/span>):<\/span><\/span>\n        <\/span>if<\/span> <\/span>cls<\/span>.<\/span>_instance <\/span>is<\/span> <\/span>None<\/span>:<\/span><\/span>\n            <\/span>cls<\/span>.<\/span>_instance <\/span>=<\/span> <\/span>super<\/span>(<\/span>Singleton<\/span>,<\/span> <\/span>cls<\/span>).<\/span>__new__<\/span>(<\/span>cls<\/span>)<\/span><\/span>\n        <\/span>return<\/span> <\/span>cls<\/span>.<\/span>_instance<\/span><\/span>\n<\/span><\/code><\/pre><\/div>\n\n\n\n
2. Factory Method Pattern<\/h2>\n\n\n\n
The Factory Method pattern defines an interface for creating an object but lets subclasses alter the type of objects that will be created. It’s useful for creating objects with similar behavior but different implementations.<\/p>\n\n\n\n
<\/circle><\/circle><\/circle><\/g><\/svg><\/span><\/path><\/path><\/svg><\/span>
from<\/span> abc <\/span>import<\/span> ABC<\/span>,<\/span> abstractmethod<\/span><\/span>\n<\/span>\nclass<\/span> <\/span>Creator<\/span>(<\/span>ABC<\/span>):<\/span><\/span>\n    <\/span>@<\/span>abstractmethod<\/span><\/span>\n    <\/span>def<\/span> <\/span>factory_method<\/span>(<\/span>self<\/span>):<\/span><\/span>\n        <\/span>pass<\/span><\/span>\n<\/span>\n    <\/span>def<\/span> <\/span>some_operation<\/span>(<\/span>self<\/span>):<\/span><\/span>\n        product <\/span>=<\/span> <\/span>self<\/span>.<\/span>factory_method<\/span>()<\/span><\/span>\n        <\/span>return<\/span> <\/span>f<\/span>"Creator: <\/span>{<\/span>product<\/span>.<\/span>operation<\/span>()<\/span>}<\/span>"<\/span><\/span>\n<\/span>\nclass<\/span> <\/span>ConcreteCreator1<\/span>(<\/span>Creator<\/span>):<\/span><\/span>\n    <\/span>def<\/span> <\/span>factory_method<\/span>(<\/span>self<\/span>):<\/span><\/span>\n        <\/span>return<\/span> <\/span>ConcreteProduct1<\/span>()<\/span><\/span>\n<\/span>\nclass<\/span> <\/span>ConcreteCreator2<\/span>(<\/span>Creator<\/span>):<\/span><\/span>\n    <\/span>def<\/span> <\/span>factory_method<\/span>(<\/span>self<\/span>):<\/span><\/span>\n        <\/span>return<\/span> <\/span>ConcreteProduct2<\/span>()<\/span><\/span>\n<\/span>\nclass<\/span> <\/span>Product<\/span>(<\/span>ABC<\/span>):<\/span><\/span>\n    <\/span>@<\/span>abstractmethod<\/span><\/span>\n    <\/span>def<\/span> <\/span>operation<\/span>(<\/span>self<\/span>):<\/span><\/span>\n        <\/span>pass<\/span><\/span>\n<\/span>\nclass<\/span> <\/span>ConcreteProduct1<\/span>(<\/span>Product<\/span>):<\/span><\/span>\n    <\/span>def<\/span> <\/span>operation<\/span>(<\/span>self<\/span>):<\/span><\/span>\n        <\/span>return<\/span> <\/span>"<\/span>ConcreteProduct1<\/span>"<\/span><\/span>\n<\/span>\nclass<\/span> <\/span>ConcreteProduct2<\/span>(<\/span>Product<\/span>):<\/span><\/span>\n    <\/span>def<\/span> <\/span>operation<\/span>(<\/span>self<\/span>):<\/span><\/span>\n        <\/span>return<\/span> <\/span>"<\/span>ConcreteProduct2<\/span>"<\/span><\/span>\n<\/span><\/code><\/pre><\/div>\n\n\n\n
3. Observer Pattern<\/h2>\n\n\n\n
The Observer pattern defines a one-to-many dependency between objects so that when one object changes state, all its dependents are notified and updated automatically. This pattern is widely used in event handling systems.<\/p>\n\n\n\n
<\/circle><\/circle><\/circle><\/g><\/svg><\/span><\/path><\/path><\/svg><\/span>
class<\/span> <\/span>Subject<\/span>:<\/span><\/span>\n    <\/span>def<\/span> <\/span>__init__<\/span>(<\/span>self<\/span>):<\/span><\/span>\n        <\/span>self<\/span>.<\/span>_observers <\/span>=<\/span> <\/span>[]<\/span><\/span>\n<\/span>\n    <\/span>def<\/span> <\/span>attach<\/span>(<\/span>self<\/span>,<\/span> <\/span>observer<\/span>):<\/span><\/span>\n        <\/span>self<\/span>.<\/span>_observers<\/span>.<\/span>append<\/span>(<\/span>observer<\/span>)<\/span><\/span>\n<\/span>\n    <\/span>def<\/span> <\/span>detach<\/span>(<\/span>self<\/span>,<\/span> <\/span>observer<\/span>):<\/span><\/span>\n        <\/span>self<\/span>.<\/span>_observers<\/span>.<\/span>remove<\/span>(<\/span>observer<\/span>)<\/span><\/span>\n<\/span>\n    <\/span>def<\/span> <\/span>notify<\/span>(<\/span>self<\/span>):<\/span><\/span>\n        <\/span>for<\/span> observer <\/span>in<\/span> <\/span>self<\/span>.<\/span>_observers<\/span>:<\/span><\/span>\n            observer<\/span>.<\/span>update<\/span>()<\/span><\/span>\n<\/span>\nclass<\/span> <\/span>ConcreteSubject<\/span>(<\/span>Subject<\/span>):<\/span><\/span>\n    <\/span>def<\/span> <\/span>set_state<\/span>(<\/span>self<\/span>,<\/span> <\/span>state<\/span>):<\/span><\/span>\n        <\/span>self<\/span>.<\/span>_state <\/span>=<\/span> state<\/span><\/span>\n        <\/span>self<\/span>.<\/span>notify<\/span>()<\/span><\/span>\n<\/span>\n    <\/span>def<\/span> <\/span>get_state<\/span>(<\/span>self<\/span>):<\/span><\/span>\n        <\/span>return<\/span> <\/span>self<\/span>.<\/span>_state<\/span><\/span>\n<\/span>\nclass<\/span> <\/span>Observer<\/span>:<\/span><\/span>\n    <\/span>def<\/span> <\/span>update<\/span>(<\/span>self<\/span>):<\/span><\/span>\n        <\/span>pass<\/span><\/span>\n<\/span>\nclass<\/span> <\/span>ConcreteObserver<\/span>(<\/span>Observer<\/span>):<\/span><\/span>\n    <\/span>def<\/span> <\/span>__init__<\/span>(<\/span>self<\/span>,<\/span> <\/span>subject<\/span>):<\/span><\/span>\n        <\/span>self<\/span>.<\/span>_subject <\/span>=<\/span> subject<\/span><\/span>\n        <\/span>self<\/span>.<\/span>_state <\/span>=<\/span> <\/span>None<\/span><\/span>\n        <\/span>self<\/span>.<\/span>_subject<\/span>.<\/span>attach<\/span>(<\/span>self<\/span>)<\/span><\/span>\n<\/span>\n    <\/span>def<\/span> <\/span>update<\/span>(<\/span>self<\/span>):<\/span><\/span>\n        <\/span>self<\/span>.<\/span>_state <\/span>=<\/span> <\/span>self<\/span>.<\/span>_subject<\/span>.<\/span>get_state<\/span>()<\/span><\/span>\n<\/span><\/code><\/pre><\/div>\n\n\n\n
4. Strategy Pattern<\/h2>\n\n\n\n
The Strategy pattern defines a family of algorithms, encapsulates each one, and makes them interchangeable. It allows you to select an algorithm at runtime, providing flexibility in behavior.<\/p>\n\n\n\n
<\/circle><\/circle><\/circle><\/g><\/svg><\/span><\/path><\/path><\/svg><\/span>
from<\/span> abc <\/span>import<\/span> ABC<\/span>,<\/span> abstractmethod<\/span><\/span>\n<\/span>\nclass<\/span> <\/span>Strategy<\/span>(<\/span>ABC<\/span>):<\/span><\/span>\n    <\/span>@<\/span>abstractmethod<\/span><\/span>\n    <\/span>def<\/span> <\/span>execute<\/span>(<\/span>self<\/span>):<\/span><\/span>\n        <\/span>pass<\/span><\/span>\n<\/span>\nclass<\/span> <\/span>ConcreteStrategyA<\/span>(<\/span>Strategy<\/span>):<\/span><\/span>\n    <\/span>def<\/span> <\/span>execute<\/span>(<\/span>self<\/span>):<\/span><\/span>\n        <\/span>return<\/span> <\/span>"<\/span>Strategy A<\/span>"<\/span><\/span>\n<\/span>\nclass<\/span> <\/span>ConcreteStrategyB<\/span>(<\/span>Strategy<\/span>):<\/span><\/span>\n    <\/span>def<\/span> <\/span>execute<\/span>(<\/span>self<\/span>):<\/span><\/span>\n        <\/span>return<\/span> <\/span>"<\/span>Strategy B<\/span>"<\/span><\/span>\n<\/span>\nclass<\/span> <\/span>Context<\/span>:<\/span><\/span>\n    <\/span>def<\/span> <\/span>__init__<\/span>(<\/span>self<\/span>,<\/span> <\/span>strategy<\/span>):<\/span><\/span>\n        <\/span>self<\/span>.<\/span>_strategy <\/span>=<\/span> strategy<\/span><\/span>\n<\/span>\n    <\/span>def<\/span> <\/span>context_interface<\/span>(<\/span>self<\/span>):<\/span><\/span>\n        <\/span>return<\/span> <\/span>self<\/span>.<\/span>_strategy<\/span>.<\/span>execute<\/span>()<\/span><\/span>\n<\/span><\/code><\/pre><\/div>\n\n\n\n
5. Decorator Pattern<\/h2>\n\n\n\n
The Decorator pattern allows behavior to be added to individual objects, either statically or dynamically, without affecting the behavior of other objects from the same class. It’s useful for adding features to classes without subclassing.<\/p>\n\n\n\n
<\/circle><\/circle><\/circle><\/g><\/svg><\/span><\/path><\/path><\/svg><\/span>
class<\/span> <\/span>Component<\/span>:<\/span><\/span>\n    <\/span>def<\/span> <\/span>operation<\/span>(<\/span>self<\/span>):<\/span><\/span>\n        <\/span>pass<\/span><\/span>\n<\/span>\nclass<\/span> <\/span>ConcreteComponent<\/span>(<\/span>Component<\/span>):<\/span><\/span>\n    <\/span>def<\/span> <\/span>operation<\/span>(<\/span>self<\/span>):<\/span><\/span>\n        <\/span>return<\/span> <\/span>"<\/span>ConcreteComponent<\/span>"<\/span><\/span>\n<\/span>\nclass<\/span> <\/span>Decorator<\/span>(<\/span>Component<\/span>):<\/span><\/span>\n    <\/span>def<\/span> <\/span>__init__<\/span>(<\/span>self<\/span>,<\/span> <\/span>component<\/span>):<\/span><\/span>\n        <\/span>self<\/span>.<\/span>_component <\/span>=<\/span> component<\/span><\/span>\n<\/span>\n    <\/span>def<\/span> <\/span>operation<\/span>(<\/span>self<\/span>):<\/span><\/span>\n        <\/span>return<\/span> <\/span>self<\/span>.<\/span>_component<\/span>.<\/span>operation<\/span>()<\/span><\/span>\n<\/span>\nclass<\/span> <\/span>ConcreteDecoratorA<\/span>(<\/span>Decorator<\/span>):<\/span><\/span>\n    <\/span>def<\/span> <\/span>operation<\/span>(<\/span>self<\/span>):<\/span><\/span>\n        <\/span>return<\/span> <\/span>f<\/span>"ConcreteDecoratorA(<\/span>{<\/span>self<\/span>.<\/span>_component<\/span>.<\/span>operation<\/span>()<\/span>}<\/span>)"<\/span><\/span>\n<\/span>\nclass<\/span> <\/span>ConcreteDecoratorB<\/span>(<\/span>Decorator<\/span>):<\/span><\/span>\n    <\/span>def<\/span> <\/span>operation<\/span>(<\/span>self<\/span>):<\/span><\/span>\n        <\/span>return<\/span> <\/span>f<\/span>"ConcreteDecoratorB(<\/span>{<\/span>self<\/span>.<\/span>_component<\/span>.<\/span>operation<\/span>()<\/span>}<\/span>)"<\/span><\/span>\n<\/span><\/code><\/pre><\/div>\n\n\n\n
5. Facade Pattern<\/h2>\n\n\n\n
The Facade pattern is a structural design pattern that provides a simplified interface to a complex system of classes, making it easier to use and understand. It acts as a “facade” or an entry point to a set of interfaces or classes, hiding the underlying complexity from the client. Here’s an example of the Facade pattern in Python:<\/p>\n\n\n\n
<\/circle><\/circle><\/circle><\/g><\/svg><\/span><\/path><\/path><\/svg><\/span>
# Complex subsystem classes<\/span><\/span>\nclass<\/span> <\/span>Subsystem1<\/span>:<\/span><\/span>\n    <\/span>def<\/span> <\/span>operation1<\/span>(<\/span>self<\/span>):<\/span><\/span>\n        <\/span>return<\/span> <\/span>"<\/span>Subsystem 1: Operation 1<\/span>"<\/span><\/span>\n<\/span>\n    <\/span>def<\/span> <\/span>operation2<\/span>(<\/span>self<\/span>):<\/span><\/span>\n        <\/span>return<\/span> <\/span>"<\/span>Subsystem 1: Operation 2<\/span>"<\/span><\/span>\n<\/span>\nclass<\/span> <\/span>Subsystem2<\/span>:<\/span><\/span>\n    <\/span>def<\/span> <\/span>operation1<\/span>(<\/span>self<\/span>):<\/span><\/span>\n        <\/span>return<\/span> <\/span>"<\/span>Subsystem 2: Operation 1<\/span>"<\/span><\/span>\n<\/span>\n    <\/span>def<\/span> <\/span>operation2<\/span>(<\/span>self<\/span>):<\/span><\/span>\n        <\/span>return<\/span> <\/span>"<\/span>Subsystem 2: Operation 2<\/span>"<\/span><\/span>\n<\/span>\n# Facade class<\/span><\/span>\nclass<\/span> <\/span>Facade<\/span>:<\/span><\/span>\n    <\/span>def<\/span> <\/span>__init__<\/span>(<\/span>self<\/span>):<\/span><\/span>\n        <\/span>self<\/span>.<\/span>_subsystem1 <\/span>=<\/span> <\/span>Subsystem1<\/span>()<\/span><\/span>\n        <\/span>self<\/span>.<\/span>_subsystem2 <\/span>=<\/span> <\/span>Subsystem2<\/span>()<\/span><\/span>\n<\/span>\n    <\/span>def<\/span> <\/span>operation<\/span>(<\/span>self<\/span>):<\/span><\/span>\n        result <\/span>=<\/span> <\/span>[]<\/span><\/span>\n        result<\/span>.<\/span>append<\/span>(<\/span>"<\/span>Facade initializes subsystems:<\/span>"<\/span>)<\/span><\/span>\n        result<\/span>.<\/span>append<\/span>(<\/span>self<\/span>.<\/span>_subsystem1<\/span>.<\/span>operation1<\/span>())<\/span><\/span>\n        result<\/span>.<\/span>append<\/span>(<\/span>self<\/span>.<\/span>_subsystem2<\/span>.<\/span>operation1<\/span>())<\/span><\/span>\n        result<\/span>.<\/span>append<\/span>(<\/span>"<\/span>Facade orders subsystems to perform the action:<\/span>"<\/span>)<\/span><\/span>\n        result<\/span>.<\/span>append<\/span>(<\/span>self<\/span>.<\/span>_subsystem1<\/span>.<\/span>operation2<\/span>())<\/span><\/span>\n        result<\/span>.<\/span>append<\/span>(<\/span>self<\/span>.<\/span>_subsystem2<\/span>.<\/span>operation2<\/span>())<\/span><\/span>\n        <\/span>return<\/span> <\/span>"<\/span>\\n<\/span>"<\/span>.<\/span>join<\/span>(<\/span>result<\/span>)<\/span><\/span>\n<\/span>\n# Client code<\/span><\/span>\ndef<\/span> <\/span>main<\/span>():<\/span><\/span>\n    facade <\/span>=<\/span> <\/span>Facade<\/span>()<\/span><\/span>\n    result <\/span>=<\/span> facade<\/span>.<\/span>operation<\/span>()<\/span><\/span>\n    <\/span>print<\/span>(<\/span>result<\/span>)<\/span><\/span>\n<\/span>\nif<\/span> __name__ <\/span>==<\/span> <\/span>"<\/span>__main__<\/span>"<\/span>:<\/span><\/span>\n    <\/span>main<\/span>()<\/span><\/span>\n<\/span><\/code><\/pre><\/div>\n\n\n\n
6. Dependency Injection Pattern<\/h2>\n\n\n\n
The Dependency Injection pattern revolves around the concept of separating the concerns of creating objects and using objects. It ensures that an object’s dependencies (e.g., other objects, services, or values) are provided from the outside, rather than being created or instantiated internally. This approach promotes the Single Responsibility Principle and allows for better testability and flexibility in your codebase.<\/p>\n\n\n\n
There are three common types of dependency injection:<\/p>\n\n\n\n
    \n
  1. Constructor Injection:<\/strong> Dependencies are injected through a class’s constructor. This is the most common form of dependency injection and is often used when dependencies are required for the class to function correctly.<\/li>\n\n\n\n
  2. Method Injection:<\/strong> Dependencies are injected through methods, typically setter methods. This is useful when you have optional dependencies or when you want to change a class’s behavior during runtime by providing different dependencies.<\/li>\n\n\n\n
  3. Property Injection:<\/strong> Dependencies are injected into a class’s properties or attributes. This is less common but can be used when you need to inject dependencies into an existing instance of a class.<\/li>\n<\/ol>\n\n\n\n
    <\/circle><\/circle><\/circle><\/g><\/svg><\/span><\/path><\/path><\/svg><\/span>
    class<\/span> <\/span>DataFetcher<\/span>:<\/span><\/span>\n    <\/span>def<\/span> <\/span>fetch_data<\/span>(<\/span>self<\/span>):<\/span><\/span>\n        <\/span># Simulate fetching data from a database<\/span><\/span>\n        <\/span>return<\/span> <\/span>"<\/span>Data fetched from the database<\/span>"<\/span><\/span>\n<\/span>\n<\/span>\nclass<\/span> <\/span>ReportGenerator<\/span>:<\/span><\/span>\n    <\/span>def<\/span> <\/span>__init__<\/span>(<\/span>self<\/span>,<\/span> <\/span>data_fetcher<\/span>):<\/span><\/span>\n        <\/span>self<\/span>.<\/span>data_fetcher <\/span>=<\/span> data_fetcher<\/span><\/span>\n<\/span>\n    <\/span>def<\/span> <\/span>generate_report<\/span>(<\/span>self<\/span>):<\/span><\/span>\n        data <\/span>=<\/span> <\/span>self<\/span>.<\/span>data_fetcher<\/span>.<\/span>fetch_data<\/span>()<\/span><\/span>\n        <\/span># Generate the report using the fetched data<\/span><\/span>\n        <\/span>return<\/span> <\/span>f<\/span>"Generated report with data: <\/span>{<\/span>data<\/span>}<\/span>"<\/span><\/span>\n<\/span>\n<\/span>\ndef<\/span> <\/span>main<\/span>():<\/span><\/span>\n    <\/span># Create instances of DataFetcher and ReportGenerator<\/span><\/span>\n    data_fetcher <\/span>=<\/span> <\/span>DataFetcher<\/span>()<\/span><\/span>\n    report_generator <\/span>=<\/span> <\/span>ReportGenerator<\/span>(<\/span>data_fetcher<\/span>)<\/span><\/span>\n<\/span>\n    <\/span># Generate a report<\/span><\/span>\n    report <\/span>=<\/span> report_generator<\/span>.<\/span>generate_report<\/span>()<\/span><\/span>\n<\/span>\n    <\/span># Print the report<\/span><\/span>\n    <\/span>print<\/span>(<\/span>report<\/span>)<\/span><\/span>\n<\/span>\n<\/span>\nif<\/span> __name__ <\/span>==<\/span> <\/span>"<\/span>__main__<\/span>"<\/span>:<\/span><\/span>\n    <\/span>main<\/span>()<\/span><\/span>\n<\/span><\/code><\/pre><\/div>\n\n\n\n
    7. Adapter Pattern<\/h2>\n\n\n\n
    The Adapter pattern is a structural design pattern that allows objects with incompatible interfaces to work together. It acts as a bridge between two incompatible interfaces, making them compatible without changing their source code. This pattern is especially useful when you want to reuse existing classes, integrate third-party libraries, or work with legacy code that doesn’t match your required interface.<\/p>\n\n\n\n
    Key Components of the Adapter Pattern:<\/strong><\/p>\n\n\n\n
      \n
    1. Target:<\/strong> This is the interface or the expected behavior that the client code interacts with.<\/li>\n\n\n\n
    2. Adapter:<\/strong> This is the class that adapts the interface of an existing class or object to match the target interface.<\/li>\n\n\n\n
    3. Adaptee:<\/strong> This is the class or object that has the behavior or interface that needs to be adapted.<\/li>\n<\/ol>\n\n\n\n
      <\/circle><\/circle><\/circle><\/g><\/svg><\/span><\/path><\/path><\/svg><\/span>
      # Adaptee (existing class)<\/span><\/span>\nclass<\/span> <\/span>OldSystem<\/span>:<\/span><\/span>\n    <\/span>def<\/span> <\/span>legacy_operation<\/span>(<\/span>self<\/span>):<\/span><\/span>\n        <\/span>return<\/span> <\/span>"<\/span>Legacy operation from the OldSystem<\/span>"<\/span><\/span>\n<\/span>\n<\/span>\n# Target interface<\/span><\/span>\nclass<\/span> <\/span>NewSystem<\/span>:<\/span><\/span>\n    <\/span>def<\/span> <\/span>new_operation<\/span>(<\/span>self<\/span>):<\/span><\/span>\n        <\/span>pass<\/span><\/span>\n<\/span>\n<\/span>\n# Adapter class<\/span><\/span>\nclass<\/span> <\/span>Adapter<\/span>(<\/span>NewSystem<\/span>):<\/span><\/span>\n    <\/span>def<\/span> <\/span>__init__<\/span>(<\/span>self<\/span>,<\/span> <\/span>old_system<\/span>):<\/span><\/span>\n        <\/span>self<\/span>.<\/span>_old_system <\/span>=<\/span> old_system<\/span><\/span>\n<\/span>\n    <\/span>def<\/span> <\/span>new_operation<\/span>(<\/span>self<\/span>):<\/span><\/span>\n        <\/span>return<\/span> <\/span>self<\/span>.<\/span>_old_system<\/span>.<\/span>legacy_operation<\/span>()<\/span><\/span>\n<\/span>\n<\/span>\n# Client code using the NewSystem<\/span><\/span>\ndef<\/span> <\/span>use_new_system<\/span>(<\/span>new_system<\/span>):<\/span><\/span>\n    result <\/span>=<\/span> new_system<\/span>.<\/span>new_operation<\/span>()<\/span><\/span>\n    <\/span>print<\/span>(<\/span>result<\/span>)<\/span><\/span>\n<\/span>\n<\/span>\ndef<\/span> <\/span>main<\/span>():<\/span><\/span>\n    <\/span># Using the Adapter to make OldSystem compatible with NewSystem<\/span><\/span>\n    old_system <\/span>=<\/span> <\/span>OldSystem<\/span>()<\/span><\/span>\n    adapter <\/span>=<\/span> <\/span>Adapter<\/span>(<\/span>old_system<\/span>)<\/span><\/span>\n<\/span>\n    <\/span># Client code uses NewSystem interface<\/span><\/span>\n    <\/span>use_new_system<\/span>(<\/span>adapter<\/span>)<\/span><\/span>\n<\/span>\n<\/span>\nif<\/span> __name__ <\/span>==<\/span> <\/span>"<\/span>__main__<\/span>"<\/span>:<\/span><\/span>\n    <\/span>main<\/span>()<\/span><\/span>\n<\/span><\/code><\/pre><\/div>\n","protected":false},"excerpt":{"rendered":"
      Design patterns are essential tools for developers to create maintainable, efficient, and scalable software solutions. These patterns provide reusable solutions to common problems in software […]<\/p>\n","protected":false},"author":1,"featured_media":119,"comment_status":"closed","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[18,4],"tags":[17,5],"class_list":["post-110","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-design-patterns","category-python","tag-design-patterns","tag-python"],"yoast_head":"\nDesign Patterns in Python - Farrukh's Tech Space<\/title>\n<meta name=\"description\" content=\"Design patterns are essential tools for developers to create maintainable, efficient, and scalable software solutions. These patterns provide reusable solutions to common problems in software design. In Python, a versatile and dynamic language, you can implement various design patterns to enhance code organization and readability. In this article, we'll explore some of the most commonly used design patterns in Python.\" \/>\n<meta name=\"robots\" content=\"index, follow, max-snippet:-1, max-image-preview:large, max-video-preview:-1\" \/>\n<link rel=\"canonical\" href=\"https:\/\/farrukhnaveed.co\/blogs\/design-patterns-in-python\/\" \/>\n<meta property=\"og:locale\" content=\"en_US\" \/>\n<meta property=\"og:type\" content=\"article\" \/>\n<meta property=\"og:title\" content=\"Design Patterns in Python\" \/>\n<meta property=\"og:description\" content=\"Design patterns are essential tools for developers to create maintainable, efficient, and scalable software solutions. These patterns provide reusable solutions to common problems in software design. In Python, a versatile and dynamic language, you can implement various design patterns to enhance code organization and readability. In this article, we'll explore some of the most commonly used design patterns in Python.\" \/>\n<meta property=\"og:url\" content=\"https:\/\/farrukhnaveed.co\/blogs\/design-patterns-in-python\/\" \/>\n<meta property=\"og:site_name\" content=\"Farrukh's Tech Space\" \/>\n<meta property=\"article:published_time\" content=\"2023-09-22T17:02:26+00:00\" \/>\n<meta property=\"article:modified_time\" content=\"2023-09-22T17:23:29+00:00\" \/>\n<meta property=\"og:image\" content=\"https:\/\/farrukhnaveed.co\/blogs\/wp-content\/uploads\/2023\/09\/Design-Patterns-1.jpg\" \/>\n\t<meta property=\"og:image:width\" content=\"1147\" \/>\n\t<meta property=\"og:image:height\" content=\"621\" \/>\n\t<meta property=\"og:image:type\" content=\"image\/jpeg\" \/>\n<meta name=\"author\" content=\"Farrukh Naveed Anjum\" \/>\n<meta name=\"twitter:card\" content=\"summary_large_image\" \/>\n<meta name=\"twitter:title\" content=\"Design Patterns in Python\" \/>\n<meta name=\"twitter:description\" content=\"Design patterns are essential tools for developers to create maintainable, efficient, and scalable software solutions. These patterns provide reusable solutions to common problems in software design. In Python, a versatile and dynamic language, you can implement various design patterns to enhance code organization and readability. In this article, we'll explore some of the most commonly used design patterns in Python.\" \/>\n<meta name=\"twitter:image\" content=\"https:\/\/farrukhnaveed.co\/blogs\/wp-content\/uploads\/2023\/09\/Design-Patterns-1.jpg\" \/>\n<meta name=\"twitter:label1\" content=\"Written by\" \/>\n\t<meta name=\"twitter:data1\" content=\"Farrukh Naveed Anjum\" \/>\n\t<meta name=\"twitter:label2\" content=\"Est. reading time\" \/>\n\t<meta name=\"twitter:data2\" content=\"3 minutes\" \/>\n<script type=\"application\/ld+json\" class=\"yoast-schema-graph\">{\"@context\":\"https:\/\/schema.org\",\"@graph\":[{\"@type\":\"Article\",\"@id\":\"https:\/\/farrukhnaveed.co\/blogs\/design-patterns-in-python\/#article\",\"isPartOf\":{\"@id\":\"https:\/\/farrukhnaveed.co\/blogs\/design-patterns-in-python\/\"},\"author\":{\"name\":\"Farrukh Naveed Anjum\",\"@id\":\"https:\/\/farrukhnaveed.co\/blogs\/#\/schema\/person\/ce7d07e6a917b9b73aa79007a2357d29\"},\"headline\":\"Design Patterns in Python\",\"datePublished\":\"2023-09-22T17:02:26+00:00\",\"dateModified\":\"2023-09-22T17:23:29+00:00\",\"mainEntityOfPage\":{\"@id\":\"https:\/\/farrukhnaveed.co\/blogs\/design-patterns-in-python\/\"},\"wordCount\":609,\"publisher\":{\"@id\":\"https:\/\/farrukhnaveed.co\/blogs\/#organization\"},\"keywords\":[\"Design Patterns\",\"Python\"],\"articleSection\":[\"Design Patterns\",\"Python\"],\"inLanguage\":\"en-US\"},{\"@type\":\"WebPage\",\"@id\":\"https:\/\/farrukhnaveed.co\/blogs\/design-patterns-in-python\/\",\"url\":\"https:\/\/farrukhnaveed.co\/blogs\/design-patterns-in-python\/\",\"name\":\"Design Patterns in Python - Farrukh's Tech Space\",\"isPartOf\":{\"@id\":\"https:\/\/farrukhnaveed.co\/blogs\/#website\"},\"datePublished\":\"2023-09-22T17:02:26+00:00\",\"dateModified\":\"2023-09-22T17:23:29+00:00\",\"description\":\"Design patterns are essential tools for developers to create maintainable, efficient, and scalable software solutions. These patterns provide reusable solutions to common problems in software design. In Python, a versatile and dynamic language, you can implement various design patterns to enhance code organization and readability. In this article, we'll explore some of the most commonly used design patterns in Python.\",\"inLanguage\":\"en-US\",\"potentialAction\":[{\"@type\":\"ReadAction\",\"target\":[\"https:\/\/farrukhnaveed.co\/blogs\/design-patterns-in-python\/\"]}]},{\"@type\":\"WebSite\",\"@id\":\"https:\/\/farrukhnaveed.co\/blogs\/#website\",\"url\":\"https:\/\/farrukhnaveed.co\/blogs\/\",\"name\":\"Farrukh Naveed Anjum Blogs\",\"description\":\"Empowering Software Architects with Knowledge on Big Data and AI\",\"publisher\":{\"@id\":\"https:\/\/farrukhnaveed.co\/blogs\/#organization\"},\"potentialAction\":[{\"@type\":\"SearchAction\",\"target\":{\"@type\":\"EntryPoint\",\"urlTemplate\":\"https:\/\/farrukhnaveed.co\/blogs\/?s={search_term_string}\"},\"query-input\":\"required name=search_term_string\"}],\"inLanguage\":\"en-US\"},{\"@type\":\"Organization\",\"@id\":\"https:\/\/farrukhnaveed.co\/blogs\/#organization\",\"name\":\"Farrukh Naveed Anjum Blogs\",\"url\":\"https:\/\/farrukhnaveed.co\/blogs\/\",\"logo\":{\"@type\":\"ImageObject\",\"inLanguage\":\"en-US\",\"@id\":\"https:\/\/farrukhnaveed.co\/blogs\/#\/schema\/logo\/image\/\",\"url\":\"https:\/\/farrukhnaveed.co\/blogs\/wp-content\/uploads\/2023\/06\/IMG_5018-scaled.jpg\",\"contentUrl\":\"https:\/\/farrukhnaveed.co\/blogs\/wp-content\/uploads\/2023\/06\/IMG_5018-scaled.jpg\",\"width\":1707,\"height\":2560,\"caption\":\"Farrukh Naveed Anjum Blogs\"},\"image\":{\"@id\":\"https:\/\/farrukhnaveed.co\/blogs\/#\/schema\/logo\/image\/\"}},{\"@type\":\"Person\",\"@id\":\"https:\/\/farrukhnaveed.co\/blogs\/#\/schema\/person\/ce7d07e6a917b9b73aa79007a2357d29\",\"name\":\"Farrukh Naveed Anjum\",\"image\":{\"@type\":\"ImageObject\",\"inLanguage\":\"en-US\",\"@id\":\"https:\/\/farrukhnaveed.co\/blogs\/#\/schema\/person\/image\/\",\"url\":\"https:\/\/secure.gravatar.com\/avatar\/bdf1af0d569259df562434e6dc99415a377c6fc053f9e1507aa34a6522561bb8?s=96&d=mm&r=g\",\"contentUrl\":\"https:\/\/secure.gravatar.com\/avatar\/bdf1af0d569259df562434e6dc99415a377c6fc053f9e1507aa34a6522561bb8?s=96&d=mm&r=g\",\"caption\":\"Farrukh Naveed Anjum\"},\"description\":\"Full Stack Developer and Software Architect with 14 years of experience in various domains, including Enterprise Resource Planning, Data Retrieval, Web Scraping, Real-Time Analytics, Cybersecurity, NLP, ED-Tech, and B2B Price Comparison\",\"sameAs\":[\"https:\/\/farrukhnaveed.co\/blog\"],\"url\":\"https:\/\/farrukhnaveed.co\/blogs\/author\/admin\/\"}]}<\/script>\n<!-- \/ Yoast SEO plugin. -->","yoast_head_json":{"title":"Design Patterns in Python - Farrukh's Tech Space","description":"Design patterns are essential tools for developers to create maintainable, efficient, and scalable software solutions. These patterns provide reusable solutions to common problems in software design. In Python, a versatile and dynamic language, you can implement various design patterns to enhance code organization and readability. In this article, we'll explore some of the most commonly used design patterns in Python.","robots":{"index":"index","follow":"follow","max-snippet":"max-snippet:-1","max-image-preview":"max-image-preview:large","max-video-preview":"max-video-preview:-1"},"canonical":"https:\/\/farrukhnaveed.co\/blogs\/design-patterns-in-python\/","og_locale":"en_US","og_type":"article","og_title":"Design Patterns in Python","og_description":"Design patterns are essential tools for developers to create maintainable, efficient, and scalable software solutions. These patterns provide reusable solutions to common problems in software design. In Python, a versatile and dynamic language, you can implement various design patterns to enhance code organization and readability. In this article, we'll explore some of the most commonly used design patterns in Python.","og_url":"https:\/\/farrukhnaveed.co\/blogs\/design-patterns-in-python\/","og_site_name":"Farrukh's Tech Space","article_published_time":"2023-09-22T17:02:26+00:00","article_modified_time":"2023-09-22T17:23:29+00:00","og_image":[{"width":1147,"height":621,"url":"https:\/\/farrukhnaveed.co\/blogs\/wp-content\/uploads\/2023\/09\/Design-Patterns-1.jpg","type":"image\/jpeg"}],"author":"Farrukh Naveed Anjum","twitter_card":"summary_large_image","twitter_title":"Design Patterns in Python","twitter_description":"Design patterns are essential tools for developers to create maintainable, efficient, and scalable software solutions. These patterns provide reusable solutions to common problems in software design. In Python, a versatile and dynamic language, you can implement various design patterns to enhance code organization and readability. In this article, we'll explore some of the most commonly used design patterns in Python.","twitter_image":"https:\/\/farrukhnaveed.co\/blogs\/wp-content\/uploads\/2023\/09\/Design-Patterns-1.jpg","twitter_misc":{"Written by":"Farrukh Naveed Anjum","Est. reading time":"3 minutes"},"schema":{"@context":"https:\/\/schema.org","@graph":[{"@type":"Article","@id":"https:\/\/farrukhnaveed.co\/blogs\/design-patterns-in-python\/#article","isPartOf":{"@id":"https:\/\/farrukhnaveed.co\/blogs\/design-patterns-in-python\/"},"author":{"name":"Farrukh Naveed Anjum","@id":"https:\/\/farrukhnaveed.co\/blogs\/#\/schema\/person\/ce7d07e6a917b9b73aa79007a2357d29"},"headline":"Design Patterns in Python","datePublished":"2023-09-22T17:02:26+00:00","dateModified":"2023-09-22T17:23:29+00:00","mainEntityOfPage":{"@id":"https:\/\/farrukhnaveed.co\/blogs\/design-patterns-in-python\/"},"wordCount":609,"publisher":{"@id":"https:\/\/farrukhnaveed.co\/blogs\/#organization"},"keywords":["Design Patterns","Python"],"articleSection":["Design Patterns","Python"],"inLanguage":"en-US"},{"@type":"WebPage","@id":"https:\/\/farrukhnaveed.co\/blogs\/design-patterns-in-python\/","url":"https:\/\/farrukhnaveed.co\/blogs\/design-patterns-in-python\/","name":"Design Patterns in Python - Farrukh's Tech Space","isPartOf":{"@id":"https:\/\/farrukhnaveed.co\/blogs\/#website"},"datePublished":"2023-09-22T17:02:26+00:00","dateModified":"2023-09-22T17:23:29+00:00","description":"Design patterns are essential tools for developers to create maintainable, efficient, and scalable software solutions. These patterns provide reusable solutions to common problems in software design. In Python, a versatile and dynamic language, you can implement various design patterns to enhance code organization and readability. In this article, we'll explore some of the most commonly used design patterns in Python.","inLanguage":"en-US","potentialAction":[{"@type":"ReadAction","target":["https:\/\/farrukhnaveed.co\/blogs\/design-patterns-in-python\/"]}]},{"@type":"WebSite","@id":"https:\/\/farrukhnaveed.co\/blogs\/#website","url":"https:\/\/farrukhnaveed.co\/blogs\/","name":"Farrukh Naveed Anjum Blogs","description":"Empowering Software Architects with Knowledge on Big Data and AI","publisher":{"@id":"https:\/\/farrukhnaveed.co\/blogs\/#organization"},"potentialAction":[{"@type":"SearchAction","target":{"@type":"EntryPoint","urlTemplate":"https:\/\/farrukhnaveed.co\/blogs\/?s={search_term_string}"},"query-input":"required name=search_term_string"}],"inLanguage":"en-US"},{"@type":"Organization","@id":"https:\/\/farrukhnaveed.co\/blogs\/#organization","name":"Farrukh Naveed Anjum Blogs","url":"https:\/\/farrukhnaveed.co\/blogs\/","logo":{"@type":"ImageObject","inLanguage":"en-US","@id":"https:\/\/farrukhnaveed.co\/blogs\/#\/schema\/logo\/image\/","url":"https:\/\/farrukhnaveed.co\/blogs\/wp-content\/uploads\/2023\/06\/IMG_5018-scaled.jpg","contentUrl":"https:\/\/farrukhnaveed.co\/blogs\/wp-content\/uploads\/2023\/06\/IMG_5018-scaled.jpg","width":1707,"height":2560,"caption":"Farrukh Naveed Anjum Blogs"},"image":{"@id":"https:\/\/farrukhnaveed.co\/blogs\/#\/schema\/logo\/image\/"}},{"@type":"Person","@id":"https:\/\/farrukhnaveed.co\/blogs\/#\/schema\/person\/ce7d07e6a917b9b73aa79007a2357d29","name":"Farrukh Naveed Anjum","image":{"@type":"ImageObject","inLanguage":"en-US","@id":"https:\/\/farrukhnaveed.co\/blogs\/#\/schema\/person\/image\/","url":"https:\/\/secure.gravatar.com\/avatar\/bdf1af0d569259df562434e6dc99415a377c6fc053f9e1507aa34a6522561bb8?s=96&d=mm&r=g","contentUrl":"https:\/\/secure.gravatar.com\/avatar\/bdf1af0d569259df562434e6dc99415a377c6fc053f9e1507aa34a6522561bb8?s=96&d=mm&r=g","caption":"Farrukh Naveed Anjum"},"description":"Full Stack Developer and Software Architect with 14 years of experience in various domains, including Enterprise Resource Planning, Data Retrieval, Web Scraping, Real-Time Analytics, Cybersecurity, NLP, ED-Tech, and B2B Price Comparison","sameAs":["https:\/\/farrukhnaveed.co\/blog"],"url":"https:\/\/farrukhnaveed.co\/blogs\/author\/admin\/"}]}},"_links":{"self":[{"href":"https:\/\/farrukhnaveed.co\/blogs\/wp-json\/wp\/v2\/posts\/110","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/farrukhnaveed.co\/blogs\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/farrukhnaveed.co\/blogs\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/farrukhnaveed.co\/blogs\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/farrukhnaveed.co\/blogs\/wp-json\/wp\/v2\/comments?post=110"}],"version-history":[{"count":4,"href":"https:\/\/farrukhnaveed.co\/blogs\/wp-json\/wp\/v2\/posts\/110\/revisions"}],"predecessor-version":[{"id":121,"href":"https:\/\/farrukhnaveed.co\/blogs\/wp-json\/wp\/v2\/posts\/110\/revisions\/121"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/farrukhnaveed.co\/blogs\/wp-json\/wp\/v2\/media\/119"}],"wp:attachment":[{"href":"https:\/\/farrukhnaveed.co\/blogs\/wp-json\/wp\/v2\/media?parent=110"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/farrukhnaveed.co\/blogs\/wp-json\/wp\/v2\/categories?post=110"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/farrukhnaveed.co\/blogs\/wp-json\/wp\/v2\/tags?post=110"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}