Method Overloading and Method Overriding in Python

Method overloading and method overriding offer powerful techniques for managing your code’s behaviour. Method overloading in Python refers to the ability of a single function or method to handle different types and numbers of parameters, whereas method overriding allows a subclass to provide its unique implementation for an inherited method from its superclass. Now let’s dive into these intriguing concepts further!

What is Method Overloading?

Method overloading is a feature that enables a class to have multiple methods with the same name but different parameters. However, Python doesn’t support method overloading like other languages. We can only achieve method overloading in Python through certain techniques.

Here are some key points:

• In method overloading, multiple methods share the same name within a class.
• These methods should differ in terms of the number or type of parameters.

Consider this table for more clarity:

Even though we created an add function with 2 and 3 parameters, respectively, Python recognizes only the latest definition.

However, here’s how you can achieve functionality similar to method overloading in Python:

1. Using Optional Parameters: You can declare your function with optional arguments which might or might not receive value while calling. Example:

def sum(a, b=0):
       return a+b

2. Using *args allows us to pass a variable-length argument list from which we can pick as many arguments as needed. Example:

def sum(*nums): total = 0 for num in nums: total += num return total

Method Overloading in Python

In Python, method overloading is a technique that allows a class to have more than one method with the same name but different parameters. Here’s how it works:

• Parameter Variations: In other languages like Java or C++, you can overload a method by changing the number and/or types of parameters. In Python, this isn’t directly possible because Python does not support explicit multiple methods.

# Attempting traditional overloading - doesn't work!
class Demo:
    def hello(self, name=None):
        if name is not None:
            print('Hello ' + name)
        else:
            print('Hello')

• Indirect Overload: We can indirectly achieve method overloading using optional arguments or variable-length arguments.

# Achieving overloading indirectly
class Demo:
    def hello(self, *args):
        for arg in args:
            print('Hello ' + arg)

Remember, while we’re achieving similar results to traditional overloads here (i.e., handling varying inputs), it’s technically incorrect to call this “method overloading” as per classical OOP definitions.

Why Use Method Overloading?

Method overloading in Python is a feature that allows us to define methods of the same name but with different parameters or arguments. This offers several advantages:

• Flexibility: With method overloading, you can write flexible functions that can handle different numbers and types of arguments.
• Readability: It enhances readability by enabling you to use the same method name for similar actions.

Example Table

Key Points

1. Code Simplicity: One function handles multiple cases based on input parameters.
2. Performance Improvement: Fewer separate functions mean less memory usage.

In conclusion, Method overloading brings flexibility and simplicity into your codebase, making it easier for other developers to understand and work with your code.

How to Implement Method Overloading in Python

In Python, method overloading isn’t supported directly. But we can achieve it by using some techniques:

1. By Using Default Arguments: This involves setting default values for the arguments.

class Addition:
    def sum(self, a=0, b=0):
        return a + b

obj = Addition()
print(obj.sum(10)) # outputs 10
print(obj.sum(10, 5)) # outputs 15

2. By Using Variable Length Arguments: In cases where we might have more than two numbers.

class Multiplication:
    def multiply(*args):
        result = 1
        for i in args:
            result *= i
        return result

obj = Multiplication()
print(obj.multiply(5,4)) #outputs 20

3. Creating Class Methods for Each Case: Create different methods with the same name but different parameters.

class Rectangle:
     def area(self,x):
         return x*x

     def area(self,x,y):
         return x*y

r = Rectangle()
r.area(4)   # doesn't work because python does not support method overloading

Remember that Python will always use the latest defined method if multiple methods with the same name exist.

What is Method Overriding?

Method overriding in Python refers to an object-oriented programming concept. It’s a feature that allows a subclass or child class to provide a specific implementation of a method already provided by its parent class.

Here are some key points:

• When the parent and child classes have the same name, Python will only call the method from the child class when invoked. This is known as method overriding.
• A primary use case for method overriding is when you want to change or expand on the behaviour defined in your superclass without modifying its original code.

Let’s see an example:

class Parent:
    def my_method(self):
        print("Parent Method")

class Child(Parent):
    def my_method(self):
        print("Child Method")

child = Child()
child.my_method()  # Output: Child Method

In this example:

1. The my_method function exists in both the Parent and Child classes.
2. When we create an instance of Child and call my_method, it calls the overridden method from the Child class, not from Parent - demonstrating method overriding.

Remember these rules about method overriding in Python:

Method Overriding in Python

In Python, method overriding occurs when a child class provides a different implementation for a method already defined in its parent class. This process allows the program to call methods of the child class through an object of the parent class.

• When to Use
• It’s beneficial when you want to change or extend the functionality of a base/parent method in your derived/child classes.

Example

Consider these two classes:

class Parent:
    def printGreeting(self):
        return "Hello from Parent"

class Child(Parent):
    def printGreeting(self):
        return "Hello from Child"

In this case, printGreeting is overridden by Child.

Execution

To execute and verify:

p = Parent()
c = Child()

print(p.printGreeting()) # Hello from Parent
print(c.printGreeting()) # Hello from Child

As expected, calling printGreeting() on objects ‘p’ and ‘c’ will output greetings specific to their respective classes.

Remember these points about method overriding:

1. The name & parameters of the override function in the child class must be the same as the base.
2. To call overridden methods, use the super() function.
3. Method overriding enables us to achieve runtime polymorphism, which helps in code reusability & readability.

That’s it! You’ve learned how Python uses method overriding!

Examples of Method Overriding in Python

Method overriding in Python allows a subclass to provide a different implementation of a method that is already defined in its superclass. Here are some examples:

1. Basic Method Overriding

Consider two classes, ClassA and ClassB. ClassB is the subclass of ClassA.

class ClassA:
    def display(self):
        print("Inside Class A")

class ClassB(ClassA):
    def display(self):
        print("Inside Class B")

In this case, we have overridden the display() method in the subclass ClassB.

2. Using Super Function

We can call the function from the parent class using super() function as follows:

class Person:
  def greet(self):
      return "Hello"

class Student(Person):
  def greet(self):
      return super().greet() + ", I am a student"

student = Student()
print(student.greet()) # Prints: Hello, I am a student

Here, even though we’ve overridden the greet() method in Student, it’s still able to access Person’s version by calling super().greet()

Remember these key points about method overriding:

• The name & parameters of the method should be the same in both base and derived classes.
• The child class must define the same method signature as the parent class - same name, same number of arguments.
• Always use override when you want new behaviour for existing functionality.

Wrapping Up

Method overloading and method overriding are two powerful features of Python that can drastically improve the efficiency and readability of your code. Overloading allows multiple methods with the same name but different parameters, while overriding lets a subclass provide a distinct implementation for an existing method defined in its superclass.

Keep practising these concepts in real-world scenarios. You can design more flexible and scalable software systems by mastering these tools. Remember: it’s not about learning all techniques at once; it’s about understanding how each fits into your coding toolbox.