Public, Protected and Private members:
- Access modifiers
- It is straight forward in c++ , Java - done using the keywords as public, protected,
private
- There is no direct way or keyword available in python for this purpose, yet its
possible using the convention methods.
- Public
- All member variables and methods are public by default.
- Can access class attributes and modify their values outside
class Employee:
def __init__(self, name, sal):
self.name = name
self.salary = sal
e1 = Employee("Aman", 10000)
print("Before Salary ", e1.salary)
e1.salary = 20000
print("After Salary ", e1.salary)
- Protected
- Standard meaning of protected is, class attributes are accessible within
class and its subclasses
- Prefixing single underscore ” _ ” to instance variables is a way of telling
that these are protected and not for accessing outside the class
- Although they can be modified outside as in the below examples shown
(Hence, the responsible programmer would refrain from accessing and
modifying instance variables prefixed with _ from outside its class)
class Employee:
def __init__(self, name, sal):
self._name = name
self._salary = sal
e1 = Employee("Aman", 10000)
print("Before Salary ", e1._salary)
e1._salary = 30000
print("After Salary ", e1._salary)
23
- Private
- Cant be accessed out side the class
class Employee:
def __init__(self, name, sal):
self.__name = name
self.__salary = sal
e1 = Employee("Aman", 10000)
print("Before Salary ", e1.__salary)
On executing above program…
AttributeError: 'Employee' object has no attribute '__salary'
- Python supports a technique called name mangling. Python performs name
mangling of private variables. Every member with double underscore will be
changed to object._ClassName__variable. If so required, it can still be accessed
from outside the class, but the practice should be refrained as shown below-
print("Before Salary ", e1._Employee__salary)
vars() and dir() built-in functions
- vars() returns dictionary of attributes and their values. It can be applied to class
and objects. When used with objects, returns class attributes and recursively
attributes of classes base class.
- dir() returns list of attributes. It can be applied to class and objects as well. When
used with objects, returns a list of objects attributes and objects class attributes
abd recursively attributes of its classes base class.
24
Python Intricacies:
- Below is an example of calling a class method from another class. Observe the
program and its output-
def display_all(): #global function
print("Inside Display All")
class Employee:
def __init__(self, n='',a=0, s=0): #instance method
self.__name = n
self.__age = a
self.__salary = s
def display_data(self): #instance method
print("Inside Employee display data")
print(self.__name, self.__age, self.__salary)
d1 = Department("CS",101)
d1.display_data() #calling a instance method of a class from
another class
print(Department.sample()) #calling a class method from another class
display_all() #calling global function
class Department:
def __init__(self, t, n): #instance method
self.__title = t
self.__id = n
def display_data(self): #instance method
print("Inside Department display data")
print(self.__title, self.__id)
def sample(): # class method
print("Inside Department sample")
# display_data() # will throw an error
e1 = Employee("Aman", 25, 30000)
e1.display_data()
25
Output of above code is below-
Inside Employee display data
Aman 25 30000
Inside Department display data
CS 101
Inside Department sample
None
Inside Display All
Static Method
- These methods are bound to the class not to the object
- Its is similar to class methods (not instance method) but unlike class
methods, it has nothing to do with class and deals with the parameters
passed to it.
- They can be called using staticmethodFunc()
- Used to group utility functions, to perform a task in isolation
class Mathematics:
def addNumbers(x, y):
return x + y
# create addNumbers static method
Mathematics.addNumbers = staticmethod(Mathematics.addNumbers)
print('The sum is:', Mathematics.addNumbers(5, 10))
- Another way of creating static methods is given below
class Dates:
def __init__(self, date):
self.date = date
def getDate(self):
return self.date
26
@staticmethod
def toDashDate(date):
return date.replace("/", "-")
date = Dates("15-12-2016")
dateFromDB = "15/12/2016"
dateWithDash = Dates.toDashDate(dateFromDB)
if(date.getDate() == dateWithDash):
print("Equal")
else:
print("Unequal")
- @staticmethod decorator, It is an expression that gets evaluated after our
function is defined.
Advantage of static methods-
- Less memory consumption, since in case of an instance method no of coppes of
the method will be equal to number of object.
- Utility functions
- Redability
Operator Overloading-
- Changing meaning of operators
- Depending upon the operands how the operator can behave is defined using
operator overloading techniques.
- So the meaning of operator for user defined data types can be defined.
- Special functions in python are used ( funcition which starts and ends with __ i.e.
a double underscore. ) Read more about the special functions here -
https://docs.python.org/3/reference/datamodel.html#special-method-names
Operators that can be overload in python are -
27
Operator Special function Operator Special function
+ __add__(self, other) < __lt__(self, other)
- __sub__(self, other) > __gt__(self, other)
* __mul__(self, other) <= __le__(self, other)
/ __truediv__(self, other) >= __ge__(self, other)
% __mod__(self, other) == __eq__(self, other)
** __pow__(self, other) != __ne__(self, other)
// __floordiv__(self, other)
Example of operator overloading is below-
class Point:
def __init__(self, x=0,y=0):
self.__x = x
self.__y = y
def display_points(self):
print("Points are: ", self.__x, self.__y)
# def __add__(self, other):
# return self.__x + other.__x, self.__y + other.__y
p1 = Point(2,3)
p1.display_points()
p2 = Point(5,5)
p2.display_points()
print("Combining points are: ", p1 + p2)
Output of the above code is here-
Points are: 2 3
Points are: 5 5
28
Traceback (most recent call last):
File "/Users/mspangtey/Downloads/DSEU 2022/Odd Sem Python/Python
Programs/operator_overloading.py", line 19, in <module>
print("Combining points are: ", p1 + p2)
TypeError: unsupported operand type(s) for +: 'Point' and 'Point'
On un commenting the __add__(self, other) method the output is-
Points are: 2 3
Points are: 5 5
Combining points are: (7, 8)
Code Reuse-
- Reusing the existing code
- Two mechanisms available to do so-
- Containership or Composition
- Used when two classes have a ‘has a’ relationship
Example:
class Department:
def __init__(self,n='',id=0):
self.__name = n
self.__id = id
def display_department(self):
print("Department id is {} and Name is {}".format(self.__id,
self.__name))
class Employee:
def __init__(self, n='', eid= 0):
self.__name = n
self.__eid = eid
self.d_obj = Department('ECE', 28)
def display_employee(self):
print("Employee Name is {}, id is {}".format(self.__name, self.__eid))
29
self.d_obj.display_department()
# print("Employee Name is {}, id is {}, Department is {} and
department id is {}".format(self.__name, self.__eid,
self.d_obj._Department__name, self.d_obj._Department__id))
e1 = Employee("Aman", 101)
e1.display_employee()
- Inheritance
- Used when two classes have a ‘like a’ relationship
- Derived Class can inherit features of Base Class
- Base class is also known as super-class or parent class
- Derived class is also known as subclass or child class
- Derived class object contains all base class data
- Derived class members can access base class members but vice
versa is not true.
- Convention for accessing variables
- var: access anywhere
- _var: access within class and derived class
- __var: access only within class
- Violating the conventions do not throw an error, for for good
practice it should follow the convention
- Accessing __var outside the class is not straight forward like
objectName.__var. This will give error. This is because variable
name gets mangled. So to access such variables the variable is
renames as _ClassName__var. Here ClassName is the class which
contains __var.
Example 1:
- Subclass Sparrow class inherits base class Bird.
- Derived class object can access all the methods of base class.
Example is speak method speak().
- The derived objects first find the speak method in Sparrow class,
once it doesnt find it here it searches the method in the base class.
class Bird:
def speak(self):
30
print("Inside Bird: Speak")
class Sparrow(Bird):
def sing(self):
print("Inside sparrow: sing")
s1 = Sparrow()
s1.sing()
s1.speak()
Output of above sample code:
Inside sparrow: sing
Inside Bird: Speak
Example 2:
- __init__ method is defined in both derived as well as in the base
class.
- In such cases, the derived class method overrides that in the base
class. Or __init__ of derived class has preference over base class
__init__.
- In order to call the base class init method, syntax is
super().__init__(3) or Polygon.__init__(self, 3) .
- super().__init__() should be used in case only one Class is
inherited. ClassName.__init__(self) should be used to call specific
inherited class.
class Polygon:
def __init__(self, n):
self.noOfSides = n
sides = [0 for i in range(self.noOfSides)]
def inputSides(self):
self.sides = [float(input("Enter side "+ str(i+1) + " : ")) for
i in range(self.noOfSides)]
def displaySides(self):
for i in range(self.noOfSides):
print("Side ",i+1, " is",self.sides[i])
31
class Triangle(Polygon):
def __init__(self):
super().__init__(3)
# Polygon.__init__(self, 3)
def findArea(self):
a, b, c = self.sides
s = (a+b+c)/2 # s is semiperimeter
area =(s*(s-a)*(s-b)*(s-c))**.5
print("Area of Triangle is %0.2f" %area)
t1 = Triangle()
t1.inputSides()
t1.displaySides()
t1.findArea()
Output of the above code is:
Enter side 1 : 20
Enter side 2 : 30
Enter side 3 : 40
Side 1 is 20.0
Side 2 is 30.0
Side 3 is 40.0
Area of Triangle is 290.47
32
Types of Inheritance-
Built-in methods to check inheritance:
- issubclass(sub, sup)
- Returns True is sub is derived from sub else returns False
- isinstance(obj, Class)
- Returns True if obj is an object or instance of Class else returns False
print(isinstance(t1, Triangle))
print(isinstance(t1, Polygon))
print(issubclass(Triangle, Polygon))
print(issubclass(Triangle, Polygon))
Output of above code is-
True
True
True
33
True
● In case of multiple Inheritance, the order in which methods are inherited is
defined by pythons method resolution technique. It can be viewed using
ClassName.__mro__
● There is something called diamond problem as shown in the below diagram. Der
class will have one copy of Base -> Derived1 and another copy of Base ->
Derived2. This will result in ambiguity.
● Python linearizes the order from left to right.
Example Below:
class Base:
def display(self):
print("Inside Base")
class Derived1(Base):
def display(Self):
print("Inside Derived 1")
super().display()
class Derived2(Base):
def display(self):
print("Inside Derived2")
super().display()
class Der(Derived1, Derived2):
def display(self):
print("Inside Der")
super().display()
d1 = Der()
d1.display()
print("")
print(Der.__mro__)
34
Abstract Class:
- Classes from which an object cant be created is called abstract class
- For this module named abc is imported and ABC class is inherited.
- A decorator @abstractmethod is used.
- If an abstract class contains only methods marked by the decorator
@abstractmethod, it is called an Interface
from abc import ABC, abstractmethod
class Student(ABC):
def __init__(self, first_name, lastname):
self.first_name = first_name
self.lastname = lastname
@property
def full_name(self):
return f"{self.first_name} {self.lastname}"
@abstractmethod
def getScore(self):
pass
35
class FullTime(Student):
def __init__(self,fn, ln, score):
super().__init__(fn, ln)
self.score = score
def getScore(self):
return self.score
class PartTime(Student):
def __init__(self,fn, ln, credit, hrs):
super().__init__(fn, ln)
self.credit = credit
self.hrs = hrs
def getScore(self):
return self.credit * self.hrs
# s1 = FullTime("Manjeet", "Pangtey", 19)
class ScoreBoard:
def __init__(self):
self.student_list = []
def add_student(self, stu):
self.student_list.append(stu)
def display_students(self):
for i in self.student_list:
print(f"{i.full_name} \t {i.getScore()}")
# st1 = Student("Ram", "Singh") # This line will throw error
sb = ScoreBoard()
sb.add_student(FullTime("Aman", "Kumar", 89))
sb.add_student(FullTime("Kiran", "Sharma", 90))
sb.add_student(FullTime("Sundaram", "Swami", 79))
sb.add_student(PartTime("Keshav", "Rao", 3, 8))
sb.add_student(PartTime("Madhav", "Bhatt", 5, 9))
sb.add_student(PartTime("Keshav", "Rao", 3, 8))
sb.display_students()
36
