Singleton Pattern in Python

This story is part of the “Design Patterns” series. You can find the other stories of this series here:

You can also find all the code used through this series on GitHub.

The Singleton pattern is a creational pattern allowing you to ensure a class has just one instance throughout the lifetime of your program.

This way, you can share resources and provide one global point of access for something.

Problems the Singleton can Solve

Sometimes in your program, some operations should be done from one access point.

For example, if your program works with a database, you won’t open a new connection every time you want to send requests to your database. Instead, you can open a connection when your program starts, and keep this connection open throughout the lifetime of your program. You can then access your database from a unique Database instance at any time, without opening a new connection.

Another example: if your program works with a file manager, it’s better to have only one instance of it. So that, you won’t have conflicts when working with files.

Singleton Implementations

There are many ways to implement a Singleton in Python.

The first one is at the module level (it’s not really a Singleton but I will talk about it anyway). Indeed, Python modules are Singletons. You can share data from a unique access point. It allows you to create modules such as constants.py to define constants you can access from everywhere.

Then, from your main:

Another way to implement a Singleton is at the class level. It’s the most common way of implementing Singletons. To implement a Singleton this way, you need to store a reference to an instance at the class level, and when creating a new object, you should check whether an instance already exists or not. If it exists, you use the existing instance, if it doesn’t, you create the instance.

Here is an implementation for the example of the database (don’t worry if you don’t know __new__ , I’ll try to explain it):

Here I used __new__ . It’s a special method that has access to the class, called before __init__ . I’m not sure if I can summarize it this way: it’s like a constructor but for the class.

So, the code works this way when instancing DatabaseSingleton:

1. We check if there is already an instance of the Singleton through __new__.
2. If there is, do nothing. If there is not, we create an instance using super.__new__
3. We return the instance.
4. __init__ is called.
5. If the database is already initialized, we do nothing. If it’s not, we create the attributes of the instance, so initialized and connection .

This way, we can access the database from a global point of access. Here is the output of the main:

True
Database
None
Database
None

As you can see, db1 and db2 are the same. (By the way, the connection I return from connect is a str , but in a real app, it would be something like a Database object)

Advantages/Disadvantages

I don’t think there are disadvantages to using a Singleton pattern when you have to work with objects like databases or file managers. It’s always better to provide one global access point.

Final Note

The Singleton pattern is a very useful pattern in Python. I use it a lot because I often have to work with Config objects, so I like to implement them as Singletons. This way, I can modify the same config from everywhere in my app, and be sure I retrieve the right config values. I also use it with databases.

It’s a powerful pattern, and there are no drawbacks to using it, that’s why it’s nice to know it!

To explore the other stories of this story, click below!

To explore more of my Python stories, click here! You can also access all my content by checking this page.

If you want to be notified every time I publish a new story, subscribe to me via email by clicking here!

If you’re not subscribed to medium yet and wish to support me or get access to all my stories, you can use my link: