• 🚶 Single Inheritance: One path to follow

Inheritance in Python: 🎉 Reuse of Class Members (Variables and Methods) 🚀

Definition 1: 📘 Inheritance is the magic of object-oriented programming ✨🪄. It lets you inherit the treasure of class members—variables and methods—from one class (called the superclass or base class) to another class (called the subclass or derived class). Think of it as learning from wise mentors who pass down their knowledge to eager learners.

Definition 2: 🪄 Imagine this: Inheritance is like getting cool gadgets and superpowers 🦸‍♂️🦸‍♀️ from your favorite superheroes without becoming one yourself. It lets you copy properties and behaviors defined in one class and add them to another class, all without wearing a superhero costume.

Key Points: 🗝️

1. Superclass (Base Class): 🧙‍♂️ The superclass, also known as the base class or the Master Class, is where all the master skills are stored. It’s the class that you inherit all the awesome tricks from. Think of it as Dumbledore teaching young wizards.

2. Subclass (Derived Class): 🚀 The subclass, your ready-to-go rocket, is where you use those inherited superpowers for your own purposes. It’s the class that extends and improves the skills of the superclass. You’re the Iron Man flying with your suit!

3. Accessing Properties: 💼 Whether it’s a wand or a jetpack, you can access both superclass properties (variables and methods) and subclass properties using the “subclass_reference.variable” or “subclass_reference.method()” syntax. It’s like having a magic key—simple and effective.

Now, let’s see this in a fun textual diagram:

🧙‍♂️ Superclass (Base Class) 📚
┌───────────────────┐
│   Inherited      │
│   Superpowers!   │
└───────────────────┘
       ^
       |
       |
       |
       |
       v
🚀 Subclass (Derived Class) 🌌
┌───────────────────┐
│   Unleash Your    │
│   Imagination!    │
└───────────────────┘

In this playful representation, the superclass shares its skills, and the subclass flies into the space with the inherited superpowers. Happy coding! 🌟💻🚀

Single Inheritance in Python: Building on Family Traits

Imagine you come from a family of artists, and you have a unique talent for painting. You decide to pass down this artistic gift to your child. In the world of programming, this is similar to what we call Single Inheritance.

In Python, Single Inheritance is a concept where a new class (your child) can inherit attributes and abilities from only one existing class (you or a superclass). Think of it as your child inheriting your artistic skills and adding their own artistic style.

Here's a textual diagram illustrating single inheritance in Python:

🔵 Artist (Superclass) 🔵
┌───────────────────────┐
│   art_style           │
│   paint()             │
└───────────────────────┘
         ^
         |
         |
         |
         |
         v
🟢 ChildArtist (Subclass) 🟢
┌───────────────────────┐
│   art_style           │
│   own_style           │
│   paint()             │
│   develop_own_style() │
└───────────────────────┘

In this diagram:

• The "Artist" class (Superclass) has attributes and methods related to artistic skills, including the art_style attribute and the paint() method.
• The "ChildArtist" class (Subclass) inherits from "Artist" and extends it with its own attributes and methods, including the own_style attribute and the develop_own_style() method.

This diagram visually represents how the "ChildArtist" class inherits the traits (attributes and methods) of the "Artist" class and adds its own unique traits, showcasing the concept of single inheritance in Python.

Here's an illustrative example:

# Define a superclass named Artist
class Artist:
    def __init__(self, art_style):
        self.art_style = art_style

    def paint(self):
        print(f"Creating art with {self.art_style} style")

# Create a subclass named ChildArtist that inherits from Artist
class ChildArtist(Artist):
    def develop_own_style(self, own_style):
        print(f"Developing their own artistic style: {own_style}")

# Create an instance of the ChildArtist class
child = ChildArtist("Impressionism")

# The child inherits the ability to paint from the Artist class
child.paint()  # This will create art with Impressionism style

# The child can also develop their own artistic style
child.develop_own_style("Abstract")

Output:

Creating art with Impressionism style
Developing their own artistic style: Abstract

In this example:

• The Artist class represents your artistic ability and has a method to create art.
• The ChildArtist class inherits from Artist and adds a method to develop their own artistic style.
• The child (an instance of ChildArtist) can create art using the inherited paint method and develop their own unique style.

This is how single inheritance allows a subclass to inherit and extend the abilities of a superclass, much like passing down artistic talent through generations.​