Introduction
In previous post , Simplified: Object-oriented Programming Python, I promised to get into details on abstraction. The assumption for this post is you are proficient with python . If you are starting , start here
In this article, we are going to dive deep on Abstraction in Python. Below is an overview of this post:
- Definition and importance of Abstraction
- Application of abstraction
- Abstract Classes and Methods
- Summary
Definition of abstraction
Before getting into technical definition of abstraction ,let's first define it with simpler and relatable example. consider your T.V remote, the '+' button ,which is used to increase the volume .You can use the button but you cannot see how operations are carried out. This is a perfect example of abstraction.
Now what is Abstraction in technical term ? In Python, data abstraction can be defined as ,hiding all the irrelevant data/process of an application in order to reduce complexity and increase the efficiency of the program.
Application of Abstraction
Data abstraction has been wholly been implemented in Django framework(Assumption you have basic experience with django).
When creating a model , take an example of Student model:
from django import models
class student(models.Model):
first_name= models.CharField(max_length=100, blank=True,null=True)
last_name= models.CharField(max_length=100, blank=True,null=True)
def __str__(self):
return self.first_name + "" + self.last_name
This is a perfect example of application of abstraction in solving real-world problem. class model inherited from ensure uniformity in definition of a model. As we progress , you will see the consequences of not following the set of instruction provided in the data abstracted.
Abstract Classes and Methods
Abstract Class is a class created as a blueprint of an object that can be inherited to create new objects, whereas abstract method is a method that is declared, but does not contain implementation. An abstract method in a base class identifies the functionality that should be implemented by all its subclasses.
implementation
To declare an Abstract class, we firstly need to import the abc module. Let us look at an example.
from abc import ABC
class payment_class(ABC):
#abstract methods goes below
Now lets implement a complete abstract class with methods
from abc import ABC
class payment_class(ABC):
#abstract methods
@abstractmethod
def send_money(self):
pass
@abstractmethod
def withdraw_money(self):
pass
Apart from abstract method, an abstract class also can have a method and every time an abstract class is inherited it would be called and run.
Let's create a working example:
#Section 1
from abc import ABC,abstractmethod
class payment_class(ABC):
def welcome_text(self,x):
print(f'Welcome to {x}')
#abstract methods
@abstractmethod
def send_money(self):
pass
@abstractmethod
def withdraw_money(self):
pass
#Section 2
# Create payment service
class Terminal_pay(payment_class):
def __init__(self,total,tax,amount,sendcharges,commission,balance=0):
self.amount = amount
self.sendcharges = sendcharges
self.commission = commission
self.tax = tax
self.balance = balance
self.total = self.tax + self.commission + self.amount + self.sendcharges
def send_money(self):
self.balance = self.balance - self.total
print(f'Send USD. {self.amount} at USD. {self.sendcharges} commission charged USD.{self.commission} give USD. {self.total}.Your balance is USD. {self.balance}')
def withdraw_money(self):
self.balance = self.balance - self.total
print(f'USD.{self.amount} withdrawn at {self.sendcharges} give {self.total}')
safariPay = Terminal_pay(total=0,tax=16,sendcharges=10,commission=10,amount=200)
safariPay.welcome_text("safariPay")
safariPay.send_money()
Output:
Welcome to safariPay
Send USD. 200 at USD.10 commission charged USD.10 give USD.236.Your balance is USD.-236
Explanation
In this example(Divided into two sections), Section 1 is importing ABC,abstractmethod from abc module, declaration of Abstract Base Class with a generic method that has an argument X declared and an Abstract methods : send_money,withdraw_money.
In section 2, We create a payment service that inherits from the payment_class Abstract Base class. The payment_class we create a constructor and what follows is definition of the methods:withdraw_money,send_money and lastly we instantiate the Terminal_class.
Follow me for more update
Top comments (0)