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

Introduction to OOPs in Python

  Learning Sections          show Introduction to Object-Oriented Programming (OOP) Object-Oriented Programming (OOP) is a programming paradigm that organizes software design around objects rather than actions and data rather than logic. It revolves around the concept of "objects", which are instances of classes. These objects encapsulate data, in the form of attributes or properties, and behaviors, in the form of methods or functions. OOP promotes modularity, reusability, and extensibility in software development. Key Concepts of OOP: Class: A class is a blueprint or template for creating objects. It defines the attributes (data) and methods (functions) that will characterize any object instantiated from that class. Object: An object is an instance of a class. It is a concrete realization of the class blueprint, containing actual values instead of placeholders for attributes. Encapsulation: Encapsulation is ...
Read more

Classes and Objects in Python

  Learning Sections          show Classes and Objects in Python In Python, a class is a blueprint for creating objects. An object is an instance of a class. Classes allow you to logically group data and functions in a way that is easy to manage and reuse. 1. Defining a Class To define a class in Python, you use the class keyword followed by the class name and a colon. Inside the class, you can define attributes and methods. Example: # Define a class class Person : # Class attribute species = 'Human' # Class method def greet ( self ): return 'Hello, I am a person.' # Create an object of the class person1 = Person () # Access class attribute print ( person1 . species ) # Output: Human # Call class method print ( person1 . greet ()) # Output: Hello, I am a person. 2. Creating Objects To create an object of a class, you simply call the class name followed by paren...
Read more

Exception Handling in Python

  Learning sections          show Exception Handling in Python Exception handling in Python is done through the use of try , except , else , and finally blocks. This allows you to catch and handle errors gracefully. Below are some examples and explanations: 1. Basic Try-Except The try block lets you test a block of code for errors. The except block lets you handle the error. # Example of basic try-except try : result = 10 / 0 except ZeroDivisionError : print ( "Cannot divide by zero!" ) # Output: # Cannot divide by zero! 2. Handling Multiple Exceptions You can catch multiple exceptions by specifying multiple except blocks. # Example of handling multiple exceptions try : result = 10 / 0 except ZeroDivisionError : print ( "Cannot divide by zero!" ) except TypeError : print ( "Invalid operation!" ) # Output: # Cannot divide by zero! 3. Using Else The e...
Read more