Skip to main content

Abstract Classes in Python

 Abstract Classes in Python

            An abstract class can be considered as a blueprint for other classes. It allows you to create a set of methods that must be created within any child classes built from the abstract class. 

 A class which contains one or more abstract methods is called an abstract class.

 An abstract method is a method that has a declaration but does not have an implementation.

 While we are designing large functional units we use an abstract class. When we want to provide a common interface for different implementations of a component, we use an abstract class. 

Abstract Class Example:


from abc import *

class Demo:
  
     @abstractmethod
      def m1(self):
           pass


The above example has one abstract method, so it is considered as abstract class.

The Abstract class concept can  also be done in python by inheriting the base class ABC(Abstract Base Class):



from abc import *

class Student(ABC):
  pass

stud1 = Student()


When an incomplete method is written in above code and when we try to create an instance of the class Student.We may face some errors.

for eg:

from abc import *
class Student(ABC):
  @abstractmethod
  def m1(self):
    pass

stud1 = Student()  


Output:

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-28-57b67a37b54d> in <module>()
      5     pass
      6 
----> 7 stud1 = Student()

TypeError:
 Can't instantiate abstract class Student with 
abstract methods m1



Whenever we inhereited ABC base class and leaving the incomplete
abstract method untouched it throws an error.

To over come this , We can directly use abstract method without
extending baseclass(example 1 below) or
we can use that abstract method in some other class(Example 2 below).

Example 1:

from abc import *
class Student():
  @abstractmethod
  def m1(self):
    print('hi hello')

stud1 = Student()  

stud1.m1() #hi hello

Example 2:


from abc import *
class Student(ABC):

  @abstractmethod

  def m1(self):
    pass

class A_student(Student):
    def m1(self):
        print("Student from A Section")



class B_student(Student):
    def m1(self):
        print("Student from B Section")

studA =  A_student()
studB=   B_student()

studA.m1() #Student from A Section
studB.m1() #Student from B Section










Comments

Popular posts from this blog

Is-A and Has-A relationships in python

  In object-oriented programming, the concept of IS-A is a totally based on Inheritance, which can be of two types Class Inheritance or Interface Inheritance. It is just like saying "A is a B type of thing". For example, Apple is a Fruit, Car is a Vehicle etc. Inheritance is uni-directional. For example, House is a Building. But Building is not a House. #Is-A relationship --> By Inheritance class  A:    def   __init__ ( self ):      self .b= 10    def   mym1 ( self ):      print ( 'Parent method' ) class  B(A):    def   mym2 ( self ):      print ( 'Child method' ) d = B() d.mym1() #output: Parent method d.mym2() #output: Child method HAS-A Relationship:  Composition(HAS-A) simply mean the use of instance variables that are references to other objects. For example Maruti has Engine, or House has Bathroom. Let’s understand...

Magic Methods in Python

  What Are Dunder Methods ? In Python, special methods are a set of predefined methods you can use to enrich your classes.  They are easy to recognize because they start and end with double underscores, for example  __init__  or  __str__ . Dunder methods let you emulate the behavior of built-in types.  For example, to get the length of a string you can call  len('string') . But an empty class definition doesn’t support this behavior out of the box: These “dunders” or “special methods” in Python are also sometimes called “magic methods.” class NoLenSupport : pass >>> obj = NoLenSupport () >>> len ( obj ) TypeError : "object of type 'NoLenSupport' has no len()" To fix this, you can add a  __len__  dunder method to your class: class LenSupport : def __len__ ( self ): return 42 >>> obj = LenSupport () >>> len ( obj ) 42 Object Initialization:  __init__ "__init __ ...

Inheritance and Types in Python

  Inheritance   Creating a new class from existing class is known as inheritance . The class from which features are inherited is known as base class and the class into which features are derived into is called derived class . Syntax: class  derived- class (base  class ):       < class -suite>      Inheritance promotes reusability of code by reusing already existing classes.  Inheritance is used to implement  is-a  relationship between classes.   Following hierarchy is an example representing inheritance between classes:   Single inheritance   When a derived class inherits only from syntax, the base class is called single inheritance. If it has one base class and one derived class it is called single inheritance.   Diagram     Syntax class  A:  #parent class         #some code       class  b(A):...