Skip to main content

Single Inheritance in Python

 


Learning Sections          show

Single Inheritance in Python

Single inheritance is a fundamental concept in object-oriented programming (OOP) where a derived class (child class) inherits properties and behaviors (methods) from a single base class (parent class). This mechanism allows for code reuse, logical organization, and the creation of hierarchical relationships between classes.

Example of Single Inheritance

Let's look at an example to understand how single inheritance works in Python.


# Define the base class
class Animal:
    def __init__(self, name):
        self.name = name

    def speak(self):
        return f"{self.name} makes a noise"

# Define the derived class
class Dog(Animal):
    def speak(self):
        return f"{self.name} barks"

# Create an instance of the derived class
dog = Dog("Buddy")
print(dog.speak())  # Output: Buddy barks
Explanation:

In this example, we have two classes: Animal and Dog. The Animal class is the base class with an initializer method __init__ that sets the name of the animal and a method speak that returns a string indicating the animal makes a noise. The Dog class is the derived class that inherits from Animal and overrides the speak method to return a string indicating the dog barks.

Creating a Hierarchical Structure

Single inheritance allows the creation of a hierarchical structure where more specific classes inherit from more general classes. This helps in organizing code in a logical and meaningful way. For instance, consider the following example:


# Base class
class Vehicle:
    def __init__(self, make, model):
        self.make = make
        self.model = model

    def display_info(self):
        return f"Vehicle: {self.make} {self.model}"

# Derived class
class Car(Vehicle):
    def display_info(self):
        return f"Car: {self.make} {self.model}"

car = Car("Toyota", "Corolla")
print(car.display_info())  # Output: Car: Toyota Corolla
Advantages of Single Inheritance
  • Code Reusability: Methods and attributes defined in the base class can be reused in the derived class, reducing code duplication.
  • Logical Structure: Establishes a clear and logical hierarchical structure, making the code easier to understand and maintain.
  • Method Overriding: Allows the derived class to override methods of the base class to provide specific functionality.
Disadvantages of Single Inheritance
  • Limited Reuse: Single inheritance restricts the derived class to inherit from only one base class, limiting reuse if multiple base classes have useful methods or attributes.
  • Tight Coupling: The derived class is tightly coupled to the base class, meaning changes in the base class can affect the derived class.
Key Points
  • Single inheritance involves a derived class inheriting from a single base class.
  • The derived class can access and override methods and attributes of the base class.
  • Helps in organizing code in a hierarchical manner.
  • Provides benefits like code reuse, logical structure, and method overriding.
  • Has some limitations like limited reuse and tight coupling.
Labels:

Popular posts from this blog

Generators in Python

  Learning Sections          show Generators in Python Generators are a special type of iterator in Python that allow you to iterate over a sequence of items without storing them all in memory at once. They are useful for generating large sequences of data on-the-fly, or for processing data in a memory-efficient manner. Creating Generators In Python, generators are created using generator functions or generator expressions: # Generator function def my_generator ( n ): for i in range ( n ): yield i # Generator expression my_generator = ( i for i in range ( 10 )) A generator function uses the yield keyword to yield values one at a time, while a generator expression creates an anonymous generator. Iterating Over Generators You can iterate over the values produced by a generator using a for loop: for value in my_generator ( 5 ): print ( value ) This w...
Read more

Inheritance in Python

  Learning Sections          show Inheritance in Python Inheritance is a fundamental concept in object-oriented programming (OOP) that allows a class to inherit attributes and methods from another class. The class that inherits is called the child class or subclass, and the class being inherited from is called the parent class or superclass. Basic Inheritance In Python, a child class inherits from a parent class by specifying the parent class in parentheses after the child class name. Example: class Animal : def __init__ ( self , name ): self . name = name def speak ( self ): raise NotImplementedError ( "Subclass must implement this method" ) class Dog ( Animal ): def speak ( self ): return "Woof!" class Cat ( Animal ): def speak ( self ): return "Meow!" # Create instances of Dog and Cat dog = Dog ( "Buddy" ) cat = Cat ( "Whiskers" ...
Read more

If else Conditional Statements in Python

  Learning Sections     show If-Else Conditional Statements Conditional statements allow you to execute different blocks of code based on certain conditions. The most common conditional statement is the if statement. It can be used alone, or combined with elif (else if) and else statements to handle multiple conditions. If Statement The if statement evaluates a condition, and if the condition is true, the block of code indented under the if statement is executed. # If statement example x = 10 if x >> 0 : print ( "x is positive" ) If-Else Statement The if-else statement adds an additional block of code that runs if the condition is false. # If-else statement example x = -10 if x >> 0 : print ( "x is positive" ) else : print ( "x is non-positive" ) If-Elif-Else Statement The if-elif-else statement allows you to check multiple conditions. The fir...
Read more