Inheritance and Polymorphism

mediumFREEClasses & ObjectsPython OOPPython Foundations

Problem Statement

Implement a class hierarchy for shapes.

Background

Inheritance allows classes to share behavior:

class Child(Parent):
    def __init__(self):
        super().__init__()

Your Task

Create an inheritance hierarchy:

Base class Shape with:
- name attribute
- area() method (returns 0)
- str returning "{name}: area={area}"
Rectangle(Shape) with:
- Constructor taking width and height
- area() returning width * height
Circle(Shape) with:
- Constructor taking radius
- area() returning π * radius²

Example

Input

Rectangle(4, 5)

Output

Rectangle: area=20

Reasoning

Input: Rectangle(4, 5) builds a rectangle with width $= 4$ and height $= 5$ . The caller never passes a name, yet the printed text starts with Rectangle, so each kind of shape must supply its own label to the shared Shape part.
Math: a rectangle's area is width times height: $4 \times 5 = 20$ . Both sides are whole numbers, so the area stays the integer $20$ , and rounding it to 2 decimal places leaves it as $20$ (not $20.00$ or $20.0$ ).
Output: the text has the form "name: area=value", giving Rectangle: area=20. That format belongs to the base Shape; it works for every shape because it asks the object for its own area, and the rectangle's version is the one that answers.
Compare a circle: one of radius $3$ has area $\pi r^2 = 9\pi \approx 28.2743$ , which rounds to $28.27$ , so it prints Circle: area=28.27.
Notice: a plain Shape with no override reports an area of $0$ ; only the subclasses know a real formula.

Constraints

Use math.pi for π
Round area to 2 decimal places in str

Learn this in

Python FoundationsFoundations

More from Python Foundations

Magic Methodsmedium Basic Class Creationeasy Decorator Implementationmedium Higher-Order Functionsmedium Function with Default Argseasy

Concept primer

Background Knowledge

Inheritance enables a class (child/subclass) to inherit attributes and methods from a base class (parent/superclass), promoting code reuse and establishing an "is-a" relationship. In Python, this is declared using class Child(Parent):, and super() calls the parent's methods, such as in constructors. For example, a Shape base class can define common behavior like reporting area, which derived classes override.

Polymorphism allows objects of different classes to be treated interchangeably through a common interface, often via method overriding. Here, Rectangle and Circle both implement area(), but compute it differently—enabling uniform calls like shape.area() regardless of type. Python's duck typing ("if it walks like a duck...") supports this dynamically, while str ensures consistent string representation across the hierarchy.

This hierarchy models real-world abstraction: all shapes share a name and area concept, but specifics vary, demonstrating OOP principles like encapsulation (data/method bundling) and extensibility.

Algorithm/Approach

Use a single inheritance tree rooted at Shape:

Define abstract-like base behavior in Shape (default area(), common str).
Extend with subclasses Rectangle and Circle, overriding area() via specific formulas.
Leverage super().init() for shared initialization and polymorphism for interchangeable use.

This top-down design ensures subclasses specialize without duplicating code, aligning with Python's Method Resolution Order (MRO) for single inheritance.

Step-by-Step Strategy

Implement Shape:

Add name as instance attribute (e.g., set in init).
Define area(self) returning 0.
Override str(self) to format as "{name}: area={self.area()}" (calls area() dynamically).

Create Rectangle(Shape):

init(self, width, height): Store dimensions, call super().init() with name="Rectangle".
Override area(self): return width * height.

Create Circle(Shape):

init(self, radius): Store radius, call super().init() with name="Circle".
Override area(self): return math.pi * radius ** 2 (import math).

Test polymorphism: Instantiate objects and print—str invokes overridden area() automatically.

Common Pitfalls

Forgetting super().init(): Leads to uninitialized base attributes like name.
str calling area() incorrectly: Use self.area() (not hardcoded) to ensure polymorphism works.
Missing math import for $\pi$ : Area will error; format output to ~2 decimals if needed (e.g., "{:.2f}".format()).
Hardcoding values: Avoid fixed names/dimensions—use parameters; don't redefine base methods unnecessarily.
Attribute access: Store self.width, self.height, etc., for area(); scope issues if using locals.

Time & Space Complexity

Time: Each area() is O(1) (constant arithmetic). str is O(1). Instantiation/construction is O(1).
Space: O(1) per object (fixed attributes: name, dimensions). Hierarchy adds no asymptotic overhead; Python objects have minor constant overhead for MRO.

solution.py

Python 3.13

Test results