#polymorphism >> poly means many and morphism means forms/states

#refers to an object taking several forms depending on the

methods/data

len("Ajay")

len([1, 2, 3, 4, 5])

len((1, 2))

def func(a, b):

return a+b

func(2, 3) #same + adding two numbers

func("pw", "skills") #same +, combining two strings

'pwskills'

func([1, 2, 3], [4, 5, 6]) #the list concatenation

[1, 2, 3, 4, 5, 6]

#observation>> func is taking different forms with respect to

different data passed

class teacher_lecture:
def lec_info(self):
print("This is lec info with teacher perspective")
class student_lecture:
def lec_info(self):
print("This is lec info with student perspective")

obj1 = teacher_lecture()
obj2 = student_lecture()
class_obj = [obj1, obj2]

def parcer(class_obj):
for i in class_obj:
i.lec_info() #at this point, lec_info is taking two forms wrt
techer and students

parcer(class_obj)
This is lec info with teacher perspective
This is lec info with student perspective

#Polymorphism in OOPS takes places in two ways:

#Method overloading >> python doesnt support true method overloading
#Method overriding

#method overloading

class Student:
def student(self):
print("Wecome to pwskills class")
def student(self, name = ""):
print("Wecome to pwskills class", name)
def student(self, name = "", course = ""):
print("Wecome to pwskills class", name, course)

stud = Student()

stud.student()

Wecome to pwskills class

stud.student("Ajay")

Wecome to pwskills class Ajay

stud.student("Ajay", "DS")

Wecome to pwskills class Ajay DS

#method overloading >> student method is taking different forms, the

last methods overloads the previous ones in the same class
class Student:
def student(self, name = "", course = ""):
print("Wecome to pwskills class", name, course)

stud = Student()
stud.student()

Wecome to pwskills class

stud.student("Ajay")

Wecome to pwskills class Ajay

stud.student("Ajay", "DS")

Wecome to pwskills class Ajay DS

#method overloading happens in the same class

#method overriding >> method in parent class and child class with same
signature, the child class method will be executed

class Animal:
def sound(self):
print("Animal Sound")
class Cat(Animal):
def sound(self):
print("cat meows")

anm = Animal()

anm.sound() #Animal class

Animal Sound

cat = Cat()
cat.sound() #cat class

cat meows

#Encapsulation>> means hiding something

#bundling of data and methods of a class
#access modifier>>public, protected, private

#public>>accessible from anywhere from outside/inside of class

class Student:
def __init__(self, name, degree):
self.name = name
self.degree = degree

stud1 = Student("Ram", "Masters")

stud1.name

'Ram'

stud1.degree

'Masters'

stud2 = Student("Sam", "Bach")

stud2.degree

'Bach'

stud2.degree = "Phd"

stud2.degree

'Phd'
#accessing the public data member inside the other method of same
class
class Student:
def __init__(self, name, degree):
self.name = name
self.degree = degree

def show(self):
#accessing the public data member
print("name", self.name, 'degree', self.degree)

aj = Student("Ajay", "Masters")

aj.show()

name Ajay degree Masters

aj.name

'Ajay'

aj.degree

'Masters'

#private >> the data and method is only accessible within its class,
use __ to make private

class Student:
def __init__(self, name, degree):
self.name = name
self.__degree = degree #private data

def show(self):
#accessing the private data member
print("name", self.name, 'degree', self.__degree)

aj = Student("Ajay", "Masters")

aj.name

'Ajay'

aj.show()

name Ajay degree Masters

aj.degree #it will throw an error as degree is now private data

----------------------------------------------------------------------
-----
AttributeError Traceback (most recent call
last)
Cell In[67], line 1
----> 1 aj.degree #it will throw an error as degree is now private
data

AttributeError: 'Student' object has no attribute 'degree'

aj.__degree #it will throw an error as degree is now private data

----------------------------------------------------------------------
-----
AttributeError Traceback (most recent call
last)
Cell In[68], line 1
----> 1 aj.__degree #it will throw an error as degree is now private
data

AttributeError: 'Student' object has no attribute '__degree'

aj._Student__degree #say you want to access the private variable using

class name

'Masters'

#a method private

class Student:
def __init__(self, name, degree):
self.name = name
self.__degree = degree #private data

def show(self):
#accessing the private data member
print("name", self.name, 'degree', self.__degree)

def __private_method(self):
print("This is a private method")

obj1 = Student("Ajay", "Masters")

obj1.private_method() #throw an error

----------------------------------------------------------------------
-----
AttributeError Traceback (most recent call
last)
Cell In[72], line 1
----> 1 obj1.private_method()

AttributeError: 'Student' object has no attribute 'private_method'

obj1.__private_method() #throw an error

----------------------------------------------------------------------
-----
AttributeError Traceback (most recent call
last)
Cell In[73], line 1
----> 1 obj1.__private_method() #throw an error

AttributeError: 'Student' object has no attribute '__private_method'

obj1._Student__private_method() #accesing private method using class

name

This is a private method

#way to provide an option to see the private method>> a wrapper

class Student:
def __init__(self, name, degree):
self.name = name
self.__degree = degree #private data

def show(self):
#accessing the private data member
print("name", self.name, 'degree', self.__degree)

def __private_method(self):
print("This is a private method")

def access_private_method(self):
self.__private_method()

obj1 = Student("AJ", "Masters")

obj1.access_private_method()

This is a private method

#another use case of modifying the private variable and accessing it

class Car:
def __init__(self, year, make, speed, model):
self.__year = year
self.__make = make
self.__speed = speed
self.__model = model

c1 = Car("1995", "Maruti", "80", "Brezza")

c1.year #since all variables are private, it will throw an error

----------------------------------------------------------------------
-----
AttributeError Traceback (most recent call
last)
Cell In[79], line 2
1 c1 = Car("1995", "Maruti", "80", "Brezza")
----> 2 c1.year

AttributeError: 'Car' object has no attribute 'year'

class Car:
def __init__(self, year, make, speed, model):
self.__year = year
self.__make = make
self.__speed = speed
self.__model = model
def set_speed(self, speed):
self.__speed = 0 if speed < 0 else speed
def get_speed(self):
return self.__speed

c1 = Car("1995", "Maruti", "80", "Brezza")

c1.get_speed()

'80'

c1.set_speed(-1000)

c1.get_speed()

c1.set_speed(100)

c1.get_speed()

100

#anaother use case

class Bank: #either you deposit or withdraw

def __init__(self, balance):

self.__balance = balance

def deposit(self, amount): #amount is new deposition

self.__balance = self.__balance + amount

def withdraw(self, amount):

if self.__balance >= amount:
self.__balance = self.__balance - amount
return True
else:
return False
 def get_balance(self):
return self.__balance

acc1 = Bank(1000)

acc1.get_balance()

1000

acc1.deposit(500)

acc1.get_balance()

1500

acc1.withdraw(100)

True

acc1.get_balance()

1400

acc1.withdraw(1500)

False

#protected>> within the class and its subclass, protected member can
be access, (_)

class College:
def __init__(self):
self._college_name = "PWSkills"
class Student(College):
def __init__(self, name):
self.name = name
College.__init__(self) #accesing variable of base
class>>classname__init__(self)

def show(self):
print("name", self.name, "college", self._college_name)
#directly call the base class variable using "_"

stud = Student("Ajay")

stud.name

'Ajay'

stud.show()

name Ajay college PWSkills

coll = College()
coll._college_name #accessing the protected variable

'PWSkills'

#anothe rway to access the data of base class using super()