Inheritance

Author: Shikha-code36

Inheritance/inheritance-1.py

@@ -0,0 +1,43 @@
+#!/usr/bin/env python
+
+# inheritance-1.py
+
+# The code below shows how a class can inherit from another class.
+# We have two classes, `Date` and `Time`. Here `Time` inherits from
+# `Date`.
+
+# Any class inheriting from another class (also called a Parent class)
+# inherits the methods and attributes from the Parent class.
+
+# Hence, any instances created from the class `Time` can access
+# the methods defined in the parent class `Date`.
+
+
+class Date(object):
+    def get_date(self):
+        print("2016-05-14")
+
+
+class Time(Date):
+    def get_time(self):
+        print("07:00:00")
+
+
+# Creating an instance from `Date`
+dt = Date()
+dt.get_date()  # Accesing the `get_date()` method of `Date`
+print("--------")
+
+# Creating an instance from `Time`.
+tm = Time()
+tm.get_time()  # Accessing the `get_time()` method from `Time`.
+# Accessing the `get_date() which is defined in the parent class `Date`.
+tm.get_date()
+
+'''
+O/P-
+2016-05-14
+--------
+07:00:00
+2016-05-14
+'''

Inheritance/inheritance-2.py

@@ -0,0 +1,60 @@
+#!/usr/bin/env python
+
+# inheritance-2.py
+
+# The code below shows another example of inheritance
+# Dog and Cat are two classes which inherits from Animal.
+# This an instance created from Dog or Cat can access the methods
+# in the Animal class, ie.. eat().
+
+# The instance of 'Dog' can access the methods of the Dog class
+# and it's parent class 'Animal'.
+
+# The instance of 'Cat' can access the methods of the Cat class
+# and it's parent class 'Animal'.
+
+# But the instance created from 'Cat' cannot access the attributes
+# within the 'Dog' class, and vice versa.
+
+
+class Animal(object):
+    def __init__(self, name):
+        self.name = name
+
+    def eat(self, food):
+        print("%s is eating/drinking %s" % (self.name, food))
+
+
+class Dog(Animal):
+    def fetch(self, thing):
+        print("%s goes after the %s" % (self.name, thing))
+
+
+class Cat(Animal):
+    def swatstring(self):
+        print("%s shred the string!" % self.name)
+
+
+dog = Dog("Tuffy")
+cat = Cat("Mona")
+
+dog.fetch("paper")
+dog.eat("bone")
+print("--------")
+cat.eat("milk")
+cat.swatstring()
+
+'''
+O/P-
+Tuffy goes after the paper
+Tuffy is eating/drinking bone
+--------
+Mona is eating/drinking milk
+Mona shred the string!
+'''
+
+# The below methods would fail, since the instances doesn't have
+# have access to the other class.
+
+cat.fetch("frizbee")
+dog.swatstring()

Inheritance/inheriting-init-constructor-1.py

@@ -0,0 +1,48 @@
+#!/usr/bin/env python
+
+# inheriting-init-constructor-1.py
+
+# This is a normal inheritance example from which we build
+# the next example. Make sure to read and understand the
+
+
+
+class Animal(object):
+    def __init__(self, name, thing):
+        self.name = name
+        self.thing = thing
+
+
+class Dog(Animal):
+    def fetch(self):
+        print("%s goes after the %s" % (self.name, self.thing))
+
+
+dog = Dog("Tuffy","Ball")
+print("The dog's name is %s and he plays %s" % (dog.name, dog.thing))
+dog.fetch()
+'''
+O/P-
+The dog's name is Tuffy and he plays Ball
+Tuffy goes after the Ball
+'''
+
+#ANOTHER WAY TO ACCESS
+class Animal(object):
+    def __init__(self, name):
+        self.name = name
+
+
+class Dog(Animal):
+    def fetch(self, thing):
+        print("%s goes after the %s" % (self.name, thing))
+
+
+d = Dog("TUFFY")
+print("The dog's name is", d.name)
+d.fetch("Ball")
+'''
+O/P-
+The dog's name is TUFFY
+TUFFY goes after the Ball
+'''

Inheritance/multiple-inheritance-1.py

@@ -0,0 +1,56 @@
+#!/usr/bin/env python
+
+# multiple-inheritance-1.py
+
+# Python supports multiple inheritance and uses a depth-first order
+# when searching for methods.
+# This search pattern is call MRO (Method Resolution Order)
+
+# This is the first example, which shows the lookup of a common
+# function named 'dothis()', which we'll continue in other examples.
+
+# As per the MRO output, it starts in class D, then B, A, and lastly C.
+
+# Both A and C contains 'dothis()'. Let's trace how the lookup happens.
+
+# As per the MRO output, it starts in class D, then B, A, and lastly C.
+
+# class `A` defines 'dothis()' and the search ends there. It doesn't go to C.
+
+# The MRO will show the full resolution path even if the full path is
+# not traversed.
+
+# The method lookup flow in this case is : D -> B -> A -> C
+
+
+class A(object):
+    def dothis(self):
+        print("doing this in A")
+
+
+class B(A):
+    pass
+
+
+class C(object):
+    def dothis(self):
+        print("doing this in C")
+
+
+class D(B, C):
+    pass
+
+
+d_instance = D()
+d_instance.dothis()  # <== This should print from class A.
+
+print("\nPrint the Method Resolution Order")
+print(D.mro())
+
+'''
+O/P-
+doing this in A
+
+Print the Method Resolution Order
+[<class '__main__.D'>, <class '__main__.B'>, <class '__main__.A'>, <class '__main__.C'>, <class 'object'>] 
+'''

Inheritance/multiple-inheritance-2.py

@@ -0,0 +1,57 @@
+#!/usr/bin/env python
+
+# multiple-inheritance-2.py
+
+# Python supports multiple inheritance
+
+# It uses a depth-first order when searching for methods.
+# This search pattern is call MRO (Method Resolution Order)
+
+# This is a second example, which shows the lookup of 'dothis()'.
+# Both A and C contains 'dothis()'. Let's trace how the lookup happens.
+
+# As per the MRO output using depth-first search,
+# it starts in class D, then B, A, and lastly C.
+
+# Here we're looking for 'dothis()' which is defined in class `C`.
+# The lookup goes from D -> B -> A -> C.
+
+# Since class `A` doesn't have `dothis()`, the lookup goes back to class `C`
+# and finds it there.
+
+
+class A(object):
+    def dothat(self):
+        print("Doing this in A")
+
+
+class B(A):
+    pass
+
+
+class C(object):
+    def dothis(self):
+        print("\nDoing this in C")
+
+
+class D(B, C):
+    """Multiple Inheritance,
+    D inheriting from both B and C"""
+
+    pass
+
+
+d_instance = D()
+
+d_instance.dothis()
+
+print("\nPrint the Method Resolution Order")
+print(D.mro())
+
+'''
+O/P-
+Doing this in C
+
+Print the Method Resolution Order
+[<class '__main__.D'>, <class '__main__.B'>, <class '__main__.A'>, <class '__main__.C'>, <class 'object'>] 
+'''

Inheritance/multiple-inheritance-3.py

@@ -0,0 +1,63 @@
+#!/usr/bin/env python
+
+# multiple-inheritance-3.py
+
+# Python supports multiple inheritance
+# and uses a depth-first order when searching for methods.
+# This search pattern is call MRO (Method Resolution Order)
+
+# Example for "Diamond Shape" inheritance
+# Lookup can get complicated when multiple classes inherit
+# from multiple parent classes.
+
+# In order to avoid ambiguity while doing a lookup for a method
+# in various classes, from Python 2.3, the MRO lookup order has an
+# additional feature.
+
+# It still does a depth-first lookup, but if the occurrence of a class
+# happens multiple times in the MRO path, it removes the initial occurrence
+# and keeps the latter.
+
+# In the example below, class `D` inherits from `B` and `C`.
+# And both `B` and `C` inherits from `A`.
+# Both `A` and `C` has the method `dothis()`.
+
+# We instantiate `D` and requests the 'dothis()' method.
+# By default, the lookup should go D -> B -> A -> C -> A.
+# But from Python 2.3, in order to reduce the lookup time,
+# the MRO skips the classes which occur multiple times in the path.
+
+# Hence the lookup will be D -> B -> C -> A.
+
+
+class A(object):
+    def dothis(self):
+        print("doing this in A")
+
+
+class B(A):
+    pass
+
+
+class C(A):
+    def dothis(self):
+        print("doing this in C")
+
+
+class D(B, C):
+    pass
+
+
+d_instance = D()
+d_instance.dothis()
+
+print("\nPrint the Method Resolution Order")
+print(D.mro())
+
+'''
+O/P-
+doing this in C
+
+Print the Method Resolution Order
+[<class '__main__.D'>, <class '__main__.B'>, <class '__main__.C'>, <class '__main__.A'>, <class 'object'>] 
+'''

README.md

@@ -121,5 +121,8 @@ def __init__(self):
 ------------
 #### 05. Inheritance
 
+With inheritance one class can derive the properties of another class.
+ex- Man Inheriting features from his father
 
+[Detailed Explanation](Inheritance)
 ------------