Singleton Design Pattern Implementation in Python

The Singleton design pattern ensures that a class has only one instance and provides a global point of access to that instance. This pattern is useful when exactly one object is needed to coordinate actions across the system, such as in logging, configuration settings, etc.

Code Template

Here is the refined implementation of the Singleton design pattern in Python:

class Singleton:
    _instance = None  # Class variable to hold the single instance

    def __new__(cls):
        """Override the default instance creation method to implement Singleton behavior."""
        if cls._instance is None:
            # If no instance exists, create one
            cls._instance = super(Singleton, cls).__new__(cls)
        return cls._instance

    def __init__(self):
        """Initialize the singleton instance.
        
        This initialization should be idempotent, as it might be called multiple times.
        """
        if not hasattr(self, 'initialized'):  # Check if initialization has already occurred
            self.initialized = True  # Set the flag to skip future initialization
            self.data = {}  # Example attribute for the Singleton instance

    def set_data(self, key, value):
        """Set data in the singleton instance."""
        self.data[key] = value

    def get_data(self, key):
        """Get data from the singleton instance."""
        return self.data.get(key, None)

Key Sections Explained

Class Variable _instance

• This variable holds the single instance of the Singleton class. It is initially set to None.

__new__ Method

• The __new__ method is responsible for creating an instance of the class.
• It checks if _instance is None, and if so, it creates a new instance. If an instance already exists, it simply returns that instance.

__init__ Method

• The __init__ method initializes the instance attributes.
• An idempotent check is performed to ensure that initialization logic is executed only once, even if __init__ is called multiple times.

Example Methods

• set_data: This method allows setting data in the singleton instance using a key-value pair.
• get_data: This method retrieves data from the singleton instance based on a provided key.

Usage Example

Here’s how you would use the Singleton class:

# Create two instances of the Singleton class
singleton1 = Singleton()
singleton2 = Singleton()

# Set data using the first instance
singleton1.set_data('example_key', 'example_value')

# Retrieve data using the second instance
print(singleton2.get_data('example_key'))  # Outputs: example_value

# Verify that both instances are the same
print(singleton1 is singleton2)  # Outputs: True

Conclusion

This implementation of the Singleton design pattern in Python ensures that no matter how many times you try to create an instance of the Singleton class, you will always receive the same instance. The code template is designed to be clean, modular, and easy to understand, serving as a practical guide to implementing the Singleton design pattern in your own projects.

For further learning on design patterns and their practical applications, consider exploring courses on the Enterprise DNA Platform.