• Introduction
• What is abstraction?
• What does abstraction look like in code?
• Using abstract methods with parameters
• Abstract Properties

In the previous article, where we talked about class encapsulation, I talked about the need that some programmers may have to hide their code from malicious users who want to modify it.

Well now, we continue with the purpose of hiding code, only for different reasons. Now, we will seek to hide code from our users to reduce the complexity of their experience, allowing them to see what the program does, but not how it does it.

This is where the concept of abstraction comes in, which will allow us to not only create a less complex program for the user, but also increase the program's efficiency.

That said,

In object-oriented programming, abstraction is used to hide the basics of a function or method from the user. Thus the user will only see the method's functionality (what it can do) but will still not know the internal details of the definition.

But, how is this done?

In classes, we must create the method initially, just defining it and placing no value for its implementation, just a pass. Then, when creating child classes, we can assign the implementation as it best suits our needs.

Looking at an example for the sound of different animals, we will create a class with an abstract method for the sound. The child classes will be the animals; according to these, the sound varies by means of the methods.

Thus, we can see that abstraction takes place, where the abstract method of the parent class is redefined to be implemented in the child classes. In this way, we hide the non-relevant information of the parent class and take the function definition and apply it to our purposes.

We know how this works in principle but what does this look like in code?

Since we can consider an abstract class to be any class that contains one or more abstract methods, we can assume that defining the class and the method will be enough. However, before doing this we must import the ABC or Abstract Base Classes module (we will talk more about modules in the future).

from abc import ABC

By means of ABC, which is a class in Itself, we will be able to inherit the characteristics that allow us to create abstract methods. Then, the syntax will be the following:

class ExampleClass(ABC):
     def abstractmethod(self):
        pass

With this, we will have defined the class and the abstract method. However, for the abstraction to be complete, it will need to be implemented in different ways for each child class:

from abc import ABC

class ExampleClass(ABC):
     def abstractmethod(self):
        pass

class ChildClass1(ExampleClass):
    def abstractmethod(self):
        print('Abstract method implementation 1')

class ChildClass2(ExampleClass):
     def abstractmethod(self):
        print('Abstract method implementation 2')

Now, if we create objects and call the method:

object_1 = ChildClass1()
object_2 = ChildClass2()

object_1.abstractmethod()
object_2.abstractmethod()

>>>
Abstract method implementation 1
Abstract method implementation2

This is one way to do it. However, the best practice will always be to use the @abstractmethod decorator (more about decorators in upcoming articles), allowing us to assign which methods will be abstract. First, we must import abstractmethod from the abc library and then apply the decorator to our method:

from abc import ABC, abstractmethod

class ExampleClass(ABC):

    @abstractmethod
    def abstractmethod(self):
        pass

class ChildClass1(ExampleClass):
    def abstractmethod(self):
        print('Abstract method implementation 1')

class ChildClass2(ExampleClass):
    def abstractmethod(self):
        print('Abstract method implementation 2')

object_1 = ChildClass1()
object_2 = ChildClass2()

object_1.abstractmethod()
object_2.abstractmethod()

Thus, we would get the same result.

Abstract method implementation 1
Abstract method implementation 2

Whenever we create an object to use an abstract method, we must be sure to use the child classes and give an implementation to the methods. In case we try to create an object for the parent class and try to invoke the method, we will get the following error:

TypeError: Can't instantiate abstract class ExampleClass with abstract method abstractmethod

If we want to create abstract methods containing parameters, we use the abstractmethod decorator, where, when we define the function, we add a parameter. For example:

class Plane(ABC):
   @abstractmethod
   def Flight(self,hour):
       pass

class Plane1(Plane):
    def Flight(self,hour):
        print(f "The flight left at {hour}")

US_Canada = Plane1()
US_Canada.Flight('12:00 am')

Here, we can see that it is as easy as adding a parameter to the abstract method and redefining using the same format to achieve the result we want. Now, what if we want to use abstract attributes as well?

Sometimes, in addition to methods, we want to use abstract properties in order to contribute to the efficiency and comprehension of the program. To do this, in addition to the @abstractmethod decorator we use @property to define a method that represents the attribute in the parent class. For example:

class Career(ABC):
    @abstractmethod
    def __init__(self,title):
        self._title = title

    @property
    @abstractmethod
    def title(self):
        pass

    @title.setter
    @abstractmethod
    def title(self,value):
        pass

This will be the parent class, where if we go back to the protected classes, the Getter and Setter, concepts that we observed in this article, we can notice that using the decorators we create a property with abstract method, which will refer to the title.

When we use @property, we define the title method, with which we will return the value of the attribute in the child function, as well as a setter, which will allow us to verify if the encapsulation is being carried out.

Thus, when creating a derived or child class:

class Engineer(Career):
    def __init__(self,title):
        self._title = title

    @property
    def title(self):
        return self._title

    @title.setter
    def name(self,value):
        self._title = value

Thus, when creating a derived or child class:

class Engineer(Career):
    def __init__(self,title):
        self._title = title

    @property
    def title(self):
        return self._title

    @title.setter
    def name(self,value):
        self._title = value

Where we finally implement the property, returning the value of the private attribute title. Finally, by using the setter we make sure that the property works by setting the parameter value to _title.

This way, when creating an object of the derived class:

Electronic = Engineer('Electronics Engineer')
print(Electronic.title)
   
>>> Electronics Engineer     

And so we will apply abstraction with properties.

Abstraction is a very useful tool when it comes to hiding information that is not useful or too complex for the user to understand. Now, with this knowledge, you will be able to control the user experience at will.

We are almost done with the key concepts of object-oriented programming, which is why we will see some exercises in order to put the acquired knowledge into practice. All in future editions of Coding Basics ;)

from abc import ABC

class ExampleClass(ABC):
     def abstractmethod(self):
        pass

from abc import ABC

class ExampleClass(ABC):
     def abstractmethod(self):
        pass

class ChildClass1(ExampleClass):
    def abstractmethod(self):
        print('Abstract method implementation 1')

class ChildClass2(ExampleClass):
     def abstractmethod(self):
        print('Abstract method implementation 2')

object_1 = ChildClass1()
object_2 = ChildClass2()

object_1.abstractmethod()
object_2.abstractmethod()

>>>
Abstract method implementation 1
Abstract method implementation2

class ExampleClass(ABC):

    @abstractmethod
    def abstractmethod(self):
        pass

class ChildClass1(ExampleClass):
    def abstractmethod(self):
        print('Abstract method implementation 1')

class ChildClass2(ExampleClass):
    def abstractmethod(self):
        print('Abstract method implementation 2')

object_1 = ChildClass1()
object_2 = ChildClass2()

object_1.abstractmethod()
object_2.abstractmethod()

Abstract method implementation 1
Abstract method implementation 2

TypeError: Can't instantiate abstract class ExampleClass with 

abstract method abstractmethod

class Plane(ABC):
   @abstractmethod
   def Flight(self,hour):
       pass

class Plane1(Plane):
    def Flight(self,hour):
        print(f"The flight left at {hour}")

US_Canada = Plane1()
US_Canada.Flight('12:00 am')

class Career(ABC):
    @abstractmethod
    def __init__(self,title):
        self._title = title

    @property
    @abstractmethod
    def title(self):
        pass

    @title.setter
    @abstractmethod
    def title(self,value):
        pass

class Engineer(Career):
    def __init__(self,title):
        self._title = title

    @property
    def title(self):
        return self._title

    @title.setter
    def name(self,value):
        self._title = value

Electronic = Engineer('Electronics Engineer')
print(Electronic.title)
   
>>> Electronics Engineer