Python Abstraction Exercises

In Python, what is the primary purpose of an Abstract Base Class (ABC)?

To create a class that can be used to store global variables for the entire program.

To define a common blueprint for other classes, ensuring they implement specific methods without allowing the blueprint itself to be instantiated.

To increase the execution speed of the program by pre-compiling method names.

To allow a class to inherit from multiple parent classes simultaneously.

Abstraction is about defining a "contract". Think of an Abstract Base Class as a set of rules that other classes must follow.

Key Characteristics:

Blueprint Only: You cannot create an object (instance) directly from an abstract class. It exists only to be inherited.
Enforcement: It forces any child class to provide its own specific version of the abstract methods.

Tip: Imagine a "Shape" class. You can't draw a "Shape," but you can draw a "Circle" or a "Square." The "Shape" is the abstract idea; the others are concrete implementations.

To create an abstract class in Python, you must import the `ABC` class and the `abstractmethod` decorator. Complete the code below:

from abc import ________, abstractmethod

class Animal(________):
    @abstractmethod
    def move(self):
        pass

Base, Base

Meta, Meta

Template, Template

ABC, ABC

In Python, we use the abc module (which stands for Abstract Base Classes).

The standard setup:

Import ABC (the base class) and abstractmethod (the decorator).
Inherit from ABC.
Mark methods with @abstractmethod to tell Python: "This method must be overridden in the subclass."

from abc import ABC, abstractmethod

class Animal(ABC):
    # This class cannot be instantiated now!

What will happen if you try to run the following code?

from abc import ABC, abstractmethod

class Vehicle(ABC):
    @abstractmethod
    def start_engine(self):
        pass

v = Vehicle()

It raises a TypeError because you cannot instantiate an abstract class with abstract methods.

It prints None because the method has no body.

It creates an object v successfully, but calling v.start_engine() will fail.

It raises an AttributeError because ABC is not a valid parent.

Python strictly enforces the rule that Abstract Base Classes cannot be turned into objects.

The logic:

Because the start_engine method is marked as @abstractmethod, it is considered "incomplete." Python prevents you from creating a Vehicle object because it wouldn't know what to do if you tried to call a method that has no implementation.

# Error message:
# TypeError: Can't instantiate abstract class Vehicle with abstract method start_engine

You are designing a data processing library. You want to ensure that every "DataWriter" (like `CSVWriter` or `JSONWriter`) has a method called `save_data()`. Which approach best utilizes Abstraction?

Write a regular class DataWriter and tell developers to remember to add a save_data method.

Create an abstract class DataWriter with an @abstractmethod called save_data().

Inherit all writers from a standard list object.

Abstraction is perfect for API Design in team environments or libraries.

Why Option 3 is the best:

Consistency: It guarantees that any developer creating a new writer must include the save_data() method, or their code won't even run.
Predictability: Other parts of your program can safely call writer.save_data() without worrying about what specific type of writer they are using.

This is often called Coding to an Interface rather than coding to a specific implementation.

Which of the following is true regarding methods in a Python Abstract Base Class?

An abstract class can ONLY contain abstract methods.

Abstract methods must be defined using the lambda keyword.

Abstract methods are private by default and cannot be accessed by subclasses.

An abstract class can contain both abstract methods and regular "concrete" methods (with code).

A common misconception is that Abstract Base Classes (ABCs) are purely empty. That's not true in Python!

Mixing Methods:

Abstract Methods: Methods that have no body (using pass) and must be overridden.
Concrete Methods: Regular methods with logic that can be shared by all subclasses.

Example: An abstract Bird class might have an abstract fly() method, but a concrete sleep() method, since all birds sleep the same way.

Analyze the following code. Why will it result in an error when trying to create an instance of `Smartphone`?

from abc import ABC, abstractmethod

class Device(ABC):
    @abstractmethod
    def power_on(self):
        pass

    @abstractmethod
    def get_battery_level(self):
        pass

class Smartphone(Device):
    def power_on(self):
        print("Screen lighting up...")

Because Device is not passed into the Smartphone constructor.

Because Smartphone needs to call super().power_on().

Because Smartphone failed to implement the abstract method get_battery_level.

Because abstract methods cannot be used in classes that have a print statement.

This exercise highlights the strict enforcement of Abstraction in Python.

The "All or Nothing" Rule:

When a subclass inherits from an Abstract Base Class (ABC), it acts as a legal contract. If the parent class defines two abstract methods, the child class must implement both.

In this case, Smartphone implemented power_on, but it completely ignored get_battery_level.
As long as even one abstract method remains "unimplemented," Python treats the subclass as abstract as well.

Resulting Error: TypeError: Can't instantiate abstract class Smartphone with abstract method get_battery_level

Can an abstract method in Python contain actual code logic, or must it only contain the `pass` keyword?

It can contain logic, and subclasses can use super() to access that shared logic while still being forced to override it.

It must only contain pass; any other code will raise a SyntaxError.

It can contain logic, but that logic is automatically deleted when a subclass is created.

It can only contain a return statement, never operational logic.

This is a "hidden" feature of Python's abc module that many beginners miss.

Abstract Methods with Bodies:

Even if a method is decorated with @abstractmethod, you can still write code inside it. This is useful when all subclasses share a common "base" behavior, but you still want to force them to acknowledge and extend that behavior.

class Base(ABC):
    @abstractmethod
    def greet(self):
        print("Hello from the Base!")

class Child(Base):
    def greet(self):
        super().greet()  # This works!
        print("Hello from the Child!")

Key Takeaway: The @abstractmethod decorator doesn't stop the method from having code; it only stops the class from being instantiated until the method is overridden.

You are creating a game where different types of enemies (`Orc`, `Dragon`) must have a `take_damage` method. However, you want to provide a common `shout()` method that all enemies use the same way. Which structure is correct?

class Enemy:
    def shout(self):
        print("Grrr!")
    def take_damage(self):
        pass

from abc import ABC, abstractmethod
class Enemy(ABC):
    @abstractmethod
    def shout(self):
        print("Grrr!")

from abc import ABC, abstractmethod
class Enemy(ABC):
    @abstractmethod
    def take_damage(self):
        pass
    @abstractmethod
    def shout(self):
        pass

from abc import ABC, abstractmethod
class Enemy(ABC):
    def shout(self):
        print("Grrr!")
    @abstractmethod
    def take_damage(self):
        pass

In real-world development, Abstract Base Classes are often Hybrid Classes.

Analysis:

shout(): Since every enemy does this exactly the same way, we define it as a Concrete Method (no decorator). Subclasses inherit this automatically.
take_damage(): Since an Orc might handle damage differently than a Dragon, we define this as an Abstract Method. This forces the subclass to define the specific logic.

Design Tip: Use abstract methods for "what" must be done (the interface) and concrete methods for "how" it's done (the shared logic).

A bank has a base class Account. It wants to ensure that every specific account type (Savings, Checking) calculates interest, but the formula for interest is strictly unique to each type. If the bank also wants to prevent anyone from creating a generic Account object, what should they do?

Make calculate_interest a private method using __.

Make Account an abstract class and calculate_interest an abstract method.

Use a global dictionary to store the interest formulas instead of a class.

Define calculate_interest in the constructor of Account.

This scenario describes the classic use-case for Abstraction.

Two Problems, One Solution:

Prevent generic instantiation: Making Account inherit from ABC ensures no one can create a "blank" account.
Enforce unique formulas: Making calculate_interest abstract ensures that SavingsAccount doesn't forget to define its specific interest logic.

This prevents bugs where a developer might create an account that accidentally uses a default (and potentially incorrect) interest rate.

Which of the following describes the relationship between a Subclass and its Abstract Parent?

The Subclass must be defined inside the same file as the Parent.

The Subclass must implement all methods marked as abstract in the Parent to become a concrete class.

The Subclass cannot have any methods of its own; it can only use what is in the Parent.

The Subclass is automatically abstract if it inherits from ABC, regardless of its methods.

Think of the relationship as a Job Interview.

The Implementation Requirement:

The Abstract Parent says: "To work here, you must know how to type() and speak()."
The Subclass says: "I know how to type() and speak(), and here is how I do them specifically."
If the Subclass fails to provide even one of those skills, it remains "unqualified" (abstract) and cannot be used to create objects.

How do you define a required property in an abstract class so that every subclass is forced to implement it as a managed attribute (getter)?

class Base(ABC):
    @property
    @abstractmethod
    def internal_id(self):
        pass

class Base(ABC):
    internal_id = abstractmethod(property)

class Base(ABC):
    def __init__(self):
        self.internal_id = abstractmethod

class Base(ABC):
    @abstractmethod
    def get_internal_id(self):
        return property()

In Python, decorators can be stacked to create sophisticated constraints.

Stacking Decorators:

When you combine @property and @abstractmethod, you are creating a "Contract for Data."

The @abstractmethod ensures that the subclass must define this method.
The @property ensures that the subclass must treat it as an attribute (using the property syntax) rather than a regular method call.

If a subclass fails to implement this as a property, Python will raise a TypeError when you try to instantiate the subclass.

What is the result of running the following code? This code demonstrates a "Template Method Pattern" where a concrete method depends on an abstract one.

from abc import ABC, abstractmethod

class Document(ABC):
    def export(self):
        # Concrete method calling an abstract one
        data = self.get_contents()
        return f"Document Data: {data}"

    @abstractmethod
    def get_contents(self):
        pass

class PDF(Document):
    def get_contents(self):
        return "PDF binary stream"

doc = PDF()
print(doc.export())

It raises a NameError because get_contents is not defined inside export.

It prints Document Data: None.

It prints Document Data: PDF binary stream.

It raises a TypeError because concrete methods cannot call abstract methods.

This is a powerful design pattern called the Template Method Pattern.

How it works:

The Abstract Base Class (Document) defines the overall structure of a process in a concrete method (export).
The concrete method relies on a "placeholder" (the abstract get_contents).
The Subclass fills in the specific details by implementing the abstract method.

When doc.export() is called, Python uses the get_contents implementation from the PDF class. This allows you to define the "skeleton" of an algorithm in the parent class while letting subclasses define the specific steps.

A developer is trying to implement a specialized `FileParser`. Why does the following code fail?

from abc import ABC, abstractmethod

class Parser(ABC):
    @abstractmethod
    def parse(self, data):
        pass

class WebParser(Parser):
    def parse(self):
        return "Parsing web data..."

wp = WebParser()

WebParser is missing the ABC inheritance.

WebParser changed the method signature (removed the data parameter), but technically in Python, this still counts as an implementation, and the error will actually only occur when the method is called with an argument. However, Python still allows the instantiation. Wait, check the logic carefully:

Abstract methods cannot be named parse.

The decorator abc.abstractmethod is missing the parentheses.

This is a tricky debugging case regarding how Python's abc module validates "implementation."

The Nuance of Implementation:

Technically, Python's ABC only checks if a method name exists in the subclass. It does not strictly enforce that the parameter signature (the arguments) matches exactly at the time of instantiation.

Because WebParser has a method named parse, Python considers the abstract contract "fulfilled."
The object wp will be created successfully.
The Trap: The error will only happen later when you try to use it correctly (e.g., wp.parse(some_data)), which will raise a TypeError because the subclass version doesn't accept any arguments.

Key Takeaway: Abstraction in Python guarantees the existence of a method, but the developer is responsible for ensuring the signature (parameters) matches the intended design.

You need to ensure that every subclass of `User` has a `username` property that can be both read and written. Which implementation correctly sets this requirement in the Abstract Base Class?

class User(ABC):
    @abstractmethod
    def username(self): pass

class User(ABC):
    username = abstractmethod(property)

class User(ABC):
    @property
    @abstractmethod
    def username(self): pass
    
    @username.setter
    def username(self, val): pass

class User(ABC):
    @property
    @abstractmethod
    def username(self): pass

    @abstractmethod
    @username.setter
    def username(self, val): pass

To enforce both a Getter and a Setter in an abstract class, both must be explicitly marked as abstract.

Why Option 4?

The first block defines the Getter as abstract.
The second block defines the Setter as abstract.
If a subclass only implements the getter, Python will still consider the class "abstract" and prevent instantiation because the setter requirement hasn't been met.

When using Abstraction for a large-scale plugin system, why might you use a "Concrete Method" in an ABC that raises a `NotImplementedError` instead of using the `@abstractmethod` decorator?

Raising NotImplementedError is faster for the Python interpreter to process.

It allows the class to be instantiated even if the method isn't overridden.

It is used when you want the method to be "optional" for some subclasses but still want to provide a warning if it's called without being defined.

It prevents subclasses from using the super() keyword.

There is a subtle difference between "Hard Abstraction" and "Soft Abstraction."

Comparison:

@abstractmethod: Hard enforcement. The program will not run (instantiate) until you implement the method.
NotImplementedError: Soft enforcement. The program will run and you can create objects. The error only happens at runtime if that specific method is called.

This is often used in plugin architectures where a subclass might only need to implement 2 out of 10 possible features. If they call a feature they didn't implement, the NotImplementedError acts as a clear signal of what's missing.

What is the internal mechanism that Python uses to prevent the instantiation of a class that has unimplemented abstract methods?

The __init__ method of the ABC class checks for decorators and raises an error if found.

A background thread scans the code during execution and stops the script if an abstract class is used.

The @abstractmethod decorator replaces the method with a raise TypeError statement.

The ABCMeta metaclass calculates a set of unimplemented abstract methods (__abstractmethods__) and blocks __call__ if that set is not empty.

To understand this, we have to look at Metaclasses—the "classes of classes."

How ABCMeta works:

When you inherit from ABC, you are actually using ABCMeta as your metaclass.
During class creation, ABCMeta looks for any methods decorated with @abstractmethod and adds their names to a special internal attribute called __abstractmethods__.
When you try to create an object (e.g., obj = MyClass()), Python's internal object.__new__ checks if __abstractmethods__ is empty. If it's not, it raises the TypeError.

Deep Dive: This is why simply adding @abstractmethod to a regular class without inheriting from ABC does nothing—the metaclass isn't there to enforce the rule!

Consider the following code using the `.register()` method. What will be the output of the `isinstance` and `issubclass` checks?

from abc import ABC

class Plugin(ABC):
    pass

class MyPlugin:
    pass

Plugin.register(MyPlugin)

obj = MyPlugin()
print(isinstance(obj, Plugin), issubclass(MyPlugin, Plugin))

False False

True True

True False

False True

This demonstrates the concept of Virtual Subclasses.

What happened here?

By using Plugin.register(MyPlugin), you are telling Python: "Even though MyPlugin doesn't inherit from Plugin, treat it as if it does."

isinstance: Returns True because MyPlugin is registered as a virtual child.
issubclass: Returns True for the same reason.
The Catch: Virtual subclasses do not inherit any methods from the ABC, nor does Python enforce abstract method implementation on them.

This is useful for Duck Typing where you want a class to belong to a category without forcing it to change its inheritance tree.

What is the result of the following code where an abstract method is called via `super()`?

from abc import ABC, abstractmethod

class Base(ABC):
    @abstractmethod
    def action(self):
        return "Base Action"

class Child(Base):
    def action(self):
        msg = super().action()
        return f"{msg} -> Child Action"

c = Child()
print(c.action())

Base Action -> Child Action

TypeError: Cannot call abstract method via super()

None -> Child Action

AttributeError: 'super' object has no attribute 'action'

This confirms that @abstractmethod does not make a method uncallable.

Why this works:

The decorator @abstractmethod only serves one primary purpose: to block instantiation of a class until the method is overridden.
The code inside the abstract method is still valid Python code stored in memory.
Subclasses are perfectly allowed (and sometimes encouraged) to use super().method_name() to reuse that logic.

This is common when the Abstract Parent defines a default behavior that every child must perform before adding their own specific logic.

In a multi-layer hierarchy, if `Class A` is an ABC with an abstract method, and `Class B` inherits from `A` but does not implement that method, and finally `Class C` inherits from `B` and does implement the method, which of the following is true?

Only Class A is abstract; B can be instantiated because it doesn't have the @abstractmethod decorator itself.

Class C will raise a TypeError because its parent (B) is invalid.

Both A and B are considered abstract and cannot be instantiated.

The abstract requirement is lost once B inherits from A.

Abstraction is transitive.

The Chain of Responsibility:

If A defines a rule, that rule follows the inheritance line until it is satisfied.
Because B inherited from A but didn't provide an implementation, B effectively "inherits" the abstract status.
Python will block the creation of any B objects.

Once C finally provides the code for that method, the "abstract" flag is cleared for C (and any classes that inherit from C).

If an abstract class defines an abstract method, can a subclass satisfy that requirement by implementing a property with the same name?

class Base(ABC):
    @abstractmethod
    def data(self):
        pass

class Child(Base):
    @property
    def data(self):
        return "Internal Data"

Yes, a property is a valid implementation of an abstract method with the same name.

No, it must be a regular method or Python will raise a TypeError.

Yes, but only if the property has a setter defined as well.

No, properties and abstract methods are incompatible in the same hierarchy.

This is a high-level Pythonic flexibility feature.

Interface Satisfaction:

When Python checks if the abstract contract is met, it looks to see if the attribute name (data) exists in the subclass and is not marked as abstract.

A @property is essentially a method that is accessed like an attribute.
Because the subclass has a concrete (non-abstract) implementation named data, the requirement is satisfied.

Practical Application: This allows you to define a "getter" interface in a parent class and decide later in the child class whether it should be a simple method or a managed property.

Benefit	Explanation
Simplified Interface	Users interact with high-level methods rather than navigating through low-level logic.
Code Blueprinting	Ensures that all subclasses follow a specific structure or "contract."
Enhanced Security	Only relevant information is exposed, hiding sensitive internal data processing.
Reduced Complexity	Large systems become manageable by breaking them into smaller, abstract units.

Component	Description
Abstract Base Class (ABC)	A class derived from `ABC` that serves as a template.
Abstract Method	A method marked with `@abstractmethod` that has no code.
Concrete Class	A normal class that provides the actual code for the abstract methods.

Python Abstraction Practice Questions

In Python, what is the primary purpose of an Abstract Base Class (ABC)?

Key Characteristics:

To create an abstract class in Python, you must import the ABC class and the abstractmethod decorator. Complete the code below:

The standard setup:

What will happen if you try to run the following code?

The logic:

You are designing a data processing library. You want to ensure that every "DataWriter" (like CSVWriter or JSONWriter) has a method called save_data(). Which approach best utilizes Abstraction?

Why Option 3 is the best:

Which of the following is true regarding methods in a Python Abstract Base Class?

Mixing Methods:

Analyze the following code. Why will it result in an error when trying to create an instance of Smartphone?

The "All or Nothing" Rule:

Can an abstract method in Python contain actual code logic, or must it only contain the pass keyword?

Abstract Methods with Bodies:

You are creating a game where different types of enemies (Orc, Dragon) must have a take_damage method. However, you want to provide a common shout() method that all enemies use the same way. Which structure is correct?

Analysis:

Two Problems, One Solution:

Which of the following describes the relationship between a Subclass and its Abstract Parent?

The Implementation Requirement:

How do you define a required property in an abstract class so that every subclass is forced to implement it as a managed attribute (getter)?

Stacking Decorators:

What is the result of running the following code? This code demonstrates a "Template Method Pattern" where a concrete method depends on an abstract one.

How it works:

A developer is trying to implement a specialized FileParser. Why does the following code fail?

The Nuance of Implementation:

You need to ensure that every subclass of User has a username property that can be both read and written. Which implementation correctly sets this requirement in the Abstract Base Class?

Why Option 4?

When using Abstraction for a large-scale plugin system, why might you use a "Concrete Method" in an ABC that raises a NotImplementedError instead of using the @abstractmethod decorator?

Comparison:

What is the internal mechanism that Python uses to prevent the instantiation of a class that has unimplemented abstract methods?

How ABCMeta works:

Consider the following code using the .register() method. What will be the output of the isinstance and issubclass checks?

What happened here?

What is the result of the following code where an abstract method is called via super()?

Why this works:

In a multi-layer hierarchy, if Class A is an ABC with an abstract method, and Class B inherits from A but does not implement that method, and finally Class C inherits from B and does implement the method, which of the following is true?

The Chain of Responsibility:

If an abstract class defines an abstract method, can a subclass satisfy that requirement by implementing a property with the same name?

Interface Satisfaction:

Quick Recap of Python Abstraction Concepts

Python Abstraction — Definition, Types, and Usage

Why Use Abstraction — Key Benefits

The ABC Module in Python

Implementing Abstraction Components

Best Practices With Python Abstraction

Summary: Key Points About Abstraction

Test Your Python Abstraction Knowledge

About This Exercise: Python – Abstraction

What You Will Learn

Why This Topic Matters

Start Practicing

Need a Quick Refresher?