Simplified O.O.P : Abstraction in Python

Introduction

In earlier submit , Simplified: Object-oriented Programming Python, I promised to get into particulars on abstraction. The belief for this submit is you might be proficient with python . In case you are beginning , begin right here

On this article, we’re going to dive deep on Abstraction in Python. Under is an outline of this submit:

• Definition and significance of Abstraction
• Software of abstraction
• Summary Courses and Strategies
• Abstract

Definition of abstraction

Earlier than stepping into technical definition of abstraction ,let’s first outline it with easier and relatable instance. take into account your T.V distant, the ‘+’ button ,which is used to extend the amount .You should utilize the button however you can not see how operations are carried out. It is a excellent instance of abstraction.

Now what’s Abstraction in technical time period ? In Python, information abstraction might be outlined as ,hiding all of the irrelevant information/technique of an utility in an effort to scale back complexity and improve the effectivity of this system.

Software of Abstraction

Knowledge abstraction has been wholly been applied in Django framework(Assumption you’ve got primary expertise with django).
When making a mannequin , take an instance of Pupil mannequin:

from django import fashions

class pupil(fashions.Mannequin):
   first_name= fashions.CharField(max_length=100, clean=True,null=True)
   last_name= fashions.CharField(max_length=100, clean=True,null=True)
   def __str__(self):
       return self.first_name + "" + self.last_name

It is a excellent instance of utility of abstraction in fixing real-world downside. class mannequin inherited from guarantee uniformity in definition of a mannequin. As we progress , you will note the implications of not following the set of instruction supplied within the information abstracted.

Summary Courses and Strategies

Summary Class is a category created as a blueprint of an object that may be inherited to create new objects, whereas summary technique is a technique that’s declared, however doesn’t include implementation. An summary technique in a base class identifies the performance that needs to be applied by all its subclasses.

implementation
To declare an Summary class, we firstly have to import the abc module. Allow us to take a look at an instance.

from abc import ABC
class payment_class(ABC):
     #summary strategies goes beneath

Now lets implement an entire summary class with strategies

from abc import ABC
class payment_class(ABC):
     #summary strategies
    @abstractmethod 
    def send_money(self):
         go
   @abstractmethod 
   def withdraw_money(self):
        go

Aside from summary technique, an summary class can also have a way and each time an summary class is inherited it will be known as and run.
Let’s create a working instance:

#Part 1
from abc import ABC,abstractmethod
class payment_class(ABC):
  def welcome_text(self,x):
    print(f'Welcome to {x}')
  #summary strategies
  @abstractmethod 
  def send_money(self):
    go
  @abstractmethod 
  def withdraw_money(self):
    go
#Part 2
# Create fee service 
class Terminal_pay(payment_class):
  def __init__(self,whole,tax,quantity,sendcharges,fee,steadiness=0):
    self.quantity = quantity
    self.sendcharges = sendcharges
    self.fee = fee
    self.tax = tax
    self.steadiness = steadiness
    self.whole = self.tax + self.fee + self.quantity + self.sendcharges
  def send_money(self):
    self.steadiness = self.steadiness - self.whole
    print(f'Ship USD. {self.quantity} at USD. {self.sendcharges} fee charged USD.{self.fee} give USD. {self.whole}.Your steadiness is USD. {self.steadiness}')
  def withdraw_money(self):
    self.steadiness = self.steadiness - self.whole
    print(f'USD.{self.quantity} withdrawn at {self.sendcharges} give {self.whole}')

safariPay = Terminal_pay(whole=0,tax=16,sendcharges=10,fee=10,quantity=200)
safariPay.welcome_text("safariPay")
safariPay.send_money()

Output:
Welcome to safariPay
Ship USD. 200 at USD.10 fee charged USD.10 give USD.236.Your steadiness is USD.-236

Clarification

On this instance(Divided into two sections), Part 1 is importing ABC,abstractmethod from abc module, declaration of Summary Base Class with a generic technique that has an argument X declared and an Summary strategies : send_money,withdraw_money.

In part 2, We create a fee service that inherits from the payment_class Summary Base class. The payment_class we create a constructor and what follows is definition of the strategies:withdraw_money,send_money and lastly we instantiate the Terminal_class.

Observe me for extra replace