example abstract class python

Python Basics
Interview Questions
Python Quiz
Popular Packages
Python Projects
Practice Python
AI With Python
Learn Python3
Python Automation
Python Web Dev
DSA with Python
Python OOPs
Dictionaries

Abstract Classes in Python

Abstract Base Class (abc) in Python
Data Abstraction in Python
C# | Abstract Classes
Python MetaClasses
classmethod() in Python
Constructors in Python
Built-In Class Attributes In Python
Python Classes and Objects
Python - Access Parent Class Attribute
Copy Constructor in Python
Private Attributes in a Python Class
self in Python class
Abstract Classes in PHP
Abstract Classes in Scala
Abstract Classes in Dart
Abstract Class in Java
JS++ | Abstract Classes and Methods
Kotlin Abstract class
AbstractSet Class in Java with Examples

An abstract class can be considered a blueprint for other classes . It allows you to create a set of methods that must be created within any child classes built from the abstract class.

A class that contains one or more abstract methods is called an abstract class . An abstract method is a method that has a declaration but does not have an implementation.

We use an abstract class while we are designing large functional units or when we want to provide a common interface for different implementations of a component.

Abstract Base Classes in Python

By defining an abstract base class, you can define a common Application Program Interface(API) for a set of subclasses. This capability is especially useful in situations where a third party is going to provide implementations, such as with plugins, but can also help you when working in a large team or with a large code base where keeping all classes in your mind is difficult or not possible.

Working on Python Abstract classes

By default, Python does not provide abstract classes . Python comes with a module that provides the base for defining A bstract Base classes(ABC) and that module name is ABC .

ABC works by decorating methods of the base class as an abstract and then registering concrete classes as implementations of the abstract base. A method becomes abstract when decorated with the keyword @abstractmethod.

This code defines an abstract base class called “ Polygon ” using the ABC (Abstract Base Class) module in Python. The “Polygon” class has an abstract method called “ noofsides ” that needs to be implemented by its subclasses.

There are four subclasses of “Polygon” defined: “Triangle,” “Pentagon,” “Hexagon,” and “Quadrilateral.” Each of these subclasses overrides the “noofsides” method and provides its own implementation by printing the number of sides it has.

In the driver code, instances of each subclass are created, and the “noofsides” method is called on each instance to display the number of sides specific to that shape.

Example 2:

Here, This code defines an abstract base class called “Animal” using the ABC (Abstract Base Class) module in Python. The “Animal” class has a non-abstract method called “move” that does not have any implementation. There are four subclasses of “Animal” defined: “Human,” “Snake,” “Dog,” and “Lion.” Each of these subclasses overrides the “move” method and provides its own implementation by printing a specific movement characteristic.

Implementation of Abstract through Subclass

By subclassing directly from the base, we can avoid the need to register the class explicitly. In this case, the Python class management is used to recognize Plugin implementation as implementing the abstract PluginBase .

A side-effect of using direct subclassing is, it is possible to find all the implementations of your plugin by asking the base class for the list of known classes derived from it.

Concrete Methods in Abstract Base Classes

Concrete classes contain only concrete (normal) methods whereas abstract classes may contain both concrete methods and abstract methods.

The concrete class provides an implementation of abstract methods, the abstract base class can also provide an implementation by invoking the methods via super(). Let look over the example to invoke the method using super():

In the above program, we can invoke the methods in abstract classes by using super().

Abstract Properties in Python

Abstract classes include attributes in addition to methods, you can require the attributes in concrete classes by defining them with @abstractproperty.

In the above example, the Base class cannot be instantiated because it has only an abstract version of the property-getter method.

Abstract Class Instantiation

Abstract classes are incomplete because they have methods that have nobody. If Python allows creating an object for abstract classes then using that object if anyone calls the abstract method, but there is no actual implementation to invoke.

So, we use an abstract class as a template and according to the need, we extend it and build on it before we can use it. Due to the fact, an abstract class is not a concrete class, it cannot be instantiated. When we create an object for the abstract class it raises an error .

Please Login to comment...

Improve your Coding Skills with Practice

What kind of Experience do you want to share?

Home » Python OOP » Python Abstract Classes

Python Abstract Classes

Summary : in this tutorial, you’ll learn about Python Abstract classes and how to use it to create a blueprint for other classes.

Introduction to Python Abstract Classes

In object-oriented programming, an abstract class is a class that cannot be instantiated. However, you can create classes that inherit from an abstract class.

Typically, you use an abstract class to create a blueprint for other classes.

Similarly, an abstract method is an method without an implementation. An abstract class may or may not include abstract methods.

Python doesn’t directly support abstract classes. But it does offer a module that allows you to define abstract classes.

To define an abstract class, you use the abc (abstract base class) module.

The abc module provides you with the infrastructure for defining abstract base classes.

For example:

To define an abstract method, you use the @abstractmethod decorator:

Python abstract class example

Suppose that you need to develop a payroll program for a company.

The company has two groups of employees: full-time employees and hourly employees. The full-time employees get a fixed salary while the hourly employees get paid by hourly wages for their services.

The payroll program needs to print out a payroll that includes employee names and their monthly salaries.

To model the payroll program in an object-oriented way, you may come up with the following classes: Employee , FulltimeEmployee , HourlyEmployee , and Payroll .

To structure the program, we’ll use modules , where each class is placed in a separate module (or file).

The Employee class

The Employee class represents an employee, either full-time or hourly. The Employee class should be an abstract class because there’re only full-time employees and hourly employees, no general employees exist.

The Employee class should have a property that returns the full name of an employee. In addition, it should have a method that calculates salary. The method for calculating salary should be an abstract method.

The following defines the Employee abstract class:

The FulltimeEmployee class

The FulltimeEmployee class inherits from the Employee class. It’ll provide the implementation for the get_salary() method.

Since full-time employees get fixed salaries, you can initialize the salary in the constructor of the class.

The following illustrates the FulltimeEmployee class:

The HourlyEmployee class

The HourlyEmployee also inherits from the Employee class. However, hourly employees get paid by working hours and their rates. Therefore, you can initialize this information in the constructor of the class.

To calculate the salary for the hourly employees, you multiply the working hours and rates.

The following shows the HourlyEmployee class:

The Payroll class

The Payroll class will have a method that adds an employee to the employee list and print out the payroll.

Since fulltime and hourly employees share the same interfaces ( full_time property and get_salary() method). Therefore, the Payroll class doesn’t need to distinguish them.

The following shows the Payroll class:

The main program

The following app.py uses the FulltimeEmployee , HourlyEmployee , and Payroll classes to print out the payroll of five employees.

When to use abstract classes

In practice, you use abstract classes to share the code among several closely related classes. In the payroll program, all subclasses of the Employee class share the same full_name property.

Abstract classes are classes that you cannot create instances from.
Use abc module to define abstract classes.

CodeFatherTech

Learn to Code. Shape Your Future

Create an Abstract Class in Python: A Step-By-Step Guide

Knowing how to create an abstract class in Python is a must-know for Python developers. In this guide, you will learn how to define and use abstract classes.

But first of all, what is an abstract class?

An Abstract class is a template that enforces a common interface and forces classes that inherit from it to implement a set of methods and properties. The Python abc module provides the functionalities to define and use abstract classes.

Abstract classes give us a standard way of developing our code even if you have multiple developers working on a project.

Let’s find out how to use them in your programs!

A Simple Example of Abstract Class in Python

Abstract Classes come from PEP 3119 . PEP stands for Python Enhancement Proposal and it’s a type of design document used to explain new features to the Python community.

Before starting, I want to mention that in this tutorial I will use the following version of Python 3:

The reason why I’m highlighting this is that the way you define abstract classes can change depending on the version of Python you use. This applies, for example, to Python 2 but also to earlier versions of Python 3 (lower than 3.4).

Firstly, let’s start by defining a simple class called Aircraft:

I can create an instance of this class and call the fly method on it without any errors:

Now, let’s say I want to convert this class into an abstract class because I want to use it as common interface for classes that represent different types of aircraft.

Here is how we can do it…

Import ABC and abstractmethod from the Python abc module .
Derive our Aircraft class from ABC .
Add the @abstractmethod decorator to the fly method.

You can make a method abstract in Python by adding the @abstractmethod decorator to it.

Now, when we create an instance of Aircraft we see the following error:

As you can see I’m not able to create an instance of our abstract class.

An Abstract class is a class that contains one or more abstract methods. Abstract classes cannot be instantiated.

This means that we cannot create an object from an abstract class…

So, how can we use them?

Abstract classes can only be used via inheritance and their concrete child classes have to provide an implementation for all the abstract methods.

In the next section, you will see what I mean with concrete.

Python Abstract Class Inheritance

Let’s see what happens if instead of instantiating our abstract class we create a child class that derives from it.

Let’s try to create an instance of Jet:

Hmmm…a similar error to the one we have seen before with the difference that now it refers to the Jet class.

That’s because to be able to create an object of type Jet we have to provide an implementation for the abstract method fly() in this class.

Let’s give it a try:

This time I can create an instance of type Jet and execute the fly method:

A class that inherits an abstract class and implements all its abstract methods is called a concrete class . In a concrete class, all the methods have an implementation while in an abstract class some or all the methods are abstract.

Now I will add another abstract method called land() to our Aircraft abstract class and then try to create an instance of Jet again:

Here’s what happens when I create an instance of the class Jet whose implementation hasn’t changed:

The cause of the error is that we haven’t provided a concrete implementation for the land method in the Jet subclass. This demonstrates that to instantiate a class that derives from an abstract class we have to provide an implementation for all the abstract methods inherited from the parent abstract class.

A child class of an abstract class can be instantiated only if it overrides all the abstract methods in the parent class.

The term override in Python inheritance indicates that a child class implements a method with the same name as a method implemented in its parent class. This is a basic concept in object-oriented programming.

Makes sense?

So, let’s implement the land() method in the Jet class:

I will run both methods in the Jet class to make sure everything works as expected:

Using Super to Call a Method From an Abstract Class

An abstract method in Python doesn’t necessarily have to be completely empty.

It can contain implementations that can be reused by child classes by calling the abstract method with super(). This doesn’t exclude the fact that child classes still have to implement the abstract method.

Here is an example…

We will make the following changes:

Add a print statement to the land method of the Aircraft abstract class.
Call the land method of the abstract class from the Jet child class before printing the message “My jet has landed”.

Here is the output:

From the output you can see that the jet1 instance of the concrete class Jet calls the land method of the abstract class first using super() and then prints its own message.

This can be handy to avoid repeating the same code in all the child classes of our abstract class.

How to Implement an Abstract Property in Python

In the same way we have defined abstract methods, we can also define abstract properties in our abstract class.

Let’s add an attribute called speed to our abstract base class Aircraft and also property methods to read and modify its value.

A way in Python to define property methods to read and modify the value of speed would be the following:

The method with the @property decorator is used to get the value of speed (getter). The method with the @speed.setter decorator allows to update the value of speed (setter).

In this case, we want these two methods to be abstract to enforce their implementation in every subclass of Aircraft. Also, considering that they are abstract we don’t want to have any implementation for them…

…we will use the pass statement.

We are also adding an abstract constructor that can be called by its subclasses.

To be fair I’m tempted to remove this constructor considering that an abstract class is not supposed to be instantiated.

At the same time, the constructor can work as guidance for the subclasses that will have to implement it. I will keep it for now.

So, the Aircraft class looks like this:

As you can see, I have added the @abstractmethod decorator to the property methods.

Note : it’s important to specify the @abstractmethod decorator after the @property and @speed.setter decorators. If I don’t do that I get the following error:

Let’s also override the constructor in the Jet class:

I’m curious to see what happens if we try to create an instance of the Jet class after adding the abstract property methods to its parent abstract class.

Notice that I’m passing the speed when I create an instance of Jet considering that we have just added a constructor to it that takes the speed as an argument:

The error message tells us that we need to implement the property methods in the concrete class Jet if we want to instantiate it.

Let’s do it!

Here is the output when we use the concrete property methods in the Jet class to read and update the value of the speed:

The code works fine!

Python also provides a decorator called @abstractproperty . Do we need it?

According to the official Python documentation this decorator is deprecated since version 3.3 and you can stick to what we have seen so far.

How to Define Abstract Classes in Earlier Versions of Python

In this tutorial, we have focused on Python 3.4 or above when it comes to defining abstract classes. At the same time, I want to show you how you can define an abstract class with Python 3.0+ and with Python 2.

I will also include Python 3.4+ in the examples so you can quickly compare it with the other two ways of defining an abstract class.

Firstly, let’s recap the implementation we have used in this tutorial using Python 3.4 +.

To make things simple I will show the:

Imports from the Python abc module .
Abstract Class definition.
Definition of the abstract method fly().

Here is the same code for Python 3.0+ :

ABCMeta is a metaclass that allows to define abstract base classes. A metaclass is a class that allows to create other classes.

I’m curious to know more about this metaclass. Let’s look at its MRO (Method Resolution Order):

As you can see it derives from “type”.

And now let’s move to Python 2 . I’m using version 2.7.14:

This should help you define your abstract classes with different versions of Python!

Raising a NotImplementedError Instead of Using the abstractmethod Decorator

Before completing this tutorial I want to show you an approach that you can use to obtain a similar behavior in an abstract class that the abstractmethod decorator provides.

Let’s take a subset of our Aircraft abstract class and remove the @abstractmethod decorator from the fly() method:

In the way our code looks like right now we can create an instance of our abstract class. When I execute the following I don’t see any errors:

Obviously, this is not what we want considering that an abstract class is not done to be instantiated.

What could we do to prevent the creation of objects of type Aircraft?

We could implement a constructor that raises an exception when it’s invoked.

Let’s try to create an instance now:

It didn’t allow me to create an instance. That’s good!

Obviously, the most correct option is to use the @abstractmethod decorator. With this example, we just want to learn to come up with different approaches in our programs.

Let’s see what happens if our Jet subclass inherits this version of the Aircraft class. At the moment I don’t have a constructor in the Jet class.

When I create an instance of Jet, here is what happens:

Same error as before, but this time it doesn’t make a lot of sense. The error message says that this is an abstract class and I can’t instantiate it.

Let’s see if we can improve this exception and error message…

We could raise a NotImplementedError instead to clearly show that methods in the abstract class need to be implemented in its subclasses.

Now, let’s create an instance of Jet:

The message is clearer now…

…let’s define a constructor in the subclass Jet:

Now we can create an instance of Jet and execute the fly method:

All good this time!

Have you enjoyed this tutorial? We went through quite a lot!

We have started by explaining the concept of abstract classes that represent a common interface to create classes that follow well-defined criteria. The name of the Python module we have used in all the examples is ABC (Abstract Base Classes).

Abstract classes cannot be instantiated and they are designed to be extended by concrete classes that have to provide an implementation for all the abstract methods in their parent class.

You have also learned that the @abstractmethod decorator allows you to define which methods are abstract. It also applies to property methods to enforce the implementation of getters and setters.

Finally, we have seen how to define abstract classes with different versions of Python and how we could “simulate” the behavior of the @abstractmethod decorator by raising exceptions in the methods of our abstract class.

Are you completely new to abstract classes or have you used them before?

Let me know in the comments below!

Another important concept of object-oriented programming in Python is inheritance (we have covered some concepts about inheritance in this tutorial too).

To learn more about Python classes have a look at the following CodeFatherTech articles about defining Python classes and Python class inheritance .

Claudio Sabato - Codefather - Software Engineer and Programming Coach

Claudio Sabato is an IT expert with over 15 years of professional experience in Python programming, Linux Systems Administration, Bash programming, and IT Systems Design. He is a professional certified by the Linux Professional Institute .

With a Master’s degree in Computer Science, he has a strong foundation in Software Engineering and a passion for robotics with Raspberry Pi.

Static Method vs Class Method in Python. What is The Difference?
Does Python support private methods?
What is a Class Instance Method in Python? [Simple Examples]
Python: Using a Lambda as a Class Method

We Love Servers.

WHY IOFLOOD?
BARE METAL CLOUD
DEDICATED SERVERS

Python Abstract Classes | Usage Guide (With Examples)

Are you finding it challenging to understand abstract classes in Python? You’re not alone. Many developers grapple with this concept, but once mastered, it can significantly streamline your coding process.

Think of abstract classes as blueprints for other classes, guiding the structure of derived classes. They are a powerful tool in the Python programmer’s arsenal, enabling you to write more efficient, readable, and maintainable code.

In this guide, we’ll walk you through the ins and outs of abstract classes in Python, from basic usage to advanced techniques. We’ll cover everything from creating an abstract class using the abc module, to more complex uses of abstract classes, and even alternative approaches.

Let’s get started!

TL;DR: How Do I Create an Abstract Class in Python?

In Python, you can create an abstract class using the abc module. This module provides the infrastructure for defining abstract base classes (ABCs).

Here’s a simple example:

In this example, we import the ABC and abstractmethod from the abc module. We then define an abstract class AbstractClassExample using the ABC as the base class. The abstractmethod decorator is used to declare the method do_something as an abstract method. This means that any class that inherits from AbstractClassExample must provide an implementation of the do_something method.

This is a basic way to create an abstract class in Python, but there’s much more to learn about using and understanding abstract classes. Continue reading for a more detailed understanding and advanced usage scenarios.

Table of Contents

Creating an Abstract Class in Python: The Basics

Advanced abstract classes: beyond the basics, exploring alternatives: metaclasses and third-party libraries, troubleshooting abstract classes: common errors and solutions, best practices and optimization, python abstract classes: an oop perspective, abstract classes in the wild: real-world applications, wrapping up: mastering python abstract classes.

In Python, abstract classes are created using the abc module, which stands for Abstract Base Class. This module provides the necessary infrastructure for defining abstract base classes (ABCs) in Python. The key components of this module that we’ll use are the ABC class and the abstractmethod decorator.

Understanding the abc Module

The abc module provides the ABC class that we can use as a base class for creating abstract classes. Here’s a simple example:

In this example, we’ve created a class MyAbstractClass that inherits from ABC . However, at this point, MyAbstractClass is not yet an abstract class because it doesn’t contain any abstract methods.

Using the abstractmethod Decorator

To create an abstract method, we use the abstractmethod decorator. An abstract method is a method declared in an abstract class but doesn’t contain any implementation. Subclasses of the abstract class are generally expected to provide an implementation for these methods. Here’s an example:

In this example, my_abstract_method is an abstract method. If we create a subclass of MyAbstractClass and try to create an instance without providing an implementation for my_abstract_method , Python will raise a TypeError .

Advantages and Potential Pitfalls

Using abstract classes provides a clear structure for your code and makes it easier to work in a team setting. It ensures that certain methods must be implemented in any subclass, which can help prevent errors.

However, it’s important to remember that Python’s abc module is not enforced at the language level but rather at the runtime level. This means that errors related to not implementing abstract methods in a subclass will only be caught at runtime, not during syntax checking or linting. Therefore, thorough testing is crucial when working with abstract classes in Python.

After mastering the basics of abstract classes in Python, you may find yourself needing more advanced techniques. Abstract classes can be used in more complex scenarios like multiple inheritance and interface implementation. Let’s dive into these concepts.

Multiple Inheritance with Abstract Classes

Python supports multiple inheritance, a feature where a class can inherit from more than one base class. This includes abstract classes. Here’s an example:

In this example, Derived is a subclass of both Base1 and Base2 and provides an implementation for the abstract methods from both base classes.

Implementing Interfaces with Abstract Classes

In Python, abstract classes can also be used to implement interfaces. An interface is a blueprint for a class, much like an abstract class, but it usually only contains method signatures and no implementation.

Here’s an example of using an abstract class to define an interface:

In this example, MyInterface is an abstract class that serves as an interface. MyClass is a concrete class that provides an implementation for the methods defined in MyInterface .

Using abstract classes for more complex scenarios like these can greatly enhance the structure and readability of your code. However, as with any powerful tool, it’s important to use these techniques judiciously and in the right context.

While the abc module is a powerful tool for creating abstract classes in Python, there are other approaches you can use, such as metaclasses and third-party libraries like zope.interface . Let’s dive into these alternative methods.

Using Metaclasses to Create Abstract Classes

A metaclass in Python is a class of a class, or rather, a class that defines the behavior of other classes. You can use metaclasses to create abstract classes in Python. Here’s an example:

In this example, AbstractClassMeta is a metaclass that raises a TypeError if the class it’s being applied to doesn’t have any abstract methods. AbstractClass uses AbstractClassMeta as its metaclass and defines an abstract method my_abstract_method .

Leveraging Third-Party Libraries: zope.interface

The zope.interface library is a third-party library that provides a way to define interfaces and abstract classes in Python. Here’s an example:

In this example, IMyInterface is an interface that defines an abstract method my_abstract_method . MyClass provides an implementation for my_abstract_method and is declared to implement IMyInterface using the @implementer decorator.

These alternative approaches to creating abstract classes in Python can provide additional flexibility and capabilities beyond what the abc module offers. However, they also come with their own trade-offs. Metaclasses can be complex and difficult to understand, while third-party libraries add external dependencies to your project. As always, it’s important to consider the specific needs and constraints of your project when deciding which approach to use.

Working with abstract classes in Python can sometimes lead to errors or obstacles. Let’s explore some common issues and their solutions.

Instantiating an Abstract Class

One common mistake when working with abstract classes is attempting to create an instance of an abstract class. Since abstract classes are meant to be a blueprint for other classes, they cannot be instantiated directly. Trying to do so will lead to a TypeError .

The solution is to create a concrete subclass that implements all the abstract methods of the abstract class, and then instantiate that subclass.

Not Implementing All Abstract Methods

Another common error is not implementing all the abstract methods in a subclass of an abstract class. If a subclass doesn’t provide implementations for all abstract methods of the superclass, Python will raise a TypeError when you try to create an instance of the subclass.

The solution is to ensure that all subclasses implement all abstract methods of the superclass.

When working with abstract classes in Python, it’s important to follow best practices to ensure your code is efficient and maintainable. Here are a few tips:

Use abstract classes when you want to provide a common interface for different classes.
Don’t overuse abstract classes. If a class doesn’t need to provide an interface and doesn’t have any abstract methods, it probably doesn’t need to be an abstract class.
Keep abstract classes small and focused. They should define a specific interface, not try to do too many things at once.
Remember that Python’s abc module is a runtime feature. Errors related to abstract classes won’t be caught until your code is actually running, so make sure to thoroughly test any code that uses abstract classes.

To fully understand the concept of abstract classes in Python, it’s crucial to have a grasp of some fundamental principles of Object-Oriented Programming (OOP). These principles include inheritance, encapsulation, and polymorphism. Let’s examine these concepts and the role of abstract classes in each.

Inheritance: The Parent-Child Relationship

Inheritance is an OOP principle that allows one class to inherit the properties and methods of another class. In the context of abstract classes, the abstract class serves as the parent class, and the subclasses that implement the abstract methods are the child classes.

In this example, Parent is an abstract class with an abstract method common_method . Child is a subclass of Parent that provides an implementation for common_method .

Encapsulation: Hiding the Complexity

Encapsulation is the principle of hiding the internal workings of an object and exposing only what is necessary. Abstract classes play a role in encapsulation by defining a clear interface that other classes can implement, hiding the complexity of the underlying implementation.

Polymorphism: One Interface, Many Implementations

Polymorphism is the ability of an object to take on many forms. With abstract classes, polymorphism is achieved through the implementation of the abstract methods in the subclasses. Each subclass can provide a different implementation, allowing for a variety of behaviors.

In this example, Dog and Cat are subclasses of the abstract class AbstractAnimal and provide different implementations for the make_sound method, demonstrating polymorphism.

In conclusion, abstract classes in Python play a crucial role in implementing the principles of OOP. They provide a blueprint for creating subclasses, encapsulate complexity, and enable polymorphism, making your code more structured, maintainable, and flexible.

Abstract classes are not just theoretical constructs, but they have practical applications in larger projects and real-world scenarios. They are often used in software design patterns, such as the Template Method pattern, where an abstract class defines a ‘skeleton’ of an algorithm in an operation and defers some steps to subclasses.

In this example, AbstractClass defines the template_method which outlines the algorithm’s structure and calls primitive_operation1 and primitive_operation2 , which are abstract methods. The ConcreteClass provides the specific implementations for these operations.

Further Resources for Mastering Python Abstract Classes

To deepen your understanding of abstract classes and related topics, here are some resources that offer more in-depth information:

Python OOP Best Practices – Dive into inheritance in Python to build relationships between classes and reuse code.

Exploring the Object Class in Python – Learn about Python objects as instances of classes, representing real-world entities.

Understanding Classes in Python – Learn how to define and instantiate classes in Python for object-oriented programming.

Python’s Official Documentation on the ABC Module – Learn about Python’s abstract base class module from official sources.

Real Python’s Guide on Abstract Base Classes – Detailed explanation of abstract base classes in Python.

Python-Course’s Tutorial on Abstract Classes – Step-by-step guide to understanding abstract classes in Python.

These resources provide a wealth of information and examples that can help you master the use of abstract classes in Python and apply them effectively in your own projects.

In this comprehensive guide, we’ve navigated through the concept of abstract classes in Python. From understanding the basic use to exploring advanced techniques, we’ve covered the essential aspects of this powerful programming construct.

We started with the basics, learning how to create an abstract class using the abc module. We then ventured into more advanced territory, discussing complex uses such as multiple inheritance and interface implementation.

Along the way, we tackled common challenges you might face when using abstract classes and provided solutions to help you overcome these hurdles.

We also looked at alternative approaches to creating abstract classes, such as using metaclasses and third-party libraries like zope.interface . This gave us a broader understanding of the various ways to implement abstract classes in Python.

Here’s a quick comparison of these methods:

Whether you’re a beginner just starting out with abstract classes or an experienced Python developer looking to level up your skills, we hope this guide has given you a deeper understanding of abstract classes in Python and how to use them effectively in your code. Happy coding!

About Author

Gabriel Ramuglia

Gabriel is the owner and founder of IOFLOOD.com , an unmanaged dedicated server hosting company operating since 2010.Gabriel loves all things servers, bandwidth, and computer programming and enjoys sharing his experience on these topics with readers of the IOFLOOD blog.

Visual comparison of digital pathways labeled npx and npm to depict their differences in package management

Contributors

Abstract Classes

Table of contents, introduction to python abstract class, creating python abstract base class, python abstract class vs interface, polymorphism in python abstract classes, usage of python abstract base classes (abc), best practices for designing python abstract classes.

In object-oriented programming, an abstract class is a class that cannot be instantiated and is designed to be subclass, providing a basic interface for its derived classes. Python is an object-oriented language that supports abstract classes through its Abstract Base Class (ABC) module. This module provides a way to define abstract classes and enforce their interface on their subclasses. This article will explore the concept of abstract classes in Python and how they are implemented using Python abstract base class.

In Python, an abstract class is a class that is designed to be inherited by other classes. It cannot be instantiated on its own and its purpose is to provide a template for other classes to build on.

An abstract base class in Python is defined using the abc module. It allows us to specify that a class must implement specific methods, but it doesn't provide an implementation for those methods. Any class that inherits from an abstract base class must implement all the abstract methods.

In the above example, Shape is an abstract base class that defines an abstract method area . Rectangle is a concrete class that inherits from Shape and implements the area method.

In this example, Animal is an abstract base class that defines an abstract method talk . Dog and Cat are concrete classes that inherit from Animal and implement the talk method.

In conclusion, abstract classes in Python provide a way to define a template for other classes to build on. They cannot be instantiated on their own and they provide a way to ensure that subclasses implement specific methods. The abc module provides a way to define abstract base classes in Python.

An abstract class is a class that cannot be instantiated and is meant to be used as a base class for other classes.

In Python, the abc module provides ABC class. It is used to create abstract base classes.

To create an abstract base class, we need to inherit from ABC class and use the @abstractmethod decorator to declare abstract methods.

Example of Abstract Class

In this example, we have created an abstract base class Shape with two abstract methods area and perimeter . Any class that inherits from Shape has to implement these two methods.

Example of Abstract Class with Inheritance

In this example, we have created an abstract base class Animal with an abstract method sound . We have also created a class Dog that inherits from Animal and implements the sound method.

A class that inherits from an abstract base class must implement all the abstract methods declared in the base class, unless it is also an abstract class.

An abstract class is a Python class that cannot be instantiated, and it is used to define common properties and behaviors that subclasses can inherit. It is defined using the abc module, which stands for abstract base class. An abstract class is used when we want to define a base class, and we don't want it to be instantiated. Instead, we want it to be subclassed by other classes that will provide specific implementations of its abstract methods.

Example of a Python Abstract Base Class

In the above example, Animal is an abstract base class with an abstract method called move(). Dog and Snake are two subclasses of the Animal class, and they provide their specific implementations of the move() method.

Interfaces in Python

An interface is a collection of abstract methods that defines the behavior of a class. In Python, there is no strict definition of an interface like in other programming languages like Java. Instead, we use abstract classes to define interfaces. An interface can be considered as a contract between the class and the outside world. A class that implements an interface must provide an implementation for all the methods defined in the interface.

Example of a Python Interface

In the above example, Shape is an interface with two abstract methods called area() and perimeter() . Rectangle is a class that implements the Shape interface and provides its implementation for the area() and perimeter() methods.

An abstract class is a class that cannot be instantiated, but it can be used as a base for other classes. It is a way to define a common interface for a group of related classes. Polymorphism is the ability of an object to take on many forms. In Python, abstract classes can be used to implement polymorphism.

Abstract classes in Python are classes that cannot be instantiated, and are meant to be inherited by other classes. They are useful for defining common methods and properties that should be implemented by their concrete subclasses.

One way to implement abstract classes in Python is to use abstract base classes (ABCs) from the abc module. An ABC is a special type of class that cannot be instantiated directly, but can be subclassed. ABCs define one or more abstract methods, which are methods that must be implemented by any concrete subclass.

The following code example shows how to define an abstract base class Animal , which defines two abstract methods speak and move that must be implemented by any concrete subclass:

Now, any concrete subclass of Animal must implement both speak and move .

Another benefit of using ABCs in Python is that they can be used to enforce certain interface contract on classes, without specifying their implementation details.

For example, if you want to define a function that accepts only objects that have a draw method, you could define an ABC called Drawable , which defines an abstract method draw :

In this example, the draw_all function accepts a list of Drawable objects, which it draws by calling their draw method. The Rectangle and Circle classes both implement the draw method, so they can be used with draw_all function.

Overall, abstract base classes in Python provide a powerful tool for code design, by allowing you to define common functionality that can be easily extended and customized by concrete subclasses.

When designing abstract classes in Python, it is important to follow best practices to ensure a maintainable and readable codebase.

Use the abc module to define an abstract base class (ABC).
Use abstract methods to specify the contract that derived classes must follow.

Following these best practices will ensure that your abstract classes are easily understandable and maintainable, with clear contracts for derived classes to follow.

Contribute with us!

Do not hesitate to contribute to Python tutorials on GitHub: create a fork, update content and issue a pull request.

software development and tech.

Abstract Class in Python — A Complete Guide (with Examples)

An abstract method is a method that has a declaration but no implementation. A Python class with at least one abstract method is called an abstract class .

To create an abstract class in Python, use the abc module.

For example, here is an abstract class Pet :

The idea of an abstract class is that when you inherit it, the child class should define all the abstract methods present in the parent class.

Notice that you cannot create objects of an abstract class. An abstract class can only act as a blueprint for creating subclasses.

Why Abstract Classes?

An abstract class acts as a blueprint for subclasses. It is the main class that specifies how the child classes should behave. In a sense, an abstract class is the “class for creating classes”.

For example, Shape could be an abstract class that implements an abstract method area() . Then the subclasses Circle , Triangle , and Rectangle provide their own implementations of this method based on their characteristics in geometry.

So, abstract classes make it possible to enforce rules for creating related child classes.

How to Write Abstract Classes in Python

To write an abstract class in Python, you need to use the abc (Abstract Base Class) module.

Here’s how you can do it:

Import ABC class and abstractmethod decorator from the abc module.
Make your abstract class a subclass of the ABC class. This tells Python interpreter that the class is going to be an abstract class.
Tag a method with the @abstractmethod decorator to make it an abstract method.

Now that you’ve learned how to build an abstract class in Python, let’s see some examples to make any sense of it.

Example: Creating Abstract Class in Python

In this example, we implement an abstract base class Pet . In this class, we implement an abstract method makesound() .

Because different pets make different sounds, it makes sense to use an abstract class with an abstract makesound() method. This way, it is up to the pet type how to implement the makesound() method. All we care about is that the subclass must implement some version of the makesound() method.

Here’s an example code that uses the abstract Pet class in creating a Cat subclass to represent cats:

At this point, you can verify that it is not possible to create an object from the abstract class!

For example:

Trying to create an object from the abstract class gives an error:

The error says it all. It’s not possible to create an abstract class object.

When Should I Use an Abstract Class in Python?

Some notable reasons as to why or when you should use an abstract class in Python include:

Avoids duplicate code.
Enforces consistency in how to implement subclasses.
Makes sure no critical methods and properties are forgotten subclasses.

These benefits are especially noticeable when working in a team of developers where the team members might reuse or extend your code. Enforcing strict rules for subclasses makes it easy to reuse and extend the code.

Today you learned what is an abstract class in Python.

To recap, an abstract class is “the class of classes”. It is a base class that specifies what methods its subclasses should implement. Abstract classes allow for specifying strict rules for how to write classes in Python. This helps write consistent and manageable code.

You cannot create an object from an abstract class.

Thanks for reading. I hope you enjoy it.

Happy coding!

Python’s Abstract Base Classes (ABC) and Interfaces Explained (With Code Snippets)

When you get started with object-oriented programming, you will come across interfaces and abstract classes. Especially languages like Java or C# make use of those two concepts a lot to structure complex programming projects and to leverage abstraction. However, in Python, interfaces and abstract classes aren’t part of the standard languages’ definition. In this article, you will learn what interfaces and abstract classes are and how to use Python’s ABC module to use those two concepts in your Python code.

What are Interfaces and Abstract Classes in a Programming Language?

Interfaces in object-oriented programming languages.

In general terms, an interface is the definition of the inputs and outputs of a thing. For example, the common inputs and outputs of water kettles are:

However, each water kettle manufacturer will “implement” those inputs and outputs differently. Some have a large lid to fill in the water while others have an only small hole, or some water kettles have their button on the top while others have their button on the bottom. An interface does not specify the implementation, it only specifies the inputs and outputs of something.

An in object-oriented programming languages interface also acts as a description of which methods a class has and what the input parameters and outputs of those methods are. To create an instance that implements an interface, there must be a class that implements the interface. There are no instances of interfaces.

Abstract classes in Object-oriented Programming Languages

In contrast to interfaces, an abstract class not only defines the inputs and outputs, it also defines the behavior. Coming back to the water kettle example, an abstract water kettle class would provide a method that implements how water is boiled. Regular classes can inherit from abstract classes to make use of the implementation of an abstract class.

Interfaces and Abstract Classes in Java

After this short theory block, let’s take a look at Java, which a very pedantic object-oriented programming language.

First define an abstract class called Animal . This abstract class has the String attribute name , a default constructor to set name , and a method walk which implements a default “walking” behavior:

It makes sense to define Animal as an abstract class because there is no “Animal” in the real world, there are only specializations of animals such as dogs, cats, horses, etc. Therefore, Animal cannot be instantiated.

Using the abstract class Animal allows you to implement a Dog class which already comes with the common attribute name and the method walk , additionally the method wag_tail is added, which is common among all dogs:

Some animals might have special abilities such as talking, but how they talk is different across different animals. A Talking interface allows you to specify the talk method together with its inputs and outputs without actually implementing it:

Now you can define a TalkingDog class which inherits from Dog and implements the Talking interface. While inheriting from the Dog class provides all the common attributes and methods of Dogs, implementing the Talking interface requires you to implement the talk method:

Putting everything together in a Java Main class (yes, everything in Java is a class) lets you compile and run the code using interfaces and abstract classes.

To compile the code above, use the following commands:

Why are there no Interfaces and Abstract Classes in Python by Default (Duck Typing Explained)?

Now that you know how interfaces and abstract classes are used in object-oriented languages such as Java, let us take a look at Python. Python is a multi-paradigm programming language which has object-oriented features such as classes and inheritance. However, by default, Python doesn’t have interfaces and abstract classes. The reason for this can largely be attributed to the fact that Python is an interpreted language and doesn’t need a compiler to run your code.

In a compiled language such as C++, the compiler turns the code you write into machine instructions. For example, at the time of compilation, it is checked if the arguments passed to a function are actually of the correct type stated in the method signature this allows for much faster code execution because at runtime there are no checks if the arguments that are passed to a method are compatible. This is why languages like C++ or Java are often called strictly typed languages because it is not possible to pass the wrong argument type to a method.

Python uses a concept called duck typing. By default, Python methods accept every type for every input, and there are no checks at runtime if the type is actually correct, only if the number of arguments passed is checked. Only when an attribute of a Python object is accessed or a method is called, the interpreter checks if those are actually available.

In the code above, there are the two classes Duck and Cat , both with their respective methods quack() and meow() . The function make_it_quack(duck) has the parameter duck as an input and will call the quack() method of duck when the counter is greater than 0 . When calling the make_it_quack function the first time and passing an object of type Cat everything works fine. However, the second time, when the counter is incremented, the Python interpreter will complain with the following error message:

This is because, only at the time of calling the method, it is checked if an object provides this method.

You can also check yourself which methods and attributes an object has at runtime using the built-in dir() function:

The Python interpreter uses this dir() function at runtime to check if an object can be used for the given purpose. This is also called the Duck Test , which states:

“If it walks like a duck and it quacks like a duck, then it must be a duck”

Which means the type of an object is almost completely irrelevant because as long as the object provides the correct methods and attributes it can be used regardless of its type.

How to Implement an Abstract Class in Python?

Even though Python uses duck typing, it can be beneficial to make use of abstract classes and interfaces in complex software projects to communication the abilities of objects. Therefore the Python module abc (short for abstract base classes) provides base classes and decorators to implement abstract classes and interfaces

The following code shows how an abstract Animal class can be implemented using abc :

From abc the class ABC is imported, which is the Abstract Base Class from which all abstract classes inherit. The methods and attributes of an abstract class in Python can be defined as in any other regular class.

Inheriting from an abstract Python class works as with any other class in Python:

And in contrast to Java, an abstract class can also be instantiated in Python without the need for inheriting from it first. This means that abstract classes in Python have more decorative purposes rather than real functionality. However, it can be useful to have abstract classes to tell other developers who want to use your code that this class is not intended for instantiation on its own.

How to Implement an Interface in Python

While abstract classes in Python can be instantiated, interfaces can’t. Defining an interface in Python is also done by inheriting from ABC . But in contrast to an abstract class, all methods of an interface are decorated using @abstractmethod :

When inheriting from an interface (e.g. implementing it) the @abstractmethod decorator ensures that all methods decorated with it are overridden by the implementing class. It is possible to give a method decorated with @abstractmethod an implementation in the interface but this implementation is never used because all implementers need to override it.

Putting it all Together

Using the Python abc module, you can now implement abstract classes and interfaces in the same way as in the Java example above. Talking is an interface which provides the method talk() , Animal is an abstract class which implements the attribute name and the method walk() , while Dog inherits from Animal and adds wag_tail() , and TalkingDog inherits from Dog and implements talk() from the interface Talking :

In this article, you have learned what interfaces and abstract classes are in object-oriented programming languages, and how to make use of them in Python to structure your code. Make sure to get the free Python Cheat Sheets in my Gumroad shop . If you have any questions about this article, feel free to join our Discord community to ask them over there.

A Python Program that Self-destructs but Makes a Clone of Itself Just in Time to Stay Alive

This article shows how to write a Python program which destructs itself when it is called, by deleting its own source code, and then creates a copy of itself just to call this copy to “live” on f...

Python *args, **kwargs, and Star/Asterisk-Operator Explained in Simple Terms (With Code Snippets)

You just discovered a cool Python module that helps you to implement your program much more elegantly or even faster and while you are digging through the code and documentation you come across *...

Python Decorators, A Beginners Guide (With Code Examples)

How to Setup a Zynq UltraScale+ Vivado Project and Run a C-Code Example Accessing an AXI Slave on the FPGA

Trending Tags

Abstract Classes in Python: A Beginner's Guide

If you're looking for an easy-to-follow guide about abstract classes in Python, you've come to the right place.

An abstract class is a blueprint for related classes. It can't be instantiated but can only be accessed through inheritance. A subclass that inherits an abstract class is required to implement its abstract methods. Otherwise, the compiler will flag an error.

Abstract methods are methods without implementation. An abstract class can have abstract methods or concrete (normal) methods.

Python doesn't directly support abstract methods, but you can access them through the abc (abstract base class) module.

Using the abc Module in Python

To define an abstract class in Python, you need to import the abc module.

See the example below:

Notice the keyword pass . This keyword is used to stand in for empty code. Leaving it out will give a compilation error.

Related: Will Julia Make a Bid for Python’s Throne?

Class definitions, method definitions, loops, and if statements expect code implementations. So, leaving them out gives a compilation error. To avoid this, use pass to substitute the empty code.

To define an abstract method in Python, use the @abstractmethod decorator:

At this point, it would be good to mention that—unlike Java—abstract methods in Python can have an implementation.. This implementation can be accessed in the overriding method using the super() method.

It's interesting to note that you can define a constructor in an abstract class.

On line 9, you can observe that @abc.abstractmethod has been used as the abstract method decorator. This is another way of doing so other than the previous form. Notice also that line 1 is shorter ( import abc ) than the former line 1 import that you used.

It's all a matter of choice. Though, many may find the second method shorter.

Exception Handling in Python

Notice that there's no way to capture errors in the code example given above. Bugs occur more often than not, and having a reliable way to get them can be a game-changer.

These events that disrupt normal program flow are called "exceptions", and managing them is called "exception handling." Next on your Python reading list should be exception handling.

Learn Python
Python Lists
Python Dictionaries
Python Strings
Python Functions
Learn Pandas & NumPy
Pandas Tutorials
Numpy Tutorials
Learn Data Visualization
Python Seaborn
Python Matplotlib

Python abc: Abstract Base Class and abstractmethod

December 23, 2022 December 23, 2022

Abstract base classes, implemented through the Python abc module, allow you to write cleaner, safer code. But what are abstract classes and when do you need them? In this tutorial, you’ll learn what abstract base classes are in Python, how to use the Python abc module, and how to use abstractmethod and abstract properties .

In a nutshell, abstract base classes allow you to implement rules around subclasses. This allows you to define methods that a subclass must have. Similarly, it allows you to define what parameters a subclass must have.

By the end of this tutorial, you’ll have learned the following:

How to create abstract base classes in Python using the abc module
How to enforce methods in subclasses using the abstractmethod decorators
How to force and use parameters when using methods in subclasses
How to enforce properties when subclassing data in Python using the abc module

Table of Contents

Understanding Abstract Base Classes with Python abc

Python implements abstract classes through the abc library. But, what are abstract classes, really? Abstract classes are classes that contain one or more abstract methods. These methods are declared but not implemented . In fact, you don’t instantiate an abstract class, but use a subclass to provide the details for implementation via its abstract methods.

All of this may seem like a lot – and it is a bit abstract. For me, the simplest way to understand this is to think of abstract classes as being a framework of what a subclass must have .

Let’s walk through an example. Imagine that we want to define a set of classes for employees, specifically for managers, supervisors, and staff. For these employees, all staff should be able to arrive at work. Let’s see how we might define what this looks like:

All of these classes have methods that, functionally, do the same thing – have the employee get to work. However, if we want to actually have the employee object show up at work, we need to use three different implementations for the same thing.

This is where abstract base classes come into play. We can enforce what methods are required when subclassing by using the Python abc module . For example, if we know that each employee needs to get to work, we can define an abstract method to accomplish this.

Now that we’ve developed a good case for using abstract classes in Python, let’s dive into how to do this using the Python abc module.

How to Use abstractmethod With Python abc

In order to create abstract classes in Python, we can use the built-in abc module. The module provides both the ABC class and the abstractmethod decorator. Let’s dive into how to create an abstract base class:

We can see that we now have a class Employee , which inherits from the ABC class itself. The class has only a single method, which is decorated using the @abstractmethod decorator. The method itself doesn’t do anything but accepts the self keyword as an argument. This part is important: the method shouldn’t do anything except for exist.

Now when we create subclasses of the Employee class, these classes will need to have a method named .arrive_at_work() . Let’s see what happens when we create a subclass with a different method:

Instantiating our Manager class raises a TypeError since we don’t have a .arrive_at_work() method. Let’s see how we can resolve this issue:

When we run the code above, no error is raised. This is because we have the correctly named method.

Remember from earlier in the tutorial that the implementation of the abstract method is up to the subclass itself . Because of this, we can have different implementations of these methods which do different things – as long as they have the correct names. Let’s see what this looks like:

We can see in the example above that the code runs fine. This is because both subclasses have the correct name – even if their implementations differ.

In the following section, you’ll learn how to add parameters to an abstractmethod and how to enforce that they exist in any subclasses.

How to Add Parameters to an abstractmethod in Python abc

What’s great about the abstractmethod decorator is that we can even require a method to have one or more parameters. This allows you to ensure that any method that exists in the subclass has the required parameters.

For example, if you needed the .arrive_at_work() method to have a time passed in, then you can do this using the abstractmethod decorator. Let’s see what this looks like:

In the code block above, we use the ABC class to create an abstract base class. The method in the class has an additional parameter, arrival_time . Both subclasses have this parameter and are required to have the parameter.

What’s interesting is that the Supervisor subclass actually has an additional parameter. The subclass only requires the parameters defined in the abstract class itself, but can also have additional parameters .

How to Add Properties to Abstract Base Classes in Python

In this section, you’ll learn how to add properties to abstract base classes. This allows you to ensure that certain properties are set when creating an abstract base class. This process is a bit more involved, so let’s take a look at an example.

In the example above, we use the @property decorator to ensure that items are labeled as properties. We also need to provide setter methods in order to make sure that they work. Notice that we implement the property before we define the setter.

Then, in the subclass, we follow a similar method of defining these items. As long as our properties and methods have the correct names, the subclass will inherit appropriately.

In this tutorial, you learned how to use the Python abc module to create abstract base classes, which act as blueprints for additional subclasses. You first learned why the concept of abstract classing is important. Then, you learned how to use the ABC class from the abc module to create an abstract class framework.

From there, you learned how to define abstract methods using the abstractmethod decorator. You also learned how to require certain parameters for subclass methods. Finally, you also learned how to set properties for any subclasses of abstract base classes.

Additional Resources

To learn more about related topics, check out the resources below:

Python Object-Oriented Programming (OOP) for Data Science
Get and Check Type of a Python Object: type() and isinstance()
Python: Print an Object’s Attributes
Python abc: Official Documentation

Nik Piepenbreier

Nik is the author of datagy.io and has over a decade of experience working with data analytics, data science, and Python. He specializes in teaching developers how to use Python for data science using hands-on tutorials. View Author posts