Method Overloading

Author: Shikha-code36

09.Method_overloading/method-overloading-1.py

@@ -0,0 +1,56 @@
+#method-overloading-1.py
+
+# This code is an example on how we can extend a method inherited by
+# a child class from the Parent class.
+
+# 1) We have defined `MyClass()` as an abstract class,
+# and it has three methods, my_set_val(), my_get_val(), and print_doc().
+# 2) MyChildClass() inherits from MyClass()
+# 3) MyChildClass() extends the parent's my_set_val() method
+# by it's own my_set_val() method. It checks for the input,
+# checks if it's an integer, and then calls the my_set_val()
+# method in the parent.
+
+# 4) The print_doc() method in the Parent is an abstract method
+# and hence should be implemented in the child class MyChildClass()
+
+
+import abc
+
+
+class MyClass(object):
+
+    __metaclass__ = abc.ABCMeta
+
+    def my_set_val(self, value):
+        self.value = value
+
+    def my_get_val(self):
+        return self.value
+
+    @abc.abstractmethod
+    def print_doc(self):
+        return
+
+
+class MyChildClass(MyClass):
+    def my_set_val(self, value):
+        if not isinstance(value, int):
+            value = 0
+        super(MyChildClass, self).my_set_val(self)
+
+    def print_doc(self):
+        print("Documentation for MyChild Class")
+
+
+my_instance = MyChildClass()
+my_instance.my_set_val(100)
+print(my_instance.my_get_val())
+print(my_instance.print_doc())
+
+'''
+O/P-
+<__main__.MyChildClass object at 0x0000027750626FA0>
+Documentation for MyChild Class
+None
+'''

09.Method_overloading/method-overloading-2.py

@@ -0,0 +1,42 @@
+#method-overloading-1.py
+
+import abc
+
+
+class GetSetParent(object):
+
+    __metaclass__ = abc.ABCMeta
+
+    def __init__(self, value):
+        self.val = 0
+
+    def set_val(self, value):
+        self.val = value
+
+    def get_val(self):
+        return self.val
+
+    @abc.abstractmethod
+    def showdoc(self):
+        return
+
+
+class GetSetList(GetSetParent):
+    def __init__(self, value=0):
+        self.vallist = [value]
+
+    def get_val(self):
+        return self.vallist[-1]
+
+    def get_vals(self):
+        return self.vallist
+
+    def set_val(self, value):
+        self.vallist.append(value)
+
+    def showdoc(self):
+        print(
+            "GetSetList object, len {0}, store history of values set".format(
+                len(self.vallist)
+            )
+        )

09.Method_overloading/method-overloading-3.py

@@ -0,0 +1,57 @@
+#method-overloading-3.py
+
+# We've seen that inherited methods can be overloaded.
+# This is possible using in-built functions as well.
+
+# Let's see how we can overload methods from the `list` module.
+
+
+class MyList(list):
+    def __getitem__(self, index):
+        if index == 0:
+            raise IndexError
+        if index > 0:
+            index -= 1
+        return list.__getitem__(self, index)
+
+    def __setitem__(self, index, value):
+        if index == 0:
+            raise IndexError
+        if index > 0:
+            index -= 1
+        list.__setitem__(self, index, value)
+
+
+x = MyList(["a", "b", "c"])
+print("First",x)
+print("-" * 10)
+
+x.append("d")
+print("Second",x)
+print("-" * 10)
+
+x.__setitem__(4, "e")
+print("Third",x)
+print("-" * 10)
+
+print(x[1])
+print("Fourth",x.__getitem__(1))
+print("-" * 10)
+
+print(x[4])
+print("Fifth",x.__getitem__(4))
+
+'''
+O/P-
+First ['a', 'b', 'c']
+----------
+Second ['a', 'b', 'c', 'd']
+----------
+Third ['a', 'b', 'c', 'e']
+----------
+a
+Fourth a
+----------
+e
+Fifth e
+'''

README.md

@@ -9,6 +9,7 @@
 06. [Encapsulation](https://github.com/Shikha-code36/Object-Oriented-Programming-OOPs-Python#06-encapsulation)
 07. [Polymorphism](https://github.com/Shikha-code36/Object-Oriented-Programming-OOPs-Python#07-polymorphism)
 08. [Decorators](https://github.com/Shikha-code36/Object-Oriented-Programming-OOPs-Python#08-decorators)
+09. [Method Overloading](https://github.com/Shikha-code36/Object-Oriented-Programming-OOPs-Python#08-decorators)
 
 ------------
 ## What do you understand by OOPs?
@@ -161,4 +162,16 @@ This is also called metaprogramming because a part of the program tries to modif
 
 [Detailed Explanation](08.Decorators)
 
+------------
+------------
+#### 09. Method Overloading
+
+Two methods cannot have the same name in Python. Method overloading in Python is a feature that allows the same operator to have different meanings.
+
+Overloading is the ability of a function or an operator to behave in different ways based on the parameters that are passed to the function, or the operands that the operator acts on.
+
+In Python, you can create a method that can be called in different ways. So, you can have a method that has zero, one or more number of parameters. Depending on the method definition, we can call it with zero, one or more arguments.
+
+[Detailed Explanation](09.Method_overloading)
+
 ------------