Understanding the Singleton Pattern

Welcome to the first lesson in our Creational Design Patterns course. We are starting with a powerful and widely used pattern: the Singleton Pattern . This pattern helps ensure that a class has only one instance and provides a global point of access to it. Understanding this pattern is a fantastic first step on your journey to mastering creational design patterns.

Introducing the Singleton Pattern

The Singleton Pattern is one of the simplest and most commonly used design patterns in software development. Its primary purpose is to restrict the instantiation of a class to a single object. This pattern provides a way to ensure that a class has only one instance and offers a global access point to that instance. Using the Singleton Pattern ensures that a class has only one instance, which simplifies the management of shared resources. This is particularly useful for scenarios such as managing configuration settings, handling logging, or controlling access to a shared database connection. By implementing the Singleton Pattern, you avoid the redundant creation of multiple instances and maintain consistent behavior across your application. Imagine you are building an application that needs to load configuration settings from a file. If each module within the application creates its own instance of the configuration loader, you could end up with unnecessary duplicates and inconsistencies. By using the Singleton Pattern, you ensure that all parts of the application use the same instance of the configuration loader, thereby maintaining a consistent and efficient approach to configuration management.

Introducing the @staticmethod

In Python, the @staticmethod decorator is used to define static methods within a class. These methods do not depend on instance variables and do not modify the class state. When implementing the Singleton Pattern, static methods are crucial because they allow you to define methods that can be called on the class itself without needing an instance. Static methods have no knowledge of the class or instance they belong to, making them purely functional methods that don't rely on the state of an object. This is particularly useful in scenarios where you want to group related utility functions inside a class but don't need these functions to modify instance-level state or behave differently across instances. For implementing the Singleton Pattern, the use of @staticmethod ensures that the method responsible for instance control remains independent of instance-specific data, focusing solely on the logic for creating and retrieving the single instance. By using a static method, you can implement logic to control instance creation. For the Singleton Pattern, this logic will check whether an instance of the class already exists. If it does, the existing instance is returned. Otherwise, a new instance is created and stored.

Join the 1M+ learners on CodeSignal

Be a part of our community of 1M+ users who develop and demonstrate their skills on CodeSignal

Real-World Example

Consider an example implementation of the Singleton Pattern with a Logger class.

Python

class Logger:
    __instance = None

    @staticmethod
    def getInstance():
        if Logger.__instance == None:
            Logger.__instance = Logger()
        return Logger.__instance

    def log(self, message):
        print(message)

if __name__ == "__main__":
    logger = Logger.getInstance()
    logger.log("Singleton pattern example with Logger.") # Output: Singleton pattern example with Logger.
    another_logger = Logger.getInstance()
    print(logger is another_logger)  # This will print True, as only one instance should exist

class Logger:
    __instance = None

    @staticmethod
    def getInstance():
        if Logger.__instance == None:
            Logger.__instance = Logger()
        return Logger.__instance

    def log(self, message):
        print(message)

if __name__ == "__main__":
    logger = Logger.getInstance()
    logger.log("Singleton pattern example with Logger.") # Output: Singleton pattern example with Logger.
    another_logger = Logger.getInstance()
    print(logger is another_logger)  # This will print True, as only one instance should exist

In this example, the Logger class implements the Singleton Pattern to ensure only one instance is created.

The class variable __instance is initialized to None and is used to store the single instance of the Logger.
The static method getInstance checks if __instance is None (indicating no instance has been created). If so, it creates a new instance of Logger and assigns it to __instance. If __instance is not None, it simply returns the existing instance.
The log method demonstrates a basic operation for the Logger class by printing a message.

The main function test demonstrates this by creating two variables, logger and another_logger, both of which refer to instances of Logger. It prints a message using log and verifies that both variables reference the same instance with print(logger is another_logger), which outputs True. This confirms that the Singleton Pattern ensures only one instance of the Logger exists throughout the application's lifecycle.