Added Inheritance Programs

Author: Vishal-sys-code

Lecture_16/Class Notes/4_Inheritance.MD

@@ -69,6 +69,26 @@ True
 * **Hierarchial Inheritance :** More than one derived class can be created from a single base.
 * **Hybrid Inheritance :** This forms combines more than one form if inheritance. Basically, it is a blend of more than one type of inheritance.
 
+## **Single Inheritance**
+
+```py
+# Base class
+class Animal:
+    def speak(self):
+        return "The animal makes a sound."
+
+# Derived class
+class Dog(Animal):
+    def speak(self):
+        return "The dog barks."
+
+# Create an instance of the Dog class
+my_dog = Dog()
+
+# Call the speak method
+print(my_dog.speak())  # Output: The dog barks.
+```
+
 ## **Multiple Inheritance**
 ```py
 # When a child class inherits from multiple parent classes, it is called Multiple Inheritance.
@@ -138,6 +158,71 @@ Address: Boston
 """
 ```
 
+## **Hierarchial Inheritance**
+
+```py
+# Base class
+class Animal:
+    def speak(self):
+        return "The animal makes a sound."
+
+# Derived class 1
+class Dog(Animal):
+    def speak(self):
+        return "The dog barks."
+
+# Derived class 2
+class Cat(Animal):
+    def speak(self):
+        return "The cat meows."
+
+# Derived class 3
+class Cow(Animal):
+    def speak(self):
+        return "The cow moos."
+
+# Create instances of the derived classes
+my_dog = Dog()
+my_cat = Cat()
+my_cow = Cow()
+
+# Call the speak method for each instance
+print(my_dog.speak())  # Output: The dog barks.
+print(my_cat.speak())  # Output: The cat meows.
+print(my_cow.speak())  # Output: The cow moos.
+```
+
+## **Hybrid Inheritance**
+
+```py
+# Base class
+class Animal:
+    def speak(self):
+        return "The animal makes a sound."
+
+# Derived class 1
+class Dog(Animal):
+    def speak(self):
+        return "The dog barks."
+
+# Derived class 2
+class Cat(Animal):
+    def speak(self):
+        return "The cat meows."
+
+# Derived class 3 (inherits from Dog and Cat)
+class HybridAnimal(Dog, Cat):
+    def hybrid_speak(self):
+        return f"{self.speak()} and {Cat.speak(self)}"
+
+# Create an instance of the HybridAnimal class
+my_hybrid = HybridAnimal()
+
+# Call the methods
+print(my_hybrid.hybrid_speak())  # Output: The dog barks. and The cat meows.
+```
+
+
 ## **Method Chaining**
 Calling multiple methods automatically each call performs an actions on the same object and returns self.
 ```py

Lecture_16/ClassWork Programs/Inheritance/1_singleInheritance.py

@@ -0,0 +1,15 @@
+# Base class
+class Animal:
+    def speak(self):
+        return "The animal makes a sound."
+
+# Derived class
+class Dog(Animal):
+    def speak(self):
+        return "The dog barks."
+
+# Create an instance of the Dog class
+my_dog = Dog()
+
+# Call the speak method
+print(my_dog.speak())  # Output: The dog barks.

Lecture_16/ClassWork Programs/Inheritance/2_multipleInheritance.py

@@ -0,0 +1,30 @@
+# When a child class inherits from multiple parent classes, it is called Multiple Inheritance.
+
+class Base1(object):
+    # constructors
+    def __init__(self):
+        self.str1 = "USA"
+        print("Base1 Class")
+class Base2(object):
+    # constructors
+    def __init__(self):
+        self.str2 = "Germany"
+        print("Base2 Class")
+class Derived(Base1, Base2):
+    def __init__(self):
+        # Calling constructors of base classes
+        Base1.__init__(self)
+        Base2.__init__(self)
+        print("Derived Class")
+    def printStr(self):
+        print("Countries:", self.str1, "", self.str2)
+obj = Derived()
+obj.printStr()
+
+"""
+Output:
+Base1 Class
+Base2 Class
+Derived Class
+Countries: USA  Germany
+"""

Lecture_16/ClassWork Programs/Inheritance/3_multilevelInheritance.py

@@ -0,0 +1,32 @@
+# When we have a child and grandchild relationship. This means that a child class will inherit from its parent class, which in turn is inheriting from its parent class.
+class Base(object):
+    # constructor
+    def __init__(self, name):
+        self.name = name
+    def getName(self):
+        return self.name
+
+class Child(Base):
+    def __init__(self,name,age):
+        Base.__init__(self,name)
+        self.age = age
+    def getAge(self):
+        self.age = age
+
+class grandChild(Child):
+    def __init__(self, name, age, address):
+        Child.__init__(self,name,age)
+        self.address = address
+    def getAddress(self):
+        return self.address
+objGrandChild = grandChild("Richard", 23, "Boston")
+print("Name:", objGrandChild.name)
+print("Age:", objGrandChild.age)
+print("Address:", objGrandChild.address)
+
+"""
+Output:
+Name: Richard
+Age: 23
+Address: Boston 
+"""

Lecture_16/ClassWork Programs/Inheritance/4_hierarchialInheritance.py

@@ -0,0 +1,29 @@
+# Base class
+class Animal:
+    def speak(self):
+        return "The animal makes a sound."
+
+# Derived class 1
+class Dog(Animal):
+    def speak(self):
+        return "The dog barks."
+
+# Derived class 2
+class Cat(Animal):
+    def speak(self):
+        return "The cat meows."
+
+# Derived class 3
+class Cow(Animal):
+    def speak(self):
+        return "The cow moos."
+
+# Create instances of the derived classes
+my_dog = Dog()
+my_cat = Cat()
+my_cow = Cow()
+
+# Call the speak method for each instance
+print(my_dog.speak())  # Output: The dog barks.
+print(my_cat.speak())  # Output: The cat meows.
+print(my_cow.speak())  # Output: The cow moos.

Lecture_16/ClassWork Programs/Inheritance/5_hybridInheritance.py

@@ -0,0 +1,25 @@
+# Base class
+class Animal:
+    def speak(self):
+        return "The animal makes a sound."
+
+# Derived class 1
+class Dog(Animal):
+    def speak(self):
+        return "The dog barks."
+
+# Derived class 2
+class Cat(Animal):
+    def speak(self):
+        return "The cat meows."
+
+# Derived class 3 (inherits from Dog and Cat)
+class HybridAnimal(Dog, Cat):
+    def hybrid_speak(self):
+        return f"{self.speak()} and {Cat.speak(self)}"
+
+# Create an instance of the HybridAnimal class
+my_hybrid = HybridAnimal()
+
+# Call the methods
+print(my_hybrid.hybrid_speak())  # Output: The dog barks. and The cat meows.

Lecture_16/ClassWork Programs/Inheritance/6_methodChaining.py

@@ -0,0 +1,44 @@
+class Car:
+    def turn_on(self):
+        print("You started the engine")
+        return self
+    def drive(self):
+        print("You drove the car")
+        return self
+    def brake(self):
+        print("You applied the brake on the Car")
+        return self
+    def turn_off(self):
+        print("You turned off the engine")
+        return self
+car = Car()
+print("Without Method Chaining: ")
+car.turn_on()
+car.drive()
+car.brake()
+car.turn_off()
+
+# Method Chaining
+print("\nWith Method Chaining: ")
+car.turn_on().drive()
+car.brake().turn_off()
+car.turn_on().drive().brake().turn_off()
+
+"""
+Output:
+Without Method Chaining: 
+You started the engine
+You drove the car
+You applied the brake on the Car
+You turned off the engine
+
+With Method Chaining:
+You started the engine
+You drove the car
+You applied the brake on the Car
+You turned off the engine
+You started the engine
+You drove the car
+You applied the brake on the Car
+You turned off the engine
+"""