Let us jump right into it. No BS!
Import the ABC (Abstract Base Class) module and abstractmethod from the abc module in Python. The ABC module is used for defining abstract base classes.

from abc import ABC, abstractmethod

Now, to create a new abstract base class, we simply need to create a class.
Here, we will call it Shape and it inherits from ABC Shape(ABC)

The abstractmethod decorator is used to declare abstract methods within an abstract class.

class Shape(ABC):
    @abstractmethod
    def area(self):
        """Abstract method to calculate the area of the shape."""
        pass

    @abstractmethod
    def perimeter(self):
        """Abstract method to calculate the perimeter of the shape."""
        pass

That's it! you've just defined an abstract base class.

In this example, Shape is an abstract base class with two abstract methods: area and perimeter.
We can have pass for method area and perimeter because they don't do anything in Shape class definition. They don't contain an implementation in abstract class.

We provide implementation for the abstract methods via subclasses. For this example we create two subclasses Circle and Square

class Circle(Shape):
    def __init__(self, radius):
        self.radius = radius

    def area(self):
        return 3.14 * self.radius * self.radius

    def perimeter(self):
        return 2 * 3.14 * self.radius

class Square(Shape):
    def __init__(self, length):
        self.length = length

    def area(self):
        return self.length * self.length

    def perimeter(self):
        return 4 * self.radius

To be valid child of Shape, we need to define area and perimeter for the subclasses. The Circle and Square classes are subclasses of Shape and provide concrete implementations for the abstract methods.

We can now create objects for classes circle and square

circle = Circle(radius=5)
square = Square(length=4)

print("Circle Area: ", circle.area())
print("Square Area: ", square.area())
print("Circle Perimeter: ", circle.perimeter())
print("Square Perimeter: ", square.perimeter())

Now our final code looks something like this.

from abc import ABC, abstractmethod

class Shape(ABC):
    @abstractmethod
    def area(self):
        """Abstract method to calculate the area of the shape."""
        pass

    @abstractmethod
    def perimeter(self):
        """Abstract method to calculate the perimeter of the shape."""
        pass

class Circle(Shape):
    def __init__(self, radius):
        self.radius = radius

    def area(self):
        return 3.14 * self.radius * self.radius

    def perimeter(self):
        return 2 * 3.14 * self.radius

class Square(Shape):
    def __init__(self, length):
        self.length = length

    def area(self):
        return self.length * self.length

    def perimeter(self):
        return 4 * self.length

circle = Circle(radius=5)
square = Square(length=4)

print("Circle Area: ", circle.area())
print("Square Area: ", square.area())
print("Circle Perimeter: ", circle.perimeter())
print("Square Perimeter: ", square.perimeter())

Let us not implement a method from subclass. You can remove any. Here, I have removed perimeter method from Square class.

class Square(Shape):
    def __init__(self, length):
        self.length = length

    def area(self):
        return self.length * self.length

When you run the program after removing a method from a subclass, you will receive an error message.

TypeError: Can't instantiate abstract class Square without an implementation for abstract method 'perimeter'

This means that any concrete subclass of Shape must provide its own implementation of area and perimeter. If a subclass fails to do so, it will result in a TypeError during instantiation.

This example demonstrates the usefulness of abstract base class in ensuring a consistent interface. It helps to avoid unintended mistakes and ensures a consistent interface for all subclasses when collaborating with others and working on a large project, where maintaining a clear and predictable structure is crucial.

So, in a nutshell, importing ABC and abstractmethod from the abc module allows you to create abstract classes with abstract methods in Python. Subclasses of these abstract classes need to provide their own implementations for the abstract methods.