Abstract Classes and Abstract Methods in Python are useful to implement the concepts of Abstraction in Python.

Abstraction refers to the act of hiding background details from the end-user and only displaying the necessary details needed to carry out the basic operations. Abstraction is one of the key principle of Object Oriented Programming.

The principle of Abstraction mainly focuses on ‘WHAT’ not on ‘HOW’. Like, what is a particular thing, not how it’s developed.

Example of Abstraction in real life:

1. If you belong to 18+ age group, then, you must have rode a bike. You only know the basic details that are essential to ride a bike, like acceleration, clutch usage, gear change etc.
You don’t give a damn about how internal operations are happening like energy conversions, wiring etc.
This is Abstraction in real world.

Let’s see how we implement Abstraction in Python using Abstract Class and Abstract Method.

Abstract Method in Python

An abstract method in Python is a method that is marked with a decorator @abstractmethod. Abstract methods are generally written without the body, (they are declared not defined). Their definition is eventually provided in the subsequent subclasses, however, there is no harm in writing an abstract method with a body.

Syntax

class Main(ABC): # abstract class
  @abstractmethod 
  def fun(self):
    pass

A normal class cannot have abstract methods inside it rather they are included in abstract class.

Abstract Class in Python

An abstract class is a class that generally contains atleast one abstract method. We (PVMs) can not create objects for abstract classes but an abstract class can be inherited.

It is considered as the best practice to create subclasses and implement all the abstract methods of an abstract class. Thereafter, we can create objects for these subclasses (remember, they are just like normal class).

Creating an abstract class in Python

The best way to create an abstract class in python is to derive it from the meta class ABC.

Python provides abc module to use the abstraction in our Python program. Please note that it is important to import abc module in our Python program to use the concept of Abstract Class.

from abc import ABC, abstractmethod
class Abstract(ABC):

In the above code, abc is abstract base class and abstractmethod is a decorator.

Let’s see one complete python program implementing the concept of abstract classes and abstract methods:

from abc import ABC, abstractmethod # importing ABC from module abc

# Calculator is our abstract class inheriting meta class
class Calculator(ABC):
    
    # let's declare abstract method using decorator
    # definition for this method is provided in subclasses
    @abstractmethod
    def get_result(self, num):
        pass # no code sir

# subclass to calculate Square of a number
class Square(Calculator):
    def get_result(self, num):
        print('Square of number {0}: {1}'.format(num, num ** 2))

# subclass to calculate Cube of a number
class Cube(Calculator):
    def get_result(self, num):
        print('Cube of number {0}: {1}'.format(num, num ** 3))

# subclass to calculate Log of a number
import math
class Log(Calculator):
    def get_result(self, num):
        print('Log of number {0}: {1}'.format(num, math.log(num)))

# creating object of subclass
s = Square()
s.get_result(10)

# creating object of subclass
c = Cube()
c.get_result(10)

# creating object of subclass
l = Log()
l.get_result(1)

O/P

Square of number 10: 100
Cube of number 10: 1000
Log of number 1: 0.0

In the above code,

Calculator: Our abstract class
Square, Cube, Log: Our subclasses
get_result(): Our abstract method
@classmethod: A decorator used to specify the abstract method

You must have observed that our abstract method get_result is implementated as per the requirements i.e for different tasks.

Above code is also an example of other OOPs principle:
1. Inheritance: Observe the Single Inheritance in the above code. Know more here.
2. Polymorphism: Same method being used in different ways.

Few Important points on Abstract classes

* An abstract class can contain both abstract methods or non abstract methods.

* An abstract class is known to perform different tasks through different implementations of its methods in subclasses.

* An abstract class will become an interface when it contains only abstract methods.

* An abstract class is useful when there are some common features to be shared by many objects.

* Abstract class (Abstract method) is also an example of Polymorphism in Python.

That’s all here.

NEXT TUTORIAL>> Errors in Python