How can you design a Python class to represent a geometric shape (e.g., Circle, Rectangle) with inheritance and method overriding, ensuring each shape calculates its area and perimeter correctly? Implement a base class Shape with abstract methods for area and perimeter, then create derived classes for Circle and Rectangle. Include validation for input parameters and demonstrate polymorphism by storing multiple shapes in a list and iterating through them to calculate total area and perimeter.

from abc import ABC, abstractmethod
import math

class Shape(ABC):
    """Abstract base class for geometric shapes."""
    
    @abstractmethod
    def area(self) -> float:
        """Calculate the area of the shape."""
        pass
    
    @abstractmethod
    def perimeter(self) -> float:
        """Calculate the perimeter of the shape."""
        pass

class Circle(Shape):
    """Represents a circle with a given radius."""
    
    def __init__(self, radius: float):
        if radius <= 0:
            raise ValueError("Radius must be positive.")
        self.radius = radius
    
    def area(self) -> float:
        return math.pi * self.radius ** 2
    
    def perimeter(self) -> float:
        return 2 * math.pi * self.radius

class Rectangle(Shape):
    """Represents a rectangle with width and height."""
    
    def __init__(self, width: float, height: float):
        if width <= 0 or height <= 0:
            raise ValueError("Width and height must be positive.")
        self.width = width
        self.height = height
    
    def area(self) -> float:
        return self.width * self.height
    
    def perimeter(self) -> float:
        return 2 * (self.width + self.height)

# Example usage
shapes = [
    Circle(5),
    Rectangle(4, 6),
    Circle(3),
    Rectangle(7, 2)
]

total_area = 0
total_perimeter = 0

for shape in shapes:
    total_area += shape.area()
    total_perimeter += shape.perimeter()

print(f"Total Area: {total_area:.2f}")
print(f"Total Perimeter: {total_perimeter:.2f}")

# Demonstrate polymorphism
for shape in shapes:
    print(f"{shape.__class__.__name__}: Area = {shape.area():.2f}, Perimeter = {shape.perimeter():.2f}")

Answer: The question explores object-oriented programming concepts in Python using inheritance and abstraction. The solution defines an abstract base class Shape with two abstract methods (area and perimeter) that must be implemented by all derived classes. Two concrete classes, Circle and Rectangle, inherit from Shape and provide their own implementations of the required methods. Input validation is enforced through error checking in the constructors. The example demonstrates polymorphism by storing different shape types in a single list and processing them uniformly. This approach promotes code reusability, maintainability, and extensibility, making it ideal for academic and real-world applications involving geometric calculations.

#Python #OOP #Inheritance #Polymorphism #Abstraction #GeometricShapes #Programming #Academic #IntermediateLevel #ObjectOriented

By: @DataScienceQ 🚀

Python Tip: Mastering init and self in OOP! 🐍

When defining a class in Python, init is a special method (often called the constructor) that gets called automatically every time a new object (instance) of the class is created. It's used to set up the initial state or attributes of that object.

The self parameter is a convention and the first parameter of any instance method. It always refers to the instance of the class itself, allowing you to access its attributes and other methods from within the class.

class Car:
    def init(self, make, model, year):
        self.make = make    # Assign 'make' to the instance's 'make' attribute
        self.model = model  # Assign 'model' to the instance's 'model' attribute
        self.year = year    # Assign 'year' to the instance's 'year' attribute

    def get_description(self):
        return f"This is a {self.year} {self.make} {self.model}."

In the init method, self.make = make means "take the value passed in as make and assign it to the make attribute of this specific Car object."

Let's create some cars:

my_car = Car("Toyota", "Camry", 2020)
your_car = Car("Honda", "Civic", 2022)

print(my_car.get_description())
print(your_car.get_description())

Output:

This is a 2020 Toyota Camry.
This is a 2022 Honda Civic.

init ensures each object starts with its own data, and self connects you to that data!

#PythonTip #OOP #Classes #InitMethod #SelfKeyword #ObjectOriented #PythonProgramming
---
By: @DataScienceQ ✨