Abstraction in Python

Abstraction in Python is a concept used in object-oriented programming. It means the hiding of internal implementation details of an object and the exposing of only essential features or functionalities. This makes the interface easier for the user to handle and maintain.

Here’s a detailed explanation:

Key Features of Abstraction

1. Hiding the implementation details:

• Abstraction lets you hide the intricate logic and expose only that part which is necessary for the user.
• For instance, when you drive a car, you use the steering wheel, accelerator, and brakes without worrying about how the engine works.

2. Simplified Interface:

• Users interact with the system through a simplified interface, without having to care about underlying complexities.
• This makes it easier to work with and reduces cognitive load.

3. Increased Modularity:

• Abstraction separates the implementation details, thereby making the code modular to be updated and maintained more easily.

How Abstraction Works in Python

In Python, abstraction is mainly achieved through abstract classes and interfaces. These tools help developers define blueprints for other classes.

Abstract Classes

An abstract class is a class that cannot be instantiated as its own and must be inherited by other classes. The definition of abstract classes relies on the abc module, abstract base class.

Key Points:

• An abstract class contains one or more abstract methods.
• An abstract method is declared in the abstract class, but does not hold an implementation (it has been defined using the decorator @abstractmethod).
• Concrete (non-abstract) classes must implement all the abstract methods inherited from an abstract class.

Implementation Example

Here’s an example to demonstrate abstraction in Python:

from abc import ABC, abstractmethod

# Abstract Class
class Shape(ABC):
    @abstractmethod
    def calculate_area(self):
        pass  # Abstract method (no implementation)

    @abstractmethod
    def calculate_perimeter(self):
        pass  # Abstract method (no implementation)

# Concrete Class 1
class Rectangle(Shape):
    def __init__(self, length, width):
        self.length = length
        self.width = width

    def calculate_area(self):
        return self.length * self.width

    def calculate_perimeter(self):
        return 2 * (self.length + self.width)

# Concrete Class 2
class Circle(Shape):
    def __init__(self, radius):
        self.radius = radius

    def calculate_area(self):
        return 3.14159 * self.radius * self.radius

    def calculate_perimeter(self):
        return 2 * 3.14159 * self.radius

# Usage
rectangle = Rectangle(10, 5)
circle = Circle(7)

print("Rectangle Area:", rectangle.calculate_area())
print("Rectangle Perimeter:", rectangle.calculate_perimeter())
print("Circle Area:", circle.calculate_area())
print("Circle Perimeter:", circle.calculate_perimeter())

Benefits of Abstraction

1. Increased Readability of the Code:
   • Users can work on a simplified interface without going through complex details.
2. Reusability:
   • Abstract classes and methods can be used as templates, thus promoting the reusability of codes.
3. Scalability:
   • It is easier to extend the base class to implement new functionalities with abstract classes.
4. Maintainability:
   • Users interacting with the interface abstractions will not feel any changes in the implementation underlying.

Key Points to Remember

1. Abstraction is focusing on “what” an object does, rather than “how” it does it.
2. In Python, abstraction is not provided by default, as many statically typed languages do-it, but the abc module brings tools for this.
3. An abstract class must be inherited and its abstract methods overridden in the concrete class.