Introduction to TechSoup’s Digital Marketing Services and Use Cases
Object_Oriented_Programming_Unit3.pdf
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12. you must specify self explicitly when defining the method, you don’t
include it when calling the method
13.
14.
15. Classes are defined using keyword “Class”
followed by user defined “ClassName” and a
colon.
Variables are also called attributes
Functions are also called methods.
Functions are also called methods.
Syntax: class className:
<statement-1>
<statement-2>
;
<statement-n>
16. class Mobile:
def __init__(self, name):
self.mobile_name=name
print("Constructor")
def receive_msg(self):
print(f"Receive Message from {self.mobile_name}")
def send_msg(self):
print(f"Send Message from {self.mobile_name}")
def main():
def main():
nokia = Mobile("Nokia")
nokia.receive_msg()
nokia.send_msg()
if __name__=="__main__":
main()
Output:
Constructor
Receive Message from Nokia
Send Message from Nokia
•Class Mobile has 2 methods:
-Receive_msg()
- Send_msg()
•Self has no meaning in Python.
•It is used to improve readability.
•__init__ function is called when an
object is instantiated
17. Object refers to a particular instance of a class.
It contains variables and methods defined in the class.
Class objects support 2 kinds of operations.
◦ A. Attribute references – The names in class are referenced by
objects and are called attribute references. There are two
objects and are called attribute references. There are two
kinds of attribute references.
A. Data attributes – Variables defined within methods are called
instance variables / data attributes which are used to store data.
B. Method attributes – Functions that are inside a class and are
referenced by objects of a class.
B. Instantiation – Act of creating an object from a class.
18. class student:
def __init__(self,name,marks):
self.name = name
self.marks = marks
def check_pass_fail(self):
if self.marks >= 40:
return True
else:
return False
•Student1 and Student2 are the objects of
Student Class.
•Student1 is instantiated with name as Harry
and marks 30
•Student2 is instantiated with name as Jane
and marks 99
•Whenever you call a method using an object,
def main():
student1 = student("Harry", 30)
student2 = student("Jane", 99)
did_pass = student1.check_pass_fail()
print(did_pass)
did_pass = student2.check_pass_fail()
print(did_pass)
if __name__=="__main__":
main()
•Whenever you call a method using an object,
the object is automatically passed in as the
first parameter to the self parameter variable
Output
False
True
19. class Birds:
def __init__(self, bird_name):
self.bird_name = bird_name
def flying_birds(self):
print(f"{self.bird_name} flies above clouds")
def non_flying_birds(self):
print(f"{self.bird_name} is the national bird of Australia")
def main():
vulture=Birds("Griffon Vulture")
Crane = Birds("Common Crane")
Emu = Birds("Emu")
vulture.flying_birds()
Crane.flying_birds()
Emu.non_flying_birds()
if __name__=="__main__":
main()
Output:
Griffon Vulture flies above clouds
Common Crane flies above clouds
Emu is the national bird of Australia
vulture, Crane and Emu are the objects
of class Birds
20. Only one constructor can be defined per class
Syntax:
def __init__(self,parameter_1,….parameter_n)
It defines and initializes the instance variables
It is called as soon as an object of a class is
It is called as soon as an object of a class is
instantiated.
All the data attributes of a class are initialised
in the init function itself.
21. An object can be passed as an argument to a calling
function
class Music:
def __init__(self,song,artist):
self.song=song
self.artist=artist
def print_track_info(vocalist):
Output:
Song is Boy With Love
Artist is BTS2
def print_track_info(vocalist):
print(f"Song is {vocalist.song}")
print(f"Artist is {vocalist.artist}")
singer = Music("Boy With Love","BTS")
print_track_info(singer)
22. class sum:
def __init__(self,num1,num2):
self.num1 = num1
self.num2 = num2
self.sum =" "
def add_sum(self):
self.sum = self.num1 + self.num2
return self
Output:
9
1787802679712
True
return self
def main():
number =sum(4,5)
returned_object = number.add_sum()
print(returned_object.sum)
print(id(returned_object))
print(isinstance(returned_object,sum))
if __name__=="__main__":
main()
•id(object) is a function that is used to find
the identity of the location of the object in
memory
•Isinstance(object,classinfo) is a function
that returns a boolean stating if the object
is an instance of class or not.
23. class Dog:
kind ='Canine'
def __init__(self,name):
self.dog_name=name
Class Attributes:
Are Class variables that is
shared by all objects of a
class.
Data Attributes
Are instance variables
unique to each object of a
d=Dog('Fido')
e=Dog("Buddy")
print(f"{d.kind}")
print(f"{e.kind}")
print(f"{d.dog_name}")
print(f"{e.dog_name}")
Output:
Canine
Canine
Fido
Buddy
unique to each object of a
class.
24. Encapsulation -> Information hiding
Abstraction -> Implementation hiding
It is the process of combining variables that store data and
methods that work on those variables into a single unit called
class.
class foo:
def __init__(self,a,b):
self.a = a
Output:
7
self.a = a
self.b = b
def add(self):
return self.a + self.b
foo_object =foo(3,4)
print(foo_object.add())
The internal representation of the foo
class is hidden outside the class ->
Encapsulation
The implementation of add() function
is hidden from the object. ->
Abstraction
25. class Demo:
def __init__(self):
self.nonprivate="I am not a private instance"
self.__private="I am a private instance"
def display_privateinstance(self):
print(f"{self.__private} used within the method of a class")
def main():
def main():
demo_obj = Demo()
demo_obj.display_privateinstance()
print(demo_obj.nonprivate)
# print(demo_obj.__private)
if __name__=="__main__":
main()
Output:
I am a private instance used within
the method of a class
I am not a private instance
26. The private instance variables cannot be accessed outside the
class, but only through a method defined inside the class
In Python, an identifier with double underscore is treated as
private.
Name mangling is intended to give the class an easy way to
define private instance variables and methods
class Student:
def __init__(self, name):
self.__name = name // private attribute
s1 = Student("Santa")
print(s1._Student__name)
//Access using _class__private attribute
27. The class that is used as the basis for inheritance is called
a superclass or base class.
A class that inherits from a base class is called a subclass
or derived class.
The base class and derived class exhibit “is a” relationship
in inheritance
Eg: Sitar is a stringed instrument
Eg: Sitar is a stringed instrument
Syntax of derived class:
Class DerivedClassName(BaseClassName):
<statement-1>
.
.
<statement-N>
28. It is possible to define the derived base when the base class is defined in another
module.
Class DerivedClassName(modname.BaseClassName)
# module1.py
class Hello:
def show(self):
print("Module1.Hello.Show Welcome")
print("Module1.Hello.Show Welcome")
#modulederived.py
______________________________________________________________________________________
import module1
class derived_module1(module1.Hello): # derived class of the Hello class in Module 1
def derived_class(self):
print("Hi")
def main():
check = derived_module1() # object of the derived_module1 class
check.show()
if __name__=="__main__":
main() Output:
Module1.Hello.Show Welcome
29. class someclass(object): # this is derived out of the "class object"
def __init__(self):
print("Constructor")
def someclass_function(self):
print("Hello India")
•All class except “Class object” are
derived classes.
•Class object is the base of
inheritance hierarchy and hence
has no derived classes.
def main():
obj = someclass()
obj.someclass_function()
if __name__=="__main__":
main()
has no derived classes.
•Classes without baseclassname are
derived from the class object.
30. class cricket:
def __init__(self,IPLteam,owner,times_won):
self.IPLteam = IPLteam
self.owner = owner
self.times_won = times_won
def IPLOwner(self):
print(f"The IPL team {self.IPLteam} is owned by {self.owner}")
class derived_cricket(cricket):
class derived_cricket(cricket):
def IPLresults(self):
print(f"The IPL team {self.IPLteam} has won {self.times_won}")
def main():
cricket_fans=derived_cricket("KKR","SRK", 9)
cricket_fans.IPLOwner()
cricket_fans.IPLresults()
if __name__=="__main__":
main()
Output:
The IPL team KKR is
owned by SRK
The IPL team KKR has
won 9
31. Derived_cricket is the derived class and cricket is the base
class
Derived class inherits variables and methods of base class
__init__() method is also derived from base class. Derived
__init__() method is also derived from base class. Derived
class has access of __init__() method of the base class.
The base class has 3 data attributes, IPLteam, owner and
times_won. It has a method IPLOwner
Derived class has access to the data attributes and methods
of the base class.
32. In Single Inheritance, built-in super() function is used to refer to base
class without explicitly naming it.
If derived class has __init__() method and needs to access the base class
__init__() method explicitly, then this is done using super().
If the derived class needs no attributes from base class, then we do not
need to use super() method to invoke base class __init__() method.
need to use super() method to invoke base class __init__() method.
Super().__init__(base_class_parameters)
Its usage is as below.
Class DerivedClass(BaseClass):
def__init__(self, derived_class_params, base_class_params)
super().__init__(base_class_params)
self.derived_class_params = derived_class_params
33. class country:
def __init__(self,country_name):
self.country_name = country_name
def country_details(self):
print(f"Happiest country in world is {self.country_name}")
class HappyCountry(country):
def __init__(self,country_name,continent):
super().__init__(country_name)
self.continent = continent
self.continent = continent
def Happy_Country_Details(self):
print(f"Happiest country in the world is {self.country_name} and it is in {self.continent}")
def main():
obj = HappyCountry("Finland","Europe")
obj.Happy_Country_Details()
if __name__=="__main__":
main()
Output:
Happiest country in the world
is Finland and it is in Europe
34. The derived class __init__() method has its own parameters
plus the base class parameters.
We do not need to specify self for base class init() method
Base class methods may be overridden (method overriding)
Derived class should have a method with same name as those
in base class. Also signature (method name, order and total
number of parameters) should be same.
35. def main():
print("Derived Class")
derived_obj=Friction("R K Narayan",
"Malgudi Days", "India Book House")
derived_obj.book_info()
print("-----------------------")
derived_obj.invoke_base_class_method()
class Book:
def __init__(self,author,title):
self.author = author
self.title = title
def book_info(self):
print(f"{self.title} is authored by {self.author}")
class Friction(Book):
if __name__=="__main__":
main()
Output:
Derived Class
Malgudi Days is authored by R K Narayan and
published by India Book House
-----------------------
Malgudi Days is authored by R K Narayan
class Friction(Book):
def __init__(self,author,title,publisher):
super().__init__(author,title)
self.publisher = publisher
def book_info(self):
print(f"{self.title} is authored by {self.author} and published by {self.publisher}")
def invoke_base_class_method(self):
super().book_info()
36. Python supports a form of multiple inheritances. A derived class
definition with multiple base classes looks like
Class DerivedClassName(Base_1,Base_2, Base_3)
<statement_1>
.
.
<statement_N>
The baseclass method can be invoked from the derived class using the
The baseclass method can be invoked from the derived class using the
syntax
BaseClassName.methodname (self, arguments)
Issubclass(DerivedClassName, BaseClassName)
returns True if DerivedClassName is a derived class of base class
BaseClassName.
37. class length:
l = 0
def length(self):
return self.l
class breadth:
b = 0
def breadth(self):
return self.b
class rect_area(length, breadth): # derived from class length and class breadth
Output:
Enter the required length for rectangle: 5
Enter the required breadth for rectangle: 4
The area of rectangle with length 5 units
and breadth 4 units is 20 sq. units.
class rect_area(length, breadth): # derived from class length and class breadth
def r_area(self):
print("The area of rectangle with length "+str(self.l)+" units and breadth "+
str(self.b)+" units is "+str(self.l * self.b)+" sq. units.")
def main():
o = rect_area()
o.l = int(input("Enter the required length for rectangle: "))
o.b = int(input("Enter the required breadth for rectangle: "))
o.r_area()
if __name__=="__main__":
main()
38. class Pet:
def __init__(self,breed):
self.breed = breed
def about(self):
print(f"This is {self.breed} breed")
class Insurable:
def __init__(self,amount):
self.amount = amount
def main():
dog_obj = dog(15, "Shitzu", 5000)
dog_obj.about()
dog_obj.get_weight()
if __name__=="__main__":
main()
self.amount = amount
def about(self):
print(f"It is insured for an amount {self.amount}")
class dog(Pet, Insurable):
def __init__(self,weight,breed,amount):
self.weight = weight
Pet.__init__(self,breed)
Insurable.__init__(self,amount)
def get_weight(self):
print(f" {self.breed} dog weights around {self.weight} pounds")
Output:
This is Shitzu breed
Shitzu dog weights around 15 pounds
[<class '__main__.dog'>, <class
'__main__.Pet'>, <class
'__main__.Insurable'>, <class 'object'>]
39. MRO denotes the way Python programming
language resolves a method found in multiple
base classes.
Syntax : class_name.mro()
Syntax : class_name.mro()
It uses C3 linearization algorithm to
determine the order of the methods to be
invoked in multiple inheritances
40. class First:
def my_method(self):
print("You found me in class first")
class Second:
def my_method(self):
print("you found me in class second")
class Third:
def my_method(self):
def main():
obj = Sixth()
obj.my_method()
print(Sixth.mro())
if __name__=="__main__":
main()
print("you found me in class Third")
class Fourth(Third,First):
pass
class Fifth(Third, Second):
pass
class Sixth(Fifth, Fourth):
pass
Output:
you found me in class Third
[<class '__main__.Sixth'>, <class
'__main__.Fifth'>, <class '__main__.Fourth'>,
<class '__main__.Third'>, <class
'__main__.Second'>, <class '__main__.First'>,
<class 'object'>]
41. class First:
def __init__(self):
print("In First")
super().__init__()
class Second:
def __init__(self):
print("In Second")
super().__init__()
Output:
In Third
In First
In Second
Method Resolution order is [<class
'__main__.Third'>, <class '__main__.First'>,
<class '__main__.Second'>, <class
'object'>]
class Third (First,Second):
def __init__(self):
print("In Third")
super().__init__()
def main():
obj = Third()
print(f"Method Resolution order is {Third.mro()}")
if __name__=="__main__":
main()
First the __init__() method of class Third is called.
This prints “In Third”. After this super().__init__() is
called which in turn calls the __init__() method of
the next class found in MRO.
42. import math
pi = 3.141
class square:
def __init__(self, length):
self.l = length
def perimeter(self):
return 4 * (self.l)
def area(self):
return self.l * self.l
class Circle:
def __init__(self, radius):
•Square and Circle are the derived classes
•The derived classes have the methods
perimeter() and area() which are common to
both
•But the implementation of these two
methods is different in each of the 2 classes.
def __init__(self, radius):
self.r = radius
def perimeter(self):
return 2 * pi * self.r
def area(self):
return pi * self.r ** 2
# Initialize the classes
sqr = square(10)
c1 = Circle(4)
print("Perimeter computed for square: ", sqr.perimeter())
print("Area computed for square: ", sqr.area())
print("Perimeter computed for Circle: ", c1.perimeter())
print("Area computed for Circle: ", c1.area())
Output:
Perimeter computed for square: 40
Area computed for square: 100
Perimeter computed for Circle: 25.128
Area computed for Circle: 50.256
43. This is a specific case of Polymorphism.
“Poly” means many and “morphism” means
forms. You can have multiple classes where
each class implements the same variables or
methods in different ways.
methods in different ways.
Operator overloading is a specific case of
polymorphism, where an operator can have
different meaning when used with operands
of different types.
44.
45.
46. class Rectangle:
def __init__(self,width,height):
self.width = width
self.height = height
def __gt__(self,other):
rectangle_l_area = self.width * self.height
rectangle_2_area = other.width * other.height
return rectangle_l_area > rectangle_2_area
Output:
rectangle 1 is greater than
rectangle 2
def main():
rectangle_1_obj = Rectangle(5,10)
rectangle_2_obj = Rectangle(3,4)
if rectangle_1_obj > rectangle_2_obj:
print("rectangle 1 is greater than rectangle 2")
else:
print("rectangle 2 is greater than rectangle 1")
if __name__=="__main__":
main()
•rectangle_1_obj and rectangle_2_obj are objects of the
Rectangle class.
•When the expression rectangle_l_area > rectangle_2_area
is evaluated, then the method
rectangle_1_obj.__gt__(rectangle_2_obj) gets invoked.
48. complex_number_sum = complex_number_1 +
complex_number_2 will execute as
Complex_number_1.__add__(complex_number_2)
__add__() method is called magic method.
Whenever we have to print the complex_number formatted,
Whenever we have to print the complex_number formatted,
then __str__() magic method is called which is implemented as
shown in the program
The __str__() method returns the values of real and imaginary
data concatenated together and imaginary part is prefixed with
i.
