Introduction to Python Abstract Classes and Abstract Methods; Define and Implement Python Abstract Classes and Abstract Methods

Interfaces in Python

You can’t define interfaces for Python as you can in other languages (e.g., C#) by using a keyword like interface; “interface” in Python is a conceptual term used to denote a functional implementation convention.

Define Python Abstract Classes

Although you can’t define an interface, Python abstract classes can achieve an approximation of an interface by constraining their derived classes to implement certain methods or attributes through overrides.

Similarly, Python does not provide a keyword like abstract for declaring an abstract class or an abstract base class (ABC); the definition of a Python abstract base class needs to be accomplished by specifying a metaclass, and any class that specifies the ABCMeta class of the abc module as a metaclass can be called a Python abstract base class. Specifying a metaclass requires the keyword metaclass, so the syntax for defining a Python abstract base class is as follows.

class <classname>(<metaclass=ABCMeta>):
    <block>

classname part

classname is the name of the abstract base class, which needs to conform to Python's identifier specification and cannot use Python keywords or reserved keywords.

block part

block is the body code of the abstract base class and needs to be indented with some sort of whitespace character to indicate that it belongs to the abstract base class.

from abc import ABCMeta


# Abstract base class representing movable
class Movable(metaclass=ABCMeta):
	pass


# Show Movable's Method Resolution Order and base classes
print(Movable.__mro__)
print(Movable.__bases__)

(<class '__main__.Movable'>, <class 'object'>)
(<class 'object'>,)

Of course, using the keyword metaclass may feel odd, and Python provides an alternative way of defining an abstract base class, by inheriting directly from the ABC class of the abc module, with the following syntax form, where classname and block have the same meaning as before.

class <classname>(ABC):
    <block>

from abc import ABC


# Abstract base class representing accessible
class Accessible(ABC):
	pass


# Show Accessible's Method Resolution Order and base classes
print(Accessible.__mro__)
print(Accessible.__bases__)

(<class '__main__.Accessible'>, <class 'abc.ABC'>, <class 'object'>)
(<class 'abc.ABC'>,)

Define Abstract Methods for Python Abstract Classes

In Python abstract base classes or their derived classes, you can use the @abstractmethod decorator provided by the abc module to define abstract methods or abstract attributes that are essentially methods. The @abstractmethod decorator can be used in conjunction with other decorators (@classmethod, @staticmethod, @property, etc.) to form more complex method definitions, such as abstract class methods, abstract static methods, abstract properties, etc.

ABCMeta checks whether a Python class derived from an abstract base class overrides all defined abstract methods or attributes in the inheritance chain when an instance of that Python class is created.

from abc import ABCMeta, abstractmethod


class Animal(metaclass=ABCMeta):
	# Abstract class method count
	@classmethod
	@abstractmethod
	def count(cls):
		pass


	# Abstract static method name
	@staticmethod
	@abstractmethod
	def name():
		print('What\'s the name?')


class Cat(Animal):
	pass


# Calls the unimplemented static method name and the unimplemented class method count
Cat.name()
Animal.count()
# ERROR Cat does not implement the abstract base class Animal
Cat().name()

What's the name?
…
TypeError: Can't instantiate abstract class Cat without an implementation for abstract methods 'count', 'name'

update_abstractmethods(cls)

cls parameter

The cls parameter is the abstract class to be updated.

from abc import ABC, abstractmethod, update_abstractmethods


# Define the abstract base class Color and the derived class Black
class Color(ABC):
	pass
class Black(Color):
	pass


# Dynamically add an abstract method to the abstract base class
@abstractmethod
def show(self):
	pass
Color.show = show


print('Create the first Black instance')
# There is no problem with creating an instance
Black()


# Update the abstract classes Color and Black
update_abstractmethods(Color)
update_abstractmethods(Black)
print('Create the second Black instance')
# ERROR You can't create an instance because Black doesn't implement the abstract method show
Black()

Create the first Black instance
Create the second Black instance
…
TypeError: Can't instantiate abstract class Black without an implementation for abstract method 'show'

Implement Python Abstract Classes and Abstract Methods

As described above, overriding an already defined Python abstract method or an abstract attribute that is essentially a method means that the abstract method or attribute is implemented. A Python abstract class is said to be implemented when all of its abstract methods and attributes are implemented.

from abc import ABCMeta, abstractmethod


class Plant(metaclass=ABCMeta):
	# Define the abstract method grow
	@abstractmethod
	def grow(self):
		print('Plant: Grow it!')


class Flower(Plant):
	# Override the abstract method grow to implement it
	@abstractmethod
	def grow(self):
		super().grow()


	# Define the abstract class method count
	@classmethod
	@abstractmethod
	def count(self):
		pass


class BigFlower(Flower):
	# Override the abstract method count to implement it
	@classmethod
	def count(self):
		print('How many are there?')


# Cannot create instances of Plant and Flower
BigFlower().grow()

Plant: Grow it!

Register Python Classes as Virtual Derived Classes that Don't Need to Implement Abstract Classes

Any Python abstract base class, or one of its derived classes, has a method named register that can be used to register an unrelated class as a virtual derived class of a Python abstract class. Unlike Python classes derived directly from an abstract class, a virtual derived class can be instantiated regardless of whether or not it already implements all of the abstract methods in the abstract class.

register(subclass)

subclass parameter

The subclass parameter is the class to be registered as a virtual derived class.

In addition, in Python 3.3 or later, the register method can be used as a class decorator to register a class as a virtual derived class of some Python abstract class. The syntax is @abstractclass.register, with abstractclass being an abstract class.

from abc import ABC, abstractmethod, get_cache_token


# Define the abstract base class Man
class Man(ABC):
	@abstractmethod
	def run(self):
		pass


# Register the classes Jerry and Tom as virtual derived classes and see how the token changes
print(f'The token is {get_cache_token()}')


@Man.register
class Jerry():
	pass


print(f'The token is {get_cache_token()}')


class Tom():
	def run(self):
		# ERROR Man is not in the MRO
		super().run()
Man.register(Tom)


print(f'The token is {get_cache_token()}')


# Jerry and Tom are considered derived classes
print(issubclass(Jerry, Man))
print(issubclass(Tom, Man))
# You can create an instance as normal
print(isinstance(Jerry(), Man))
print(isinstance(Tom(), Man))


Tom().run()

The token is 24
The token is 25
The token is 26
True
True
True
True
…
AttributeError: 'super' object has no attribute 'run'

__subclasshook__(subclass)

subclass parameter

The subclass parameter is the class that needs to be determined if it is a derived class.

from abc import ABC


class Unit(ABC):
	# None of the classes are derived from the Unit
	@classmethod
	def __subclasshook__(cls, subclass):
		print(f'Is {subclass} a derived class of Unit?')
		return False


class Player(Unit):
	pass


# View the relationship between Player and Unit
print(issubclass(Player, Unit))
print(isinstance(Player(), Unit))

Is <class '__main__.Player'> a derived class of Unit?
False
False

Source Code

src/en/classes/abstract·codebeatme/python·GitHub