Inheritace.py

class Parent:
    def __init__(self, name):
        self.name = name
        print("Parent class initialized with name:", self.name)

class Child1(Parent): 
    def __init__(self, name, age):
        super().__init__(name)  
        self.age = age
        print("Name:", self.name)
        print("Age:", self.age)
        print("Child1 class initialized")

class Child2(Parent): 
    def __init__(self, name):
        super().__init__(name)  
        print("Child2 class initialized")


c1 = Child1("John", 10)
c2 = Child2("Doe")


class Demo1:
    def disp1(self):  # Renamed method to avoid conflict with class name
        print("Demo1 class initialized")

class Demo2:
    def disp2(self):  # Fixed inheritance issue                                       MRO - Method Resolution Order
        print("Demo2 class initialized")

class Demo3(Demo1, Demo2):  # Corrected inheritance
    def disp3(self):
        print("Demo3 class initialized")

# Create an instance of Demo3
d3 = Demo3()
d3.disp3()  # Call disp3 from Demo3
d3.disp2()  # Call disp2 from Demo2
d3.disp1()  # Call disp1 from Demo1

# Print the Method Resolution Order (MRO) of the Demo3 class
print(Demo3.mro()) 


# operator # overloading
class Stuent:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def __str__(self):
        return self.name
    
    def __add__(self, other):
        if isinstance(other, Stuent):
            return self.age + other.age
        return NotImplemented
    

S = Stuent("Anu", 20)
s1 = Stuent("Ram", 21)

print(S.name)  # This will print the name of the student
print(S)       # This will call the __str__ method and print the name
print(S + s1)  # This will add the ages of the two students
print(s1)
print(S == s1)  # This will compare the object references, not the names
print(S is s1)  # This will check if both variables point to the same object


# Operator overloading for circle class
# This class calculates the area and circumference of a circle based on its radius.
class circle:
    def __init__(self, radius):
        self.radius = radius

    def area(self):
        return 3.14 * (self.radius ** 2)

    def circumference(self):
        return 2 * 3.14 * self.radius
    
c = circle(5)
print("Area of circle:", c.area())
print("Circumference of circle:", c.circumference())

c1 = circle(10)
print("Area of circle:", c1.area())
print("Circumference of circle:", c1.circumference())

c2 = circle(15)
print("Area of circle:", c2.area())
print("Circumference of circle:", c2.circumference())

# sum of two rADius
def sum_of_radii(circle1, circle2):
    return circle1.radius + circle2.radius

print("Sum of radii:", sum_of_radii(c, c1))
print("Sum of radii:", sum_of_radii(c1, c2))

# Inheritance Example with Software Development Roles
class SoftwareDeveloper:
    def __init__(self, name, programming_language):
        self.name = name
        self.id = id(self)
        self.intro = (self.name, self.id, programming_language)

class SoftwareEngineer(SoftwareDeveloper):
    def __call__(self):
        return f"{self.name} is coding in {self.intro[2]}"
    
class SoftwareTester(SoftwareDeveloper):
    def __call__(self):
        return f"{self.name} is testing the software in {self.intro[2]}"
    
s1 = SoftwareEngineer("John", "Java")
s2 = SoftwareTester("Bob", "Java")
print(s1.intro)
print(s1())
print(s2.intro)
print(s2())


# Single Inheritance Example with Vehicle
class Vehicle:
    def start(self):
        print("The vehicle is starting.")

# Subclass
class Car(Vehicle):
    def honk(self):
        print("The car is honking. Beep beep!")

# Creating Instance
car1 = Car()
car1.start()   # Output: The vehicle is starting.
car1.honk()    # Output: The car is honking. Beep beep!

# Multiple Inheritance Example with Hybrid Car
class Electric:
    def charge(self):
        print("The vehicle is charging.")
class Engine:
    def fuel(self):
        print("The vehicle is refueling.")
class HybridCar(Electric, Engine):
    def drive(self):
        print("The hybrid car is driving.")

# Creating Instance
hybrid_car = HybridCar()
hybrid_car.charge()   # Output: The vehicle is charging.
hybrid_car.fuel()     # Output: The vehicle is refueling.


# Abstraction easy Example using friuts
from abc import ABC, abstractmethod
class Fruit(ABC):
    @abstractmethod
    def taste(self):
        pass

class Apple(Fruit):
    def taste(self):
        return "Sweet"
    
class Orange(Fruit):
    def taste(self):
        return "Citrus"
    
class Banana(Fruit):
    def taste(self):
        return "Sweet and soft"
    
# Creating instances of each fruit
apple = Apple()
orange = Orange()
banana = Banana()
# Printing the taste of each fruit
print("Apple taste:", apple.taste())
print("Orange taste:", orange.taste())
print("Banana taste:", banana.taste())

# animal example that shows both inheritance and polymorphism
class Animal:
    def sound(self):
        return "Some generic animal sound"
    
class Dog(Animal):
    def sound(self):
        return "Bark"
    
class Cat(Animal):
    def sound(self):
        return "Meow"
    
class money(Animal):
    def sound(self, sound, tail, dance):
        return f"{sound} with {tail} tail and {dance} dance"
    def chirp(self):
        return "Chirp"

# Creating instances of Dog and Cat
dog = Dog()
cat = Cat()

# Creating an instance of money
mon = money()

# Printing the sounds made by each animal
print("Dog sound:", dog.sound())  # Output: Dog sound: Bark
print("Cat sound:", cat.sound())  # Output: Cat sound: Meow
print("Money sound:", mon.sound("Chirp", "long", "happy"))  # Output: Money sound: Chirp with long tail and happy dance


# animal example that shows both inheritance and polymorphism with only monkey with all methods and properties of monkey
class Stuent:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def __str__(self):
        return self.name
    
    def __add__(self, other):
        if isinstance(other, Stuent):
            return self.age + other.age
        return NotImplemented
    
    def __eq__(self, other):
        if isinstance(other, Stuent):
            return self.name == other.name
        return NotImplemented
    
    def __ne__(self, other):
        if isinstance(other, Stuent):
            return self.name != other.name
        return NotImplemented
    
    def __lt__(self, other):
        if isinstance(other, Stuent):
            return self.age < other.age
        return NotImplemented
    
    def __le__(self, other):
        if isinstance(other, Stuent):
            return self.age <= other.age
        return NotImplemented
    
    def __gt__(self, other):
        if isinstance(other, Stuent):
            return self.age > other.age
        return NotImplemented
    
    def __ge__(self, other):
        if isinstance(other, Stuent):
            return self.age >= other.age
        return NotImplemented
    
    def __call__(self):
        return f"{self.name} is {self.age} years old"
    
class money(Stuent):
    def __init__(self, name, age, sound, tail, dance):
        super().__init__(name, age)
        self.sound = sound
        self.tail = tail
        self.dance = dance
    
    def __call__(self):
        return f"{self.name} is {self.age} years old and makes a {self.sound} sound with a {self.tail} tail and does a {self.dance} dance"
    
# Creating instances of Stuent and money
m = money("Monkey", 5, "Chirp", "long", "happy")
m1 = money("Monkey1", 6, "Chirp", "short", "sad")
m2 = money("Monkey2", 7, "Chirp", "medium", "excited")
m3 = money("Monkey3", 8, "Chirp", "long", "joyful")
m4 = money("Monkey4", 9, "Chirp", "short", "playful")
# Printing the details of each monkey
print(m())  # Output: Monkey is 5 years old and makes a Chirp sound with a long tail and does a happy dance
print(m1())  # Output: Monkey1 is 6 years old and makes a Chir

#p sound with a short tail and does a sad dance
print(m2())  # Output: Monkey2 is 7 years old and makes a Chirp sound with a medium tail and does an excited dance
print(m3())  # Output: Monkey3 is 8 years old and makes a Chir

# Absrtaction example for making payments usaing upi and use names of persons Anu, Ram,
class Payment(ABC):
    @abstractmethod
    def pay(self):
        pass

class UPI(Payment):
    def __init__(self, name):
        self.name = name

    def pay(self):
        return f"{self.name} is making a payment using UPI."
    
class CreditCard(Payment):
    def __init__(self, name):
        self.name = name

    def pay(self):
        return f"{self.name} is making a payment using Credit Card."
    
class DebitCard(Payment):
    def __init__(self, name):
        self.name = name

    def pay(self):
        return f"{self.name} is making a payment using Debit Card."
    

# Creating instances of each payment method
upi_payment = UPI("Anu")
credit_card_payment = CreditCard("Ram")
debit_card_payment = DebitCard("Ram")

# Printing the payment methods
print(upi_payment.pay())          # Output: Anu is making a payment using UPI
print(credit_card_payment.pay())  # Output: Ram is making a payment using Credit Card
print(debit_card_payment.pay())   # Output: Sita is making a payment using Debit Card

# telling users about payment operation is successful
def payment_success(payment_method):
    print(f"Payment operation using {payment_method.name} is successful.")
payment_success(upi_payment)          # Output: Payment operation using Anu is successful.
payment_success(credit_card_payment)  # Output: Payment operation using Ram is successful.
payment_success(debit_card_payment)   # Output: Payment operation using Ram is successful.