Python Material - Part - 21 - Oops - 4

 __author__ = "Narendra Boyina"

# -----------------------------------------------------------------------------
# Copyright (c) 2025 BR Technologies PVT LTD
# -----------------------------------------------------------------------------
"""
Topics to be covered in today's class:
--> Inheritance / Single inheritance
--> Multiple inheritance 
--> multi-level inheritance 
--> Hierarchial inheritance 
--> Hybrid inheritance
--> issubclass
--> isinstance
"""


""" Inheritance / Single inheritance
Inheritance − The transfer of the characteristics of a class to other classes that are derived from it.
 
Instead of starting from a scratch, you can create a class by deriving it from a pre-existing class
by writing the parent class name in parentheses after the new_class_name.

Single Inheritance Syntax:
Derived class is declared much like it's parent class.

class ChildClassName(ParentClass):
   'Optional class documentation string'
   class_suite (class variables , methods)


The child class inherits the attributes of its parent class, and you can use those attributes as if they were defined in the child class. 
A child class can also override data members and methods from the parent.

"""
class Base():
    pass  # Empty Class

class Derived(Base):
    pass  # Empty Class

"""
Single Inheritance
When a child class inherits only a single parent class."""

class Bhaskarao:   # define parent class
   parentAttr = 100  # class variable/local variable/ attribute

   def __init__(self):
      print ("Calling parent constructor")

   def parentMethod(self):
      print ('Calling parent method')

   def setAttr_Name(self, attr):
      Bhaskarao.parentAttr = attr  # class_name.class_variable

   def getAttr_Name(self):
      print ("Parent attribute value:", Bhaskarao.parentAttr)

   def python(self):
       print("venkat")
       print("priyanka")
       print("subhashini")
       print("sujana")
       print("rindha")


# priyanka = Bhaskarao()  # obj/instance creation
# print("class attribute value:",priyanka.parentAttr)
# priyanka.parentMethod()
# priyanka.setAttr_Name(444)
# priyanka.getAttr_Name()
# priyanka.python()


# single Inheritance
class Narendra(Bhaskarao):   # define derived class / child class

   def __init__(self):
      print ("Calling child constructor")
   def Narendra_Method(self):
      print ('Calling child method')


# child_obj = Narendra()          # instance of child , immediately child's init method will be executed
# child_obj.Narendra_Method()
# child_obj.python()   # calls parent's method
# child_obj.parentMethod()     # calls parent's method
# child_obj.setAttr_Name(200)       # again call parent's method
# child_obj.getAttr_Name()          # again call parent's method
"""
When the above code is executed, it produces the following result −

Calling child constructor
Calling child method
Calling parent method
Parent attribute : 200
"""
"""
############# Multiple inheritance #############
When a child class inherits from more than one parent class
or
 # In a similar way, you can drive a class from multiple parent classes as follows −

class A:        # define your class A
.....

class B:         # define your calss B
.....

class C(A, B):   # subclass of A and B
.....
"""

class Chocolate:
   def __init__(self):
      print("calling chocolate method")

   def ingedreint(self):
      print("badam, pista and cashew are presented in this ")

   def flavour(self):
      print("choclate flavour")


class FiveStar:

   def __init__(self):
       print("calling five star method")

   def taste(self):
      print("completely filled with chocolate and caramel")

class Abcd:

    def xyz(self):
        print("called xyz method")


class DairyMilk(Chocolate, FiveStar, Abcd):  # Multiple inheritance
   Mahalakshmi = 444  # class attribute / class variable

   def __init__(self):
      print("calling Dairy Milk method")

   def nutrition_facts(self):
      print("energy contains: 4% \nproteins contain: 0% \nfat contains: 10% \ncarbohydrates contains: 5%")


# child_obj = DairyMilk()
# print(child_obj.Mahalakshmi)
# child_obj.nutrition_facts()
# child_obj.flavour()
# child_obj.taste()
# child_obj.ingedreint()
# child_obj.xyz()


""" ############# multi-level inheritance ############# 
When a child class becomes a parent class for another child class """

class subhashini():  # In general we called this(subhashini) as Base class
    def abc(self):
        print("called abc method available in subhashini class")

class venkat(subhashini):  # In general we called this(venkat) as Derived class
    def xyz(self):
        print("called xyz method available in venkat class")

class ganesh(venkat):   # In general we called this(ganesh) as Derived class
    def ijk(self):
        print("called ijk method available in ganesh class")

class rindha(ganesh):
    def qwerty(self):
        print("called qwerty method available in rindha class")

child_obj = rindha()
child_obj.xyz()
child_obj.abc()
child_obj.qwerty()
# print(issubclass(rindha, ganesh))   # True
# print(issubclass(rindha, venkat))
# print(issubclass(ganesh, rindha))  # False
# print(issubclass(venkat, rindha))

"""
How to check if a class is subclass of another?
Python provides a function issubclass() that directly tells us if a class is subclass of another class
You can use issubclass() or isinstance() functions to check a relationships of two classes and instances.
The issubclass(sub, sup) boolean function returns True, if the given subclass sub is indeed a subclass of the superclass sup.
 The isinstance(obj, Class) boolean function returns True, if obj is an instance of class Class or is an instance of a subclass of Class
"""
# print(isinstance(child_obj, rindha))
# print(isinstance(child_obj, ganesh))
# print(isinstance(child_obj, venkat))
# print(isinstance(child_obj, subhashini))


""" ############# Hierarchial inheritance #############
 single class inherited by multiple classes
 
 or 
 When more than one derived classes are created from a single base,
 this type of inheritance is called hierarchical inheritance. """

class FiveStar:
   cost = 30 # class_variable / attribute
   def __init__(self):
       print("calling five star method")
   def qwerty(self):
        print("called qwerty method available in rindha class")
   def taste(self):
      print("completely filled with chocolate and caramel")

class Narendra (FiveStar):
    pass


class Varun(FiveStar):
    pass

class Manikanta(FiveStar):
    pass



"""Hybrid Inheritance

Hybrid inheritance is done when we have to mix different types of inheritance within a single program, 
for example, mixing single inheritance with multiple inheritance or multiple inheritance within a single program
"""