{"id":544,"date":"2020-10-15T03:08:00","date_gmt":"2020-10-15T03:08:00","guid":{"rendered":"https:\/\/www.pythontutorial.net\/?page_id=544"},"modified":"2025-03-31T10:15:48","modified_gmt":"2025-03-31T10:15:48","slug":"python-abstract-class","status":"publish","type":"page","link":"https:\/\/www.pythontutorial.net\/python-oop\/python-abstract-class\/","title":{"rendered":"Python Abstract Classes"},"content":{"rendered":"\n

Summary<\/strong>: in this tutorial, you’ll learn about Python Abstract classes and how to use it to create a blueprint for other classes.<\/p>\n\n\n\n

Introduction to Python Abstract Classes #<\/a><\/h2>\n\n\n\n

In object-oriented programming, an abstract class is a class<\/a> that cannot be instantiated. However, you can create classes that inherit from an abstract class.<\/p>\n\n\n\n

Typically, you use an abstract class to create a blueprint for other classes.<\/p>\n\n\n\n

Similarly, an abstract method is an method without an implementation. An abstract class may or may not include abstract methods.<\/p>\n\n\n\n

Python doesn’t directly support abstract classes. But it does offer a module<\/a> that allows you to define abstract classes.<\/p>\n\n\n\n

To define an abstract class, you use the abc<\/code> (abstract base class) module.<\/p>\n\n\n\n

The abc<\/code> module provides you with the infrastructure for defining abstract base classes.<\/p>\n\n\n\n

For example:<\/p>\n\n\n

from<\/span> abc import<\/span> ABC\n\n\nclass<\/span> AbstractClassName<\/span>(ABC)<\/span>:<\/span>\n    pass<\/span>\n<\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
To define an abstract method, you use the @abstractmethod<\/code> decorator:<\/p>\n\n\n
from<\/span> abc import<\/span> ABC, abstractmethod\n\n\nclass<\/span> AbstractClassName<\/span>(ABC)<\/span>:<\/span>\n    @abstractmethod<\/span>\n    def<\/span> abstract_method_name<\/span>(self)<\/span>:<\/span>\n        pass<\/span>\n<\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
The Employee class #<\/a><\/h3>\n\n\n\n
The Employee<\/code> class represents an employee, either full-time or hourly. The Employee<\/code> class should be an abstract class because there’re only full-time employees and hourly employees, no general employees exist.<\/p>\n\n\n\n
The Employee<\/code> 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.<\/p>\n\n\n\n
The following defines the Employee<\/code> abstract class:<\/p>\n\n\n
from<\/span> abc import<\/span> ABC, abstractmethod\n\n\nclass<\/span> Employee<\/span>(ABC)<\/span>:<\/span>\n    def<\/span> __init__<\/span>(self, first_name, last_name)<\/span>:<\/span>\n        self.first_name = first_name\n        self.last_name = last_name\n\n    @property<\/span>\n    def<\/span> full_name<\/span>(self)<\/span>:<\/span>\n        return<\/span> f\"{self.first_name}<\/span> {self.last_name}<\/span>\"<\/span>\n\n    @abstractmethod<\/span>\n    def<\/span> get_salary<\/span>(self)<\/span>:<\/span>\n        pass<\/span>\n<\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
The FulltimeEmployee class #<\/a><\/h3>\n\n\n\n
The FulltimeEmployee<\/code> class inherits from the Employee<\/code> class. It’ll provide the implementation for the get_salary()<\/code> method.<\/p>\n\n\n\n
Since full-time employees get fixed salaries, you can initialize the salary in the constructor of the class.<\/p>\n\n\n\n
The following illustrates the FulltimeEmployee<\/code> class:<\/p>\n\n\n
class<\/span> FulltimeEmployee<\/span>(Employee)<\/span>:<\/span>\n    def<\/span> __init__<\/span>(self, first_name, last_name, salary)<\/span>:<\/span>\n        super().__init__(first_name, last_name)\n        self.salary = salary\n\n    def<\/span> get_salary<\/span>(self)<\/span>:<\/span>\n        return<\/span> self.salary\n<\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
The HourlyEmployee class #<\/a><\/h3>\n\n\n\n
The HourlyEmployee<\/code> also inherits from the Employee<\/code> class. However, hourly employees get paid by working hours and their rates. Therefore, you can initialize this information in the constructor of the class.<\/p>\n\n\n\n
To calculate the salary for the hourly employees, you multiply the working hours and rates.<\/p>\n\n\n\n
The following shows the HourlyEmployee<\/code> class:<\/p>\n\n\n
class<\/span> HourlyEmployee<\/span>(Employee)<\/span>:<\/span>\n    def<\/span> __init__<\/span>(self, first_name, last_name, worked_hours, rate)<\/span>:<\/span>\n        super().__init__(first_name, last_name)\n        self.worked_hours = worked_hours\n        self.rate = rate\n\n    def<\/span> get_salary<\/span>(self)<\/span>:<\/span>\n        return<\/span> self.worked_hours * self.rate\n<\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
The Payroll class #<\/a><\/h2>\n\n\n\n
The Payroll<\/code> class will have a method that adds an employee to the employee list and print out the payroll.<\/p>\n\n\n\n
Since fulltime and hourly employees share the same interfaces (full_time<\/code> property and get_salary()<\/code> method). Therefore, the Payroll class doesn’t need to distinguish them.<\/p>\n\n\n\n
The following shows the Payroll<\/code> class:<\/p>\n\n\n
class<\/span> Payroll<\/span>:<\/span>\n    def<\/span> __init__<\/span>(self)<\/span>:<\/span>\n        self.employee_list = []\n\n    def<\/span> add<\/span>(self, employee)<\/span>:<\/span>\n        self.employee_list.append(employee)\n\n    def<\/span> print<\/span>(self)<\/span>:<\/span>\n        for<\/span> e in<\/span> self.employee_list:\n            print(f\"{e.full_name}<\/span> \\t ${e.get_salary()}<\/span>\"<\/span>)\n<\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
The main program #<\/a><\/h3>\n\n\n\n
The following app.py<\/code> uses the FulltimeEmployee<\/code>, HourlyEmployee<\/code>, and Payroll<\/code> classes to print out the payroll of five employees.<\/p>\n\n\n
from<\/span> fulltimeemployee import<\/span> FulltimeEmployee\nfrom<\/span> hourlyemployee import<\/span> HourlyEmployee\nfrom<\/span> payroll import<\/span> Payroll\n\npayroll = Payroll()\n\npayroll.add(FulltimeEmployee('John'<\/span>, 'Doe'<\/span>, 6000<\/span>))\npayroll.add(FulltimeEmployee('Jane'<\/span>, 'Doe'<\/span>, 6500<\/span>))\npayroll.add(HourlyEmployee('Jenifer'<\/span>, 'Smith'<\/span>, 200<\/span>, 50<\/span>))\npayroll.add(HourlyEmployee('David'<\/span>, 'Wilson'<\/span>, 150<\/span>, 100<\/span>))\npayroll.add(HourlyEmployee('Kevin'<\/span>, 'Miller'<\/span>, 100<\/span>, 150<\/span>))\n\npayroll.print()<\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
Output:<\/p>\n\n\n
John Doe         $6000<\/span>\nJane Doe         $6500<\/span>\nJenifer Smith    $10000<\/span>\nDavid Wilson     $15000<\/span>\nKevin Miller     $15000<\/span><\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
When to use abstract classes #<\/a><\/h2>\n\n\n\n
In practice, you use abstract classes to share the code among several closely related classes. In the payroll program, all subclasses of the Employee<\/code> class share the same full_name<\/code> property.<\/p>\n\n\n\n
Summary #<\/a><\/h2>\n\n\n\n
Python abstract class example #<\/a><\/h2>\n\n\n\n
Suppose that you need to develop a payroll program for a company.<\/p>\n\n\n\n
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.<\/p>\n\n\n\n
The payroll program needs to print out a payroll that includes employee names and their monthly salaries.<\/p>\n\n\n\n
To model the payroll program in an object-oriented way, you may come up with the following classes: Employee<\/code>, FulltimeEmployee<\/code>, HourlyEmployee<\/code>, and Payroll<\/code>.<\/p>\n\n\n\n
To structure the program, we’ll use modules<\/a>, where each class is placed in a separate module (or file).<\/p>\n\n\n\n