Is it not possible to define multiple constructors in Python?

python

parametric-polymorphism

keyword-arguments

class-methods

byAlex Kataev·Feb 24, 2025

In Python, you won't find traditional multiple constructors as in languages like Java. However, you can implement functionality strongly resembling them using just one __init__ method with default parameters or class methods as alternative constructors.

Let's take a look at a concrete example using a class method:

class Circle:
    def __init__(self, radius=1.0):
        self.radius = radius  # By default, radius is set to one. Feel free to change

    @classmethod
    def from_diameter(cls, diameter):
        return cls(diameter / 2)  # Hey, isn't it cool to create a circle from diameter?

# Usage
circle_default = Circle()                # The simple, no-surprise circle everyone knows
circle_custom = Circle(2.5)              # An oddball circle that doesn't go with the flow
circle_from_diam = Circle.from_diameter(5)  # Makes you think, doesn't it?

Here, Circle.from_diameter is a class method providing an alternative way to create a Circle instance, similar to having visibility of multiple constructors

Exploring default parameters and keyword arguments

Digging deeper, we see an underlying concept known as parametric polymorphism in action. By using keyword arguments, you can create greater flexibility when handling diverse parameters in __init__.

You can also ensure that object types are clearly identifiable by relying on explicit arguments rather than checking types with isinstance. This increases code readability and predictability:

class Coordinates:
    def __init__(self, latitude, longitude=None):  # Either you specify both or just latitude
        if longitude is None:
            self.x, self.y = latitude    # For the savvy ones who pass a pair
        else:
            self.x, self.y = latitude, longitude  # Everyone else, this is for you

In scenarios requiring different initialization paths based on the argument type, an if-elif chain within __init__ can be implemented.

Embracing class methods and static methods

Class methods can act as alternative constructors. They not only provide distinct ways to construct instances, but they also improve maintainability:

class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    @classmethod
    def from_birth_year(cls, name, birth_year):
        return cls(name, datetime.date.today().year - birth_year)  # Time travellers beware! Past years only.

With this approach, the from_birth_year method acts as an alternative constructor, allowing instance creation based on a person's birth year, not merely age. This is a common Python pattern, allowing you to write organized, clean code with clear intent.

Implementing customizable object construction

To enhance flexibility, default constructors, parameterized constructors, and keyword arguments can be levereaged:

class Car:
    def __init__(self, make, model, year, body=None, transmission=None, color=None):
        """Init a Car object with mandatory and optional attributes."""
        self.make = make
        self.model = model
        self.year = year
        self.body = body or "Coupe"  # A man's got to have defaults, right?
        self.transmission = transmission or 'Manual'  # Let's keep it old school
        self.color = color or 'Black'  # Isn't black always stylish?