Python | Method Overloading

Method Overloading:

Two or more methods have the same name but different numbers of parameters or different types of parameters, or both. These methods are called overloaded methods and this is called method overloading. 

Like other languages (for example, method overloading in C++) do, python does not support method overloading by default. But there are different ways to achieve method overloading in Python. 

The problem with method overloading in Python is that we may overload the methods but can only use the latest defined method. 

# First product method.
# Takes two argument and print their
# product


def product(a, b):
    p = a * b
    print(p)

# Second product method
# Takes three argument and print their
# product


def product(a, b, c):
    p = a * b*c
    print(p)

# Uncommenting the below line shows an error
# product(4, 5)


# This line will call the second product method
product(4, 5, 5)

100

In the above code, we have defined two product methods we can only use the second product method, as python does not support method overloading. We may define many methods of the same name and different arguments, but we can only use the latest defined method. Calling the other method will produce an error. Like here calling product(4,5) will produce an error as the latest defined product method takes three arguments.

Thus, to overcome the above problem we can use different ways to achieve the method overloading.

Method 1 (Not The Most Efficient Method):

We can use the arguments to make the same function work differently i.e. as per the arguments.

# Function to take multiple arguments
def add(datatype, *args):

    # if datatype is int
    # initialize answer as 0
    if datatype == 'int':
        answer = 0

    # if datatype is str
    # initialize answer as ''
    if datatype == 'str':
        answer = ''

    # Traverse through the arguments
    for x in args:

        # This will do addition if the
        # arguments are int. Or concatenation
        # if the arguments are str
        answer = answer + x

    print(answer)


# Integer
add('int', 5, 6)

# String
add('str', 'Hi ', 'Geeks')

11
Hi Geeks

Method 2 (Not the efficient one):

We can achieve method overloading in python by user defined function using "None" keyword as default parameter.

Code explanation:

The first parameter of  "add" method is set to None. This will give us the option to call it with or without a parameter.

When we pass arguments to the add method (Working):

• The method checks if both the parameters are available or not. 
• As we have already given default parameter values as "None", if any of the value is not passed it will remain "None".
• Using If-Else statements, we can achieve method overloading by checking each parameter as single statement.

# code
def add(a=None, b=None):
    # Checks if both parameters are available
    # if statement will be executed if only one parameter is available
    if a != None and b == None:
        print(a)
    # else will be executed if both are available and returns addition of two
    else:
        print(a+b)


# two arguments are passed, returns addition of two
add(2, 3)
# only one argument is passed, returns a
add(2)

5
2

The problem with above methods is that, it makes code more complex with multiple if/else statement and is not the desired way to achieve the method overloading.

Method 3 (Efficient One):

By Using Multiple Dispatch Decorator 

Multiple Dispatch Decorator Can be installed by: 

pip3 install multipledispatch

If pip is not installed on your device:

Click here for "Windows"

Click here for "Linux"

from multipledispatch import dispatch

# passing one parameter


@dispatch(int, int)
def product(first, second):
    result = first*second
    print(result)

# passing two parameters


@dispatch(int, int, int)
def product(first, second, third):
    result = first * second * third
    print(result)

# you can also pass data type of any value as per requirement


@dispatch(float, float, float)
def product(first, second, third):
    result = first * second * third
    print(result)


# calling product method with 2 arguments
product(2, 3)  # this will give output of 6

# calling product method with 3 arguments but all int
product(2, 3, 2)  # this will give output of 12

# calling product method with 3 arguments but all float
product(2.2, 3.4, 2.3)  # this will give output of 17.985999999999997

Output: 

6
12
17.985999999999997

In Backend, Dispatcher creates an object which stores different implementation and on runtime, it selects the appropriate method as the type and number of parameters passed.

Example of Overriding:

class Parent:
    def show(self):
        print("Inside Parent")

class Child(Parent):
    def show(self):
        print("Inside Child")

c = Child()
c.show()  # Output: Inside Child

• Overriding refers to the ability of a subclass to provide a specific implementation of a method that is already defined in its superclass. This is a common feature in object-oriented programming and is fully supported in Python. This allows a method to behave differently depending on the subclass that implements it.
• Overloading in Python is not supported in the traditional sense where multiple methods can have the same name but different parameters. However, Python supports operator overloading and allows methods to handle arguments of different types, effectively overloading by type checking inside methods.

Does Python Allow Operator Overloading?

Yes, Python allows operator overloading. You can define your own behavior for built-in operators when they are applied to objects of classes you define. This is done by redefining special methods in your class, such as __add__ for +, __mul__ for *, etc.

Example of Operator Overloading:

class Point:
    def __init__(self, x=0, y=0):
        self.x = x
        self.y = y

    def __str__(self):
        return f"({self.x}, {self.y})"

    def __add__(self, other):
        x = self.x + other.x
        y = self.y + other.y
        return Point(x, y)

p1 = Point(1, 2)
p2 = Point(2, 3)
print(p1 + p2)  # Output: (3, 5)

What is __init__ in Python?

The __init__ method in Python is a special method used for initializing newly created objects. It's called automatically when a new object of a class is created. This method can have arguments through which you can pass values for initializing object attributes.

Example of __init__:

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

    def greet(self):
        print(f"Hello, my name is {self.name} and I am {self.age} years old.")

p = Person("John", 30)
p.greet()  # Output: Hello, my name is John and I am 30 years old.

What is Encapsulation in Python?

Encapsulation is a fundamental concept in object-oriented programming that involves bundling the data (attributes) and methods (functions) that operate on the data into a single unit or class. It restricts direct access to some of the object's components, which can prevent the accidental modification of data and allows for safer and more structured code. In Python, encapsulation is implemented using private (denoted by double underscores __) and protected (denoted by single underscore _) attributes and methods.

Example of Encapsulation:

class Account:
    def __init__(self, owner, amount=0):
        self.owner = owner
        self.__balance = amount  # Private attribute

    def deposit(self, amount):
        if amount > 0:
            self.__balance += amount
            print("Deposit successful")
        else:
            print("Deposit amount must be positive")

    def get_balance(self):
        return self.__balance

acct = Account("John")
acct.deposit(100)
print(acct.get_balance())  # Output: 100
# print(acct.__balance)  # This will raise an error because __balance is private