Python : OOPS important Concepts

Python: OOPS important Concepts
static and class method
'''static method : 
1.cannot access any properties
2. Can have no parameters at all.
Class method: 
1) Similar to static method but can use class properties .
2) Must have a reference to a class object as the first parameter’’’
class stat_test():

    var="private" #properties

    def method(self):

        return ("normal method")  

    @staticmethod

    def static_method(self):

            return(self.var)    

    @classmethod

    def class_method(self):

           return(self.var)

            

print(stat_test().method())   

#print(stat_test.static_method()) #error

print(stat_test.class_method())

print("#========#Access Modifiers(Encapsulation) DUNDEE =======")
private: "__" at the beginning and at most “_” at end
protected: "_" at the beginning and at most “_” at end (Convention only)
Restricted": "__a__" at beginning and at end
E.g.: print ("adasdsa".__len__()) #__name__ = inbuilt functions
'''
class a:

    pubv="pub"

    _prov="pro"

    __priv="priv"   

    def __init__(self):

        pass

    def pubm(self):

        return(self.pubv)

    def _prom(self):

        return(self._prov)      

    def __prim(self):

        return(self.__priv)         

 

class b(a):

    def __init__(self):

        pass 

    def priv(self):

        return(self.__priv)    

    def prov(self):

        return(self._prov)              

    def prim(self):

        return(self.__privm())

    def prom(self):

        return(self._prom())

    def pubm(self):

        return(super().pubm())

A=a()       

print(A.pubv,A._prov)

#print(A.__priv) # Error

print(A.pubm(),A._prom())

#print(A.__prim()) # Error

B=b()

#print(B.priv()) # Error

print(B.prov())

#print(B.prim()) # error

print(B.prom())
print("#====Constructor/Method Overriding and Inheritance===")
#Note : Overloading does not exist in python , only overriding exist

class Bird():

    name=None

    def __init__(self,name):

        self.name=name

    def bird_name(self):

        return(self.name)

    def fly(self):

        return("True")

class non_fly(Bird):

    swim=None

    def __init__(self,name,swim):        #Constr overriding

        super().__init__(name)              #call parent constr

       #  Bird.__init__(self, name) 

        self.swim=swim

   def swim(self):

        print(self.bird_name(),self.swim) #Method inheritance

    def fly(self):                                                  #Method Overrdiing

        return("false")

peng=non_fly("peng",True)

print(peng.bird_name(),peng.fly(),peng.swim)#inheritance
#O/P: peng false True
print("#==========#polymorphism===================")
#Polymorphism (Duck Typing)
'''In a duck-typed language (if it looks like a duck and quacks like a duck, it's a duck)
If the object  have the methods, then execute  else it raises a run-time error.’’’
class Duck():
   def quack(self):
      print ("Duck Quack")

class Mallard():
    def quack(self):
        print ("Mallard Quack")

#Polymorphism
for i in [Duck(), Mallard()]:
   i.quack()
print("#=============Abstract Class ==========")

#( At least 1 method is abstract,entire class = abstract class)
from abc import ABC, abstractmethod
class Abstract(ABC):
    @abstractmethod
    def foo(self):
        pass
#a=Abstract()#uncomment below to raise exception 
print("#=========Diamond problem============")
class Duck():
   def quack(self):
      print ("Duck Quack")
class Mallard():
    def quack(self):
        print ("Mallard Quack")

class c(Duck,Mallard):

                  def c(self):

                                    super().quack()

print(c().c()) #O/p = Duck Quack (as Duck appears 1^st)

print("#=========super vs self vs class name============")
super()

1.  Used inside child constructor to call parent constructor

2.  Used inside overriding method to call the parent method

self

1. Used to call method and properties of the same class

2. Used to call methods and properties of parent class

3. Cannot be used inside overriding constructor or method as it creates infinite loop.

className

1. Can be used to call properties and methods of parent class.

2. Parent class name needs to be hardcoded

3. "self" needs to be sent as an arguement.

print(#=========multiple inheritance============")

class a():

    x="1"

    def a(self):

        return("2")

class b():

    y="3"

    def b(self):

        return("4") 

class c(a,b):

    z="5"

    def c(self):

        print(self.x,self.y,self.z,self.a(),self.b())

C=c()

C.c()

print(C.x,C.y,C.a(),C.b())