docs: add term entry for Single Inheritance in Python

This commit adds a new term entry under `content/python/concepts/inheritance/terms/single-inheritance/`.
It includes:
- Metadata and SEO-optimized description
- Definition with clear examples
- Syntax section
- Visual diagram for understanding
- A runnable Codebyte in Python
- Cross-links to related concepts

Closes #7078

Author: Prankisster

content/python/concepts/inheritance/terms/single-inheritance/single-inheritance.md

@@ -0,0 +1,106 @@
+---
+Title: 'Single Inheritance'
+Description: 'Explains single inheritance in Python, where one subclass inherits from a single parent class.'
+Subjects:
+  - 'Python'
+  - 'Object-Oriented Programming'
+Tags:
+  - 'Classes'
+  - 'Inheritance'
+  - 'OOP'
+CatalogContent:
+  - 'learn-python-3'
+  - 'paths/computer-science'
+---
+
+**Single inheritance** is a core concept in object-oriented programming (OOP), where a class (called the child or subclass) inherits attributes and methods from one parent (or superclass). It enables code reuse, logical hierarchy, and cleaner structure in simple inheritance relationships.
+
+In Python, single inheritance is achieved by defining the subclass with the name of the superclass in parentheses. This allows the subclass to extend or override the functionality of the parent class.
+
+## Syntax
+
+```python
+class ParentClass:
+    # Parent class attributes and methods
+
+class ChildClass(ParentClass):
+    # Child class inherits from ParentClass
+    # Can override or extend functionality
+````
+
+* `ParentClass`: The base class whose methods and attributes are inherited.
+* `ChildClass`: The derived class that inherits from `ParentClass`.
+* The subclass can override methods from the parent or introduce its own new behavior.
+
+## Example
+
+```python
+class Animal:
+    def speak(self):
+        return "Makes a sound"
+
+class Dog(Animal):
+    def speak(self):
+        return "Barks"
+
+a = Animal()
+d = Dog()
+
+print(a.speak())  # Output: Makes a sound
+print(d.speak())  # Output: Barks
+```
+
+### Explanation:
+
+* `Dog` inherits from `Animal`.
+* Both classes define a `speak()` method, but `Dog` overrides the inherited method.
+* This shows how subclasses can provide specialized behavior while still inheriting from the parent.
+
+## Codebyte Example
+
+```codebyte/python
+class Vehicle:
+    def start_engine(self):
+        return "Engine started"
+
+class Car(Vehicle):
+    def drive(self):
+        return "Car is driving"
+
+my_car = Car()
+
+print(my_car.start_engine())  # Inherited method
+print(my_car.drive())         # Subclass method
+```
+
+## Diagram
+
+Here's a simple representation of single inheritance:
+
+```
++-------------+
+| Vehicle     |
+|-------------|
+| start_engine|
++------+------+
+       |
+       ▼
++-------------+
+| Car         |
+|-------------|
+| drive       |
++-------------+
+```
+
+By using single inheritance:
+
+* **Code reusability** is enhanced.
+* **Modularity** improves through separation of concerns.
+* **Maintenance** becomes easier since shared behavior is centralized.
+
+> ⚠️ Use single inheritance when a subclass logically "is-a" type of its superclass and no multiple base classes are needed.
+
+### Related Concepts
+
+* [Multiple Inheritance](../../inheritance.md)
+* [super() Function in Python](../../../built-in-functions/terms/super/super.md)