Python Topics : Multiple Constructors
Providing Multiple Constructors in Python

Python doesn't inherently support multiple constructors
there are ways to simulate them and customize instance creation
standard c'tor 

class Example:
    def __init__(self):
        print("Example class instance created!")
Checking Argument Types
Python supports dynamic typing
can check the types of arguments at runtime
can simulate multiple constructors by creating a general constructor which behaves differently based on argument types 
class Example:
    def __init__(self, data):
        if isinstance(data, list):
            self.data = data
        elif isinstance(data, str):
            self.data = list(data)
        else:
            raise TypeError("Invalid data type provided!")
Utilizing Default Argument Values
can use default argument values in the __init__ method
simulates multiple constructors by allowing different numbers of arguments
if an argument isn't provided when creating an object, the default value is used 
class Example:
    def __init__(self, data="default"):
        self.data = data
Writing Class Methods for Alternate Constructors
class methods provide a way to define alternate constructors
methods belong to the class rather than instances
can be used to provide additional ways of creating instances 
class Example:
    def __init__(self, data):
        self.data = data
 
    @classmethod
    def from_list(cls, data_list):
        return cls(data_list)
 
    @classmethod
    def from_string(cls, data_str):
        return cls(list(data_str))

lst = [1,2,3]
s = 'Hello World!'    

x1 = Example(None)
x2 = Example.from_list(lst)
x3 = Example.from_string(s)
from_list and from_string are alternate c'tors
Single-Dispatch Methods and Overloading
Understanding Single-Dispatch Methods
the functools module provides a decorator @functools.singledispatchmethod
decorator allows a method to behave differently based on the type of a particular argument
can create a constructor that behaves differently based on argument types 
from functools import singledispatchmethod

class Name:
    @singledispatchmethod
    def __init__(self, name):
        # the default implementation
        # runs when the data type is not registered.
        raise ValueError("This data type is not supported.")
    
    # decorator is used to register the function with the data type of the first argument
    # Format: .register()
    @__init__.register(str)
    def _(self, name):
        # if the data type of the name is a string, then this constructor is called.
        self.firstName, self.lastName = name.split(" ")
        
    @__init__.register(list)
    def _(self, name):
        # if the data type is a list, then this constructor is called.
        self.firstName, self.lastName = name[0], name[1]

    def __str__(self):
        return "Full Name: {} {}".format(self.firstName, self.lastName)
        

# Object creation for string and list
obj1 = Name("Alice Bob")
obj2 = Name(["Alice", "Bob"])
print(obj1)
print(obj2)
# throws an Error as the data type is not defined
obj3 = Name(1)
can add multiple constructors and run them according to the type of the first argument
Multiple Constructors in an Existing Class
Constructing Dictionaries Using .fromkeys() Method
dict is a fundamental data typ
dictionaries are one of the most used data structures
different ways to create instances of a dictionary
  • using key-value pairs {key: value}.
  • using the keyword dict()
  • using the alternative constructor fromkeys()
# Method 1: Using {}
alphabet = {"A": 1, "B": 2, "C": 3}
print(alphabet)

# Method 2: Using dict()
colors = dict()
colors["green"] = (0, 255, 0)
colors["blue"] = (0, 0, 255)
print(colors)

# Method 3 : Using .fromKeys() class method
keys = ["a", "b", "c"]
triangle = dict.fromkeys(keys, 0)
print(triangle)
output 
{'A': 1, 'B': 2, 'C': 3}
{'green': (0, 255, 0), 'blue': (0, 0, 255)}
{'a': 0, 'b': 0, 'c': 0}
Creating datetime.date Objects
datetime.date class has multiple constructors
class defines the date using the data members: year, month, and day
also provides constructors to convert dates from ordinal and timestamps to this format
some of the constructors provided by this class are
  • fromordinal()
  • fromtimestamp()
  • fromisoformat()
constructors are used to initialize an object when the input is given in different formats 
from datetime import date
from time import time

# datetime.date(year, month, day)
date1 = date(2012, 11, 12)
print("Date1 using default constructor", date1.year, date1.month, date1.day)
# Using the ordinal date 
ordinalDate = date.fromordinal(699129)
print("Date from ordinal using fromordinal() constructor", ordinalDate)
# Using timestamp
timeStampDate = date.fromtimestamp(time())
print("Date from timestamp using fromtimestamp() constructor", timeStampDate)
    
isoDate = date.fromisoformat("2022-10-04")
print("Date from isoformat using fromisoformat() constructor", isoDate)
output 
Date1 using default constructor 2012 11 12
Date from ordinal using fromordinal() constructor 1915-02-25
Date from timestamp using fromtimestamp() constructor 2022-10-04
Date from isoformat using fromisoformat() constructor 2022-10-04
index