Python Tutorial



Python Tutorial

Data Abstraction in Python


Data abstraction in Python is a crucial aspect of object-oriented programming, acting as a beacon for developers to simplify complex architectures. This tutorial speaks about the nuances of this concept, exploring the symbiosis between abstract classes and efficient code. As we journey through, you'll uncover how abstraction not only streamlines development but also paves the way for a more intuitive and maintainable codebase. 


This tutorial delves deep into data abstraction in Python, unraveling its intricacies, and understanding its indispensable role within object-oriented programming. From the foundational abstract classes to the reasons that underscore their importance, we'll embark on a journey to grasp the essence of abstraction and how it contributes to scalable and maintainable code.

What are Abstraction Classes? 

In Python programming, abstract classes emerge as one of the paramount pillars, underpinning the architecture of object-oriented programming. Understanding these classes paves the way for better software design, ensuring robustness and scalability. They, in essence, serve as foundational structures, emphasizing more "what" an object does, rather than "how".

By laying down a blueprint for other classes, they facilitate a structure that other classes can build upon, ensuring a standard set of methods that must be implemented in the derived classes. This creates a scenario where the abstract class dictates a contract of sorts, and the inheriting classes fulfill this contract by implementing the methods. Some key components include:

  • They cannot be instantiated directly: One of the defining features of abstract classes is that you cannot create an instance of them directly. They are meant to be a base for other classes, not to be instantiated themselves.

  • Act as a foundation for other classes: Abstract classes provide a set template or a structure that other classes can build upon. By defining methods without implementing them, they lay out a blueprint for other classes to follow.

Why Abstraction is Important?

In the vast expanse of software engineering, abstraction stands as a cornerstone. Its strength lies in taming the complexities of code, shaping it into a form that’s both palatable and scalable. But, why exactly does abstraction hold such a pivotal position? Let's unravel this.

Abstraction is the art of discernment, it is about sieving through layers of complexity to present only what's needed. Think of it like an iceberg, where the visible tip signifies the presented features, while the submerged, larger portion represents the hidden complexities. Through abstraction, software developers provide a simplified view of the intricate mechanisms working beneath, shielding end-users and even other developers from the daunting intricacies.

Encapsulation vs. Abstraction

At the heart of object-oriented programming (OOP), two concepts often get mingled, encapsulation, and abstraction. Both abstraction and encapsulation in Python play pivotal roles, yet they have distinct purposes.

  • Encapsulation: As the guardian of data, encapsulation binds together data and the functions that manipulate this data, ensuring that unauthorized access is restricted. It acts as a protective wrapper, allowing data manipulation only through predefined methods.

  • Abstraction: While encapsulation safeguards, abstraction simplifies. Abstraction is about cherry-picking essential features to expose while keeping the nitty-gritty of implementation cloaked. It’s a mechanism to present only what's essential, ensuring the underlying complexities remain unseen and unfelt.

Benefits of Data Abstraction

Abstraction isn't just a theoretical construct; its real-world applications underscore its vitality in software design.

  • Simplifying Complexity: With abstraction, what could be a maze of intertwined code structures becomes a streamlined, user-friendly interface. It makes interacting with complex systems more intuitive, ensuring users don’t get bogged down with details they don't need.

  • Enhanced Maintainability: Abstraction acts as a buffer against changes. By encapsulating changes and exposing only a consistent interface, developers can make modifications to the underlying code without disrupting the user experience.

  • Boost in Flexibility: With abstraction, software becomes malleable. Developers have the leeway to make internal code modifications, optimize performances, or introduce new functionalities without affecting the user interface or necessitating changes in how users interact with the software.

Using Abstract Classes

Defining an Abstract Class

An abstract class is declared using the abstract keyword or a similar construct depending on the programming language (ABC in Python). Abstract classes cannot be instantiated on their own; they serve as a template for other classes

Abstract Methods

Abstract classes may contain abstract methods, which are methods declared without any implementation. Subclasses of the abstract class must provide concrete implementations for all the abstract methods. Abstract methods are used to define a common interface that subclasses must adhere to.


Concrete subclasses inherit from abstract classes to provide specific implementations for the abstract methods. The concrete subclasses are responsible for providing meaningful code for the abstract methods.

Enforcement of Interface

Abstract classes enforce a contract or interface that subclasses must follow.

Subclasses must provide concrete implementations for all abstract methods defined in the abstract class. If a subclass fails to implement any of the abstract methods, it is considered abstract and cannot be instantiated.


Abstract classes enable polymorphism, which allows objects of different concrete subclasses to be treated uniformly through the common interface defined by the abstract class.

This simplifies code by allowing you to work with objects of different types without needing to know their specific implementations.

Code Reusability

Abstract classes promote code reusability by providing a common structure for subclasses to build upon. Shared functionality and attributes can be defined in the abstract class, reducing redundancy in code.

Use Cases

Abstract classes are commonly used in scenarios where you want to define a set of methods that must be implemented by related classes. For example, in geometric shapes, you might have an abstract class "Shape" with abstract methods like "area" and "perimeter," and concrete subclasses like "Circle" and "Rectangle" that implement these methods.

Here is an example of abstract classes in Python:


from abc import ABC, abstractmethod
class AbstractClass(ABC):
    def abstract_method(self):
class ConcreteClass(AbstractClass):
    def abstract_method(self):
        print("ConcreteClass's implementation of abstract_method")
obj = ConcreteClass()

In the above example, AbstractClass is an abstract class with an abstract method abstract_method. ConcreteClass inherits from AbstractClass and provides a concrete implementation of abstract_method. An instance of ConcreteClass can be created and used.

Abstract Base Classes in Python

Abstract Base Classes (ABCs) in Python are a way to define a blueprint for a class, specifying a set of methods that must be implemented by any concrete (derived) class. They are part of the abc module in Python's standard library and provide a way to enforce a common interface among a group of related classes.

Here's how they work:

1. Importing the abc Module

To use abstract base classes, you need to import the abc module:

from abc import ABC, abstractmethod

2. Creating an Abstract Base Class:

To define an abstract base class, you inherit from the ABC class provided by the abc module. Additionally, you can use the @abstractmethod decorator to indicate which methods must be implemented by concrete subclasses. Here's an example:

from abc import ABC, abstractmethod
class Shape(ABC): 
    def area(self):
    def perimeter(self):

In this example, the Shape class is an abstract base class with two abstract methods: area() and perimeter(). Any concrete subclass of Shape must implement these methods.

3. Creating Concrete Subclasses:

Concrete subclasses are classes that inherit from an abstract base class and provide implementations for its abstract methods. For example:

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

Here, Circle is a concrete subclass of the Shape abstract base class. It implements the area() and perimeter() methods, which are required by the Shape base class.

4. Using Polymorphism

With abstract base classes, you can use polymorphism to work with objects of different concrete subclasses through a common interface. For example:

def print_shape_info(shape):
    print(f"Area: {shape.area()}")
    print(f"Perimeter: {shape.perimeter()}")
circle = Circle(5)

The print_shape_info() function can accept any object that is a subclass of Shape, allowing you to work with different shapes without knowing their specific types.

5. Enforcing Interface Compliance

If a concrete subclass of an abstract base class doesn't implement all the required abstract methods, Python will raise a TypeError at runtime, indicating that the subclass is not "concrete" and must implement all abstract methods.

Here is another working abstract class in python example where we'll create an abstract base class representing a data storage interface and then create concrete subclasses for different types of data storage, such as a database and a file system:


from abc import ABC, abstractmethod
# Abstract base class for data storage
class DataStorage(ABC):
    def read(self, key):
    def write(self, key, value):
# Concrete subclass for database storage
class DatabaseStorage(DataStorage):
    def __init__(self):
        # Simulate a database connection
        self.database = {}
    def read(self, key):
        if key in self.database:
            return self.database[key]
            return None
    def write(self, key, value):
        self.database[key] = value
        print(f"Writing to the database: {key} -> {value}")
# Concrete subclass for file system storage
class FileSystemStorage(DataStorage):
    def __init__(self):
        # Simulate a file system
        self.files = {}
    def read(self, key):
        if key in self.files:
            return self.files[key]
            return None
    def write(self, key, value):
        self.files[key] = value
        print(f"Writing to the file system: {key} -> {value}")
# Client code
if __name__ == "__main__":
    # Create instances of data storage types
    db_storage = DatabaseStorage()
    fs_storage = FileSystemStorage()
    # Perform data storage operations
    db_storage.write("user123", "Alice")
    fs_storage.write("order456", "Product: XYZ")
    # Read data
    user_data ="user123")
    order_data ="order456")
    # Display retrieved data
    print("User data:", user_data)
    print("Order data:", order_data)

In the above example, DataStorage is the abstract base class representing a data storage interface. It defines two abstract methods, read and write, which must be implemented by its concrete subclasses. DatabaseStorage and FileSystemStorage are concrete subclasses of DataStorage. They provide specific implementations of the read and write methods for database and file system storage, respectively.

In the client code, we create instances of DatabaseStorage and FileSystemStorage, perform data storage operations, and then read and display the retrieved data.

The use of the abc module ensures that all concrete subclasses adhere to the common interface defined by the DataStorage abstract base class, achieving data abstraction and allowing us to work with different types of data storage using a consistent API.


Mastering data abstraction in Python provides a developer with the tools to craft organized, efficient, and scalable code. As we journey through Python's vast landscapes, the role of concepts like these becomes undeniable. For professionals who seek to further upskill, upGrad offers an array of courses tailored for excellence.


1. What is encapsulation in Python?

It's a mechanism of wrapping data (variables) and code (methods) together as a single unit.

2. How is abstraction different from polymorphism in Python?

Abstraction hides complexity, while polymorphism lets a single interface represent different data types.

3. Are there distinct types of abstraction in Python?

Two primary types exist: data abstraction and control abstraction.

4. Can an abstract class in Python contain regular methods?

An abstract class can mix abstract and concrete methods.

5. What's the core role of an abstract method in Python?

It sets a framework for derived classes, mandating a specific implementation for the method.

Leave a Reply

Your email address will not be published. Required fields are marked *