Python inheritance enables classes to share methods and properties, making code easier to reuse and extend. This article walks through practical examples that show how inheritance works in everyday projects.
Below is a quick reference that outlines core concepts, common use cases, and tradeoffs so you can decide when to use inheritance in Python.
| Scenario | Base Class Role | Derived Class Role | Key Benefit |
|---|---|---|---|
| User profiles | Common attributes like name and email | Admin and Guest with extra permissions | Shared validation and login logic |
| Payment processing | Process and refund interface | CreditCardPayment and PayPalPayment | Consistent checkout flow |
| Geographic data | Location with lat/lon | City and Country with labels | Reusable distance calculation |
| Device control | Turn on/off and status | SmartLight and Thermostat | Polymorphic device management |
Defining a Base Class and Subclass
Start with a base class that captures shared behavior, then create subclasses that inherit and optionally extend functionality.
In this example, Vehicle serves as the parent class with start and stop methods, while Car overrides start to add model-specific logic.
Syntax and Method Resolution
Using super() ensures the parent implementation runs, which is important for initialization and state consistency.
Subclasses can introduce new attributes and methods without changing the base class, following the open closed principle.
Overriding and Extending Methods
Override methods in a subclass when you need different behavior while keeping the same interface.
Extended methods let you add steps before or after the inherited behavior, which is handy for logging or validation.
Practical Use Case: Shape and Circle
A Shape base class can define area as an abstract method, while Circle implements it with radius-specific math.
This pattern makes it easy to add Rectangle, Triangle, or other shapes later, each providing its own formula.
Multiple Inheritance and Mixins
Python supports multiple inheritance, allowing a class to inherit from more than one parent, which is useful for composing behavior.
Mixins are small classes focused on a single feature, such as serialization or caching, that can be reused across unrelated hierarchies.
Method Resolution Order (MRO)
Python follows C3 linearization to decide which method to call when multiple parents define the same name.
You can inspect MRO with ClassName.mro() to understand the lookup path and avoid surprising behavior.
Design Guidelines and Best Practices
Use inheritance when subclasses truly represent a kind-of relationship and can share meaningful logic.
Prefer composition for cross-cutting concerns to keep classes focused and reduce coupling.
- Keep the base class small and focused on shared interface and state.
- Use abstract base classes to enforce required methods in subclasses.
- Document overridden methods so the intent of changes is clear.
- Test each subclass independently to verify both inherited and new behavior.
Applying Inheritance to Real Projects
In production code, inheritance helps organize domain models, reduce duplication, and support polymorphism in frameworks and APIs.
Thoughtful class design, clear documentation, and tests ensure that inheritance remains a powerful tool without introducing fragility.
FAQ
Reader questions
How does super() behave with multiple inheritance in Python?
super() follows the MRO to call the next method in line, which ensures each class in the hierarchy is initialized once in the correct order.
Can I inherit from built-in types like list or dict?
Yes, you can subclass list or dict to add custom methods while retaining all standard operations and interface guarantees.
What happens if a subclass does not call the parent initializer?
The parent state may remain uninitialized, leading to missing attributes or inconsistent objects unless setup logic is handled elsewhere.
When should I choose composition over inheritance?
Choose composition when behavior is cross-cutting, frequently changing, or better expressed by delegating to other objects rather than modeling a strict hierarchy.