Welcome back! Previously, you delved into polymorphism and learned how to create more flexible code structures using classes and inheritance. In this session, we will take a step further and explore a crucial aspect of Object-Oriented Programming in Python: abstract classes and abstract methods.

An abstract class is a class that cannot be instantiated directly. Think of it as a blueprint for other classes. It often includes one or more abstract methods. A class that inherits from an abstract class must implement all its abstract methods.

In Python, the abc (Abstract Base Classes) module provides tools for defining abstract base classes. An abstract base class is a class that cannot be instantiated directly and often includes one or more abstract methods. These classes serve as blueprints for other classes, enforcing a consistent interface for a group of derived classes. By defining common behavior in abstract base classes, we ensure that derived classes follow the same protocol, making our code more predictable and robust.

Example:

Python
Copy to clipboard
1from abc import ABC, abstractmethod
2
3class Animal(ABC):
4    @abstractmethod
5    def sound(self):
6        pass

In this snippet, Animal is an abstract class with an abstract method sound. You cannot create an instance of Animal, but you can inherit from it. Any subclass of Animal must thereby implement the sound method.

When you define an abstract method within an abstract class, it acts as a placeholder without any implementation, serving as a rule that subclasses must follow. These methods establish a required interface, ensuring that any subclass provides its specific implementation. This approach enforces consistency across subclasses while allowing each to fulfill the required behavior uniquely, promoting organized and reliable code.

By mastering abstract classes and abstract methods, you'll be able to easily add new types of derived classes without modifying existing code — a key principle of software design. For example, consider the following implementation, where you adhere to the defined interface without any modifications to the existing Shape class:

Python
Copy to clipboard
1from abc import ABC, abstractmethod
2
3class Shape(ABC):
4    @abstractmethod
5    def area(self):
6        pass
7    
8    @abstractmethod
9    def perimeter(self):
10        pass
11
12class Circle(Shape):
13    def __init__(self, radius):
14        self.radius = radius
15    
16    def area(self):
17        return 3.14159 * self.radius * self.radius
18    
19    def perimeter(self):
20        return 2 * 3.14159 * self.radius
21
22class Rectangle(Shape):
23    def __init__(self, width, height):
24        self.width = width
25        self.height = height
26    
27    def area(self):
28        return self.width * self.height
29    
30    def perimeter(self):
31        return 2 * (self.width + self.height)
32
33if __name__ == "__main__":
34    circle = Circle(5)
35    rectangle = Rectangle(4, 6)
36
37    print(f"Circle Area: {circle.area()}, Perimeter: {circle.perimeter()}")
38    # Output: Circle Area: 78.53975, Perimeter: 31.4159
39    print(f"Rectangle Area: {rectangle.area()}, Perimeter: {rectangle.perimeter()}")
40    # Output: Rectangle Area: 24, Perimeter: 20

Here, the Shape class is an abstract class that sets a blueprint with two abstract methods: area and perimeter. Subclasses must implement these methods. The Circle class inherits from Shape, using its constructor to initialize the radius and providing specific implementations for calculating the circle's area and perimeter based on the radius. The Rectangle class also inherits from Shape, initializing its width and height in the constructor, and implementing methods to compute its area and perimeter.

In the __main__ block, instances of Circle and Rectangle are created, and their areas and perimeters are printed, demonstrating the concrete implementations in each subclass. Importantly, the Shape class cannot be instantiated directly; only its subclasses with concrete method implementations can be instantiated. This ensures a consistent interface, enhancing code maintainability and readability by enforcing a structured and predictable way of defining shapes.

Consider a scenario where you have a generic concept of Payment. Different payment methods might include CreditCardPayment and PayPalPayment. You want to ensure that each payment method has a process_payment method. Here’s how you can enforce this:

Python
Copy to clipboard
1from abc import ABC, abstractmethod
2
3class Payment(ABC):
4    @abstractmethod
5    def process_payment(self, amount):
6        pass
7
8class CreditCardPayment(Payment):
9    def process_payment(self, amount):
10        return f"Processing credit card payment of {amount}"
11
12class PayPalPayment(Payment):
13    def process_payment(self, amount):
14        return f"Processing PayPal payment of {amount}"

This setup ensures that all payment methods implement the process_payment method. It creates more organized and readable code, encourages code reusability by placing common code in abstract base classes, and enhances flexibility.

Abstract classes and methods are powerful tools in Python's OOP arsenal. They allow you to define a blueprint for a group of related classes, ensuring that all subclasses follow a specific interface and thus promoting consistency and reliability in your code. By mastering the principles of abstract base classes and abstract methods, you can create more organized, maintainable, and scalable software. These techniques foster code reusability and flexibility, making it easier to introduce new types of derived classes without modifying existing code, which aligns with key principles of software design.

Confidently use abstract classes and methods to structure your Python programs, enabling cleaner and more predictable interfaces for your classes. Excited to start practicing? Let's move on and put this theory into action!