Python Abstraction

Learning Objectives

By the end of this lesson, you will understand how abstraction helps developers design clear and maintainable object-oriented systems.

What Is Abstraction?

Abstraction means exposing the important parts of an object while hiding unnecessary implementation details.

In other words, abstraction focuses on:

Consider a car.

When you drive a car, you interact with controls such as the steering wheel, accelerator, brake, and gear selector. You do not need to understand every internal engine calculation in order to drive it.

The interface is simple, while the internal implementation is complex.

Why Abstraction Matters

Software applications can contain thousands or even millions of lines of code.

If every developer or user needed to understand every internal detail, software would become extremely difficult to use and maintain.

Abstraction provides a simpler interface.

payment.process(5000)

The caller does not need to know whether the payment system communicates with a bank, validates a card, creates a transaction record, contacts an API, or generates a receipt.

Those details can remain inside the implementation.

Real-World Abstraction

We use abstraction every day, often without noticing it.

ATM

An ATM provides options such as:

• Withdraw money
• Deposit money
• Check balance

You do not need to understand the internal banking infrastructure.

Web Browser

You enter a URL and the browser handles many internal operations:

• DNS lookup
• Network communication
• HTTP requests
• Response processing
• Rendering

The user interacts with a simple interface.

E-commerce Checkout

A customer may simply click:

Place Order

Behind the button, the application may validate stock, calculate taxes, process payment, create an order, update inventory, and send notifications.

That complexity is hidden behind a simpler interface.

Abstraction vs Encapsulation

These two concepts are closely related but have different purposes.

Abstraction
→ Focuses on what an object does.
→ Hides unnecessary implementation complexity.

Encapsulation
→ Focuses on protecting and controlling object data.
→ Controls how internal state is accessed.

A well-designed class can use both principles at the same time.

Abstract Classes

An abstract class is a class designed to act as a blueprint for other classes.

It can define methods that child classes are expected to implement.

Abstract classes are useful when several classes share a common concept but need different implementations.

For example:

Payment
├── CreditCardPayment
├── BankTransfer
└── DigitalWallet

Every payment method should provide a way to process a payment, but each payment system may implement the process differently.

The abc Module

Python provides the abc module for creating abstract base classes.

abc stands for Abstract Base Classes.

We can import the required tools using:

from abc import ABC, abstractmethod

ABC provides the base class used to create abstract classes.

abstractmethod marks a method that child classes are expected to implement.

The @abstractmethod Decorator

The @abstractmethod decorator tells Python that a method is required in concrete child classes.

from abc import ABC, abstractmethod


class Payment(ABC):

    @abstractmethod
    def pay(self, amount):
        pass

Here, Payment defines the idea of a payment operation, but it does not provide a specific payment implementation.

A concrete child class must implement pay() before it can be instantiated normally.

Basic Abstract Class

Let's create a simple abstract class for animals.

from abc import ABC, abstractmethod


class Animal(ABC):

    @abstractmethod
    def speak(self):
        pass

The class says:

The abstract class defines the required interface without deciding exactly how every animal should speak.

Implementing Child Classes

Child classes can implement the abstract method in their own way.

from abc import ABC, abstractmethod


class Animal(ABC):

    @abstractmethod
    def speak(self):
        pass


class Dog(Animal):

    def speak(self):
        print("Woof!")


class Cat(Animal):

    def speak(self):
        print("Meow!")


dog = Dog()
cat = Cat()

dog.speak()
cat.speak()

Woof!
Meow!

The parent class defines the required behavior, while the child classes provide their implementations.

Multiple Abstract Methods

An abstract class can require multiple methods.

from abc import ABC, abstractmethod


class Shape(ABC):

    @abstractmethod
    def area(self):
        pass

    @abstractmethod
    def perimeter(self):
        pass

Any concrete child class must implement both methods.

class Rectangle(Shape):

    def __init__(self, width, height):
        self.width = width
        self.height = height

    def area(self):
        return self.width * self.height

    def perimeter(self):
        return 2 * (self.width + self.height)


rectangle = Rectangle(10, 5)

print(rectangle.area())
print(rectangle.perimeter())

50
30

Abstract Properties

Abstract classes can also require child classes to provide properties.

from abc import ABC, abstractmethod


class Product(ABC):

    @property
    @abstractmethod
    def price(self):
        pass

A concrete child class must provide a compatible implementation of the price property.

class PhysicalProduct(Product):

    def __init__(self, price):
        self._price = price

    @property
    def price(self):
        return self._price


product = PhysicalProduct(2500)

print(product.price)

2500

Concrete Methods in Abstract Classes

An abstract class does not have to contain only abstract methods.

It can contain normal, fully implemented methods as well.

from abc import ABC, abstractmethod


class Payment(ABC):

    @abstractmethod
    def pay(self, amount):
        pass

    def receipt(self):
        print("Payment receipt generated.")


class CardPayment(Payment):

    def pay(self, amount):
        print(f"Paid ${amount} by card.")


payment = CardPayment()

payment.pay(1000)
payment.receipt()

Paid $1000 by card.
Payment receipt generated.

The child class must implement pay(), but it automatically inherits the concrete receipt() method.

Abstraction and Inheritance

Abstract classes are closely connected to inheritance.

The abstract parent establishes the rules or interface, while child classes provide concrete implementations.

Abstract Class
       ↓
 ┌─────┼─────┐
 ↓     ↓     ↓
Class Class Class
 A     B     C

For example:

Payment
   ↓
CreditCardPayment
BankTransfer
DigitalWallet

Each child follows the same general payment contract while implementing the details differently.

Abstraction and Polymorphism

Abstraction becomes especially powerful when combined with polymorphism.

from abc import ABC, abstractmethod


class Payment(ABC):

    @abstractmethod
    def pay(self, amount):
        pass


class CardPayment(Payment):

    def pay(self, amount):
        print(f"Card payment: ${amount}")


class BankTransfer(Payment):

    def pay(self, amount):
        print(f"Bank transfer: ${amount}")


class DigitalWallet(Payment):

    def pay(self, amount):
        print(f"Digital wallet: ${amount}")


payments = [
    CardPayment(),
    BankTransfer(),
    DigitalWallet()
]

for payment in payments:
    payment.pay(500)

Card payment: $500
Bank transfer: $500
Digital wallet: $500

The abstract class establishes the common interface:

pay(amount)

Polymorphism then allows each child class to implement that operation differently.

Real-World Applications

E-commerce Payments

A payment interface can require:

pay(amount)

Different providers can implement it differently.

Notification Services

An abstract notification class might require:

send(message)

Child classes could implement:

• Email notifications
• SMS notifications
• Push notifications

Data Export

A reporting application might define:

export(data)

Different classes could export the same data as:

• CSV
• JSON
• Excel
• PDF

Database Systems

A common database interface might define operations such as:

connect()
execute()
close()

Different database implementations can provide their own versions.

Benefits and Limitations

Benefits

• Reduces unnecessary complexity.
• Creates clear interfaces.
• Encourages consistent designs.
• Makes large applications easier to maintain.
• Supports polymorphism.
• Makes systems easier to extend.
• Separates interface from implementation.

Limitations

• Too much abstraction can make simple code unnecessarily complicated.
• Abstract interfaces need careful design.
• Beginners may find multiple layers difficult to follow.
• Not every small class requires an abstract base class.

Common Mistakes

1. Thinking Abstract Classes Are Normal Classes

An abstract class is designed to establish a contract or common structure for concrete implementations.

2. Forgetting to Import ABC

You normally need:

from abc import ABC, abstractmethod

3. Forgetting @abstractmethod

Simply creating a method named pay() does not make it abstract.

4. Not Implementing Required Methods

A concrete child class must implement all inherited abstract methods before it can normally be instantiated.

5. Making Everything Abstract

Not every method needs to be abstract. Shared behavior can often be implemented directly in the abstract base class.

6. Confusing Abstraction with Data Hiding

Abstraction hides unnecessary implementation complexity. Encapsulation focuses more directly on controlling access to internal state.

Practice Exercises

Try these exercises independently before attempting the mini challenge.

Mini Challenge — Payment Processing Framework

Requirements

1. Import ABC and abstractmethod.
2. Create an abstract class called Payment.
3. Add an abstract method called pay(amount).
4. Create CreditCardPayment.
5. Create BankTransfer.
6. Create DigitalWallet.
7. Implement pay() differently in each class.
8. Create a common function called process_payment().
9. Process all payment objects through the same function.

from abc import ABC, abstractmethod


class Payment(ABC):

    @abstractmethod
    def pay(self, amount):
        pass


class CreditCardPayment(Payment):

    def pay(self, amount):
        print(f"Credit card payment: ${amount}")


class BankTransfer(Payment):

    def pay(self, amount):
        print(f"Bank transfer payment: ${amount}")


class DigitalWallet(Payment):

    def pay(self, amount):
        print(f"Digital wallet payment: ${amount}")


def process_payment(payment, amount):
    payment.pay(amount)


payments = [
    CreditCardPayment(),
    BankTransfer(),
    DigitalWallet()
]


for payment in payments:
    process_payment(payment, 1000)

Credit card payment: $1000
Bank transfer payment: $1000
Digital wallet payment: $1000

Quick Knowledge Check

Test your understanding of abstraction.

Lesson Summary

Abstraction allows us to expose essential functionality while hiding unnecessary implementation details.