Extending a Class Method in Python

Extending a class method in Python involves inheriting from a parent class and adding new functionality to an existing method. Here’s a tutorial-like description with an

Key Points:

• Inheritance: Reuse and extend code from the parent class.
• Method Overriding: Define a method in the subclass with the same name to extend functionality.
• super() Function: Calls the parent class method to retain original behavior.

Extending class methods enables building on existing code, enhancing functionality without redundancy.

Extending class methods enables you to build on existing code, enhancing functionality without redundancy. This approach allows you to maintain and organize code more efficiently, ensuring that changes in the base functionality are automatically propagated to extended methods in subclasses. It also promotes the DRY (Don’t Repeat Yourself) principle, leading to cleaner and more maintainable code.

# definition of superclass "Triangles" 
class Triangles(object): 
  
  count = 0
  
  # Calling Constructor 
  def __init__(self, name, s1, s2, s3): 
    self.name = name 
    self.s1 = s1 
    self.s2 = s2 
    self.s3 = s3 
    Triangles.count+= 1

  def setName(self, name): 
    self.name = name 

  def setdim(self, s1, s2, s3): 
    self.s1 = s1 
    self.s2 = s2 
    self.s3 = s3 

  def getcount(self): 
    return Triangles.count 
  
  def __str__(self): 
    return 'Name: '+self.name+'\nDimensions: '+str(self.s1)+','+str(self.s2)+','+str(self.s3) 
  
  
# describing a subclass 
# inherits from Triangles 
class Peri(Triangles): 
  
  # function to calculate the area	 
  def calculate(self): 
    self.pm = 0
    self.pm = self.s1 + self.s2 + self.s3 
    
  # function to display just the area 
  # because it is not extended 
  def display(self): 
    return self.pm 
    
  
def main(): 
  
  # instance of the subclass 
  p = Peri('PQR', 2, 3, 4) 
  # call to calculate() 
  p.calculate() 
  # explicit call to __str__() 
  print(p.__str__()) 
  # call to display() 
  print(p.display()) 
  
main() 

Explanation:

In Python, extending a class method involves creating a child class that inherits from a parent class and then overriding a method from the parent class to modify or enhance its behavior. This technique allows for the implementation of polymorphism, where the same method can exhibit different behaviors in different contexts. In the provided example, the animal class includes a method sound that prints a generic message indicating that an animal makes a sound. The dog class, which inherits from, overrides the method to provide a specific implementation that prints “Dog barks.” This method extension allows the class to refine the behavior inherited from the animal class, making it more specific to the dog instance. When an instance of the dog class calls the sound method, the overridden version in the dog class executes, demonstrating the extended behavior. This example underscores the power of object-oriented programming in Python, where subclassing and method overriding enable developers to build more specialized and flexible class hierarchies, promoting code reuse and enhancing modularity. By extending methods, one can tailor inherited functionality to better fit specific needs without altering the original parent class, ensuring a clear and maintainable code structure.