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

MultiProcessing in Python

  Learning Sections          show MultiProcessing in Python Multiprocessing in Python involves using the multiprocessing module to run multiple processes concurrently, taking advantage of multiple CPU cores. This module provides a higher level of concurrency than threading and is especially useful for CPU-bound tasks. Creating Processes You can create and start a new process by using the multiprocessing module: import multiprocessing def print_numbers (): for i in range ( 10 ): print ( i ) p1 = multiprocessing.Process ( target = print_numbers ) p1 . start () p1 . join () # Wait for the process to complete Using Process Pools The multiprocessing module provides a Pool class, which allows you to manage a pool of worker processes: from multiprocessing import Pool def square ( n ): return n * n with Pool ( 4 ) as pool : result = pool.map ( square , range (...
Read more

Learn Python

  Learning Sections Introduction to Python Comment, escape sequence and print statement in Python Variables and Data Types in Python Typecasting in Python User input in Python String slicing and operations on string in Python String methods in Python If else conditional statements in Python Match case statement in Python For loops in Python While loops in Python Break and continue statement in Python Functions in Python Function Arguments in Python introduction to lists in Python List methods in Python Tuples in Python Operations on tuple in Python f strings in Python Docstrings in Python Recursion in Python Sets in Python Set methods in Python Dictionaries in Python for Loop with else in Python Exception Handling in Python Finally keyword in Python Raising custom errors in Python Short hand if else statements Enumerate Function in Python Virtual Environment in Python How import works in Python if __nam...
Read more

Introduction to Python Programming

  Learning Sections      show History of Python Python was created by Guido van Rossum and first released in 1991. He wanted to create a language that was easy to read and simple to use. The name "Python" comes from the British comedy series "Monty Python's Flying Circus". Key Features of Python Readability: Python's syntax is clear and easy to read. Ease of Learning: Python is straightforward, making it great for beginners. High-Level Language: Python handles much of the complexity of the computer’s operations. Interpreted Language: Python runs code line-by-line, which makes debugging easier. Dynamically Typed: You don’t need to declare variable types. Extensive Standard Library: Python has many built-in modules for various tasks. Portability: ...
Read more