Python_Unit_2 OOPS.pptx

2
OOP Features
Main Concepts of Object-Oriented Programming (OOPs)
• Class
• Objects
• Polymorphism
• Compile-Time (Function Overloading, Operator Overloading)
• Run-Time (Method Overriding)
• Encapsulation
• Inheritance
• Data Abstraction

3
OOP, Defining a Class
• Python was built as a procedural language
– OOP exists and works fine, but feels a bit more "tacked on"
– Java probably does classes better than Python (gasp)
• Declaring a class:
class name:
statements

4
Fields
name = value
– Example:
class Point:
x = 0
y = 0
# main
p1 = Point()
p1.x = 2
p1.y = -5
– can be declared directly inside class (as shown here)
or in constructors (more common)
– Python does not really have encapsulation or private fields
• relies on caller to "be nice" and not mess with objects' contents
point.py
1
2
3
class Point:
x = 0
y = 0

5
Using a Class
import class
– client programs must import the classes they use
point_main.py
1
2
3
4
5
6
7
8
9
10
from Point import *
# main
p1 = Point()
p1.x = 7
p1.y = -3
...
# Python objects are dynamic (can add fields any time!)
p1.name = "Tyler Durden"

6
Object Methods
def name(self, parameter, ..., parameter):
statements
– self must be the first parameter to any object method
• represents the "implicit parameter" (this in Java)
– must access the object's fields through the self reference
class Point:
def translate(self, dx, dy):
self.x += dx
self.y += dy
...

7
"Implicit" Parameter (self)
• Java: this, implicit
public void translate(int dx, int dy) {
x += dx; // this.x += dx;
y += dy; // this.y += dy;
}
• Python: self, explicit
self.x += dx
self.y += dy
– Exercise: Write distance, set_location, and
distance_from_origin methods.

8
Exercise Answer
point.py
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
from math import *
class Point:
x = 0
y = 0
def set_location(self, x, y):
self.x = x
self.y = y
def distance_from_origin(self):
return sqrt(self.x * self.x + self.y * self.y)
def distance(self, other):
dx = self.x - other.x
dy = self.y - other.y
return sqrt(dx * dx + dy * dy)

9
Calling Methods
• A client can call the methods of an object in two ways:
– (the value of self can be an implicit or explicit parameter)
1) object.method(parameters)
or
2) Class.method(object, parameters)
• Example:
p = Point(3, -4)
p.translate(1, 5)
Point.translate(p, 1, 5)

10
Constructors
• Constructors are generally used for instantiating an object.
The task of constructors is to initialize(assign values) to the
data members of the class when an object of the class is
created.
def __init__(self, parameter, ..., parameter):
statements
– a constructor is a special method with the name __init__
– Example:
class Point:
def __init__(self, x, y):
self.x = x
self.y = y
...
How would we make it possible to construct a
Point() with no parameters to get (0, 0)?

11
toString and __str__
def __str__(self):
return string
– equivalent to Java's toString (converts object to a string)
– invoked automatically when str or print is called
Exercise: Write a __str__ method for Point objects that
returns strings like "(3, -14)"
def __str__(self):
return "(" + str(self.x) + ", " + str(self.y) + ")"

12
Complete Point Class
point.py
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
from math import *
class Point:
def __init__(self, x, y):
self.x = x
self.y = y
def distance_from_origin(self):
return sqrt(self.x * self.x + self.y * self.y)
def distance(self, other):
dx = self.x - other.x
dy = self.y - other.y
return sqrt(dx * dx + dy * dy)
self.x += dx
self.y += dy
def __str__(self):
return "(" + str(self.x) + ", " + str(self.y) + ")"

13
Python Class and Object Example1
Dog.py
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
class Dog:
# class attribute
attr1 = "mammal"
# Instance attribute
def __init__(self, name):
self.name = name
# Object instantiation
Rodger = Dog("Rodger")
Tommy = Dog("Tommy")
# Accessing class attributes
print("Rodger is a", Rodger.attr1)
print("Rodger is a", Tommy.attr1)
# Accessing instance attributes
print("My name is", Rodger.name)
print("My name is", Tommy.name)

14
Python Class and Object Example2
Dog1.py
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
class Dog1:
# class attribute
attr1 = "mammal“
# Instance attribute
self.name = name
def speak(self):
print("My name is {}".format(self.name))
# Object instantiation
Rodger = Dog1("Rodger")
Tommy = Dog1("Tommy")
# Accessing class methods
Rodger.speak()
Tommy.speak()

15
Encapsulation
• Encapsulation is the mechanism for restricting the access to some
of an objects's components, this means, that the internal
representation of an object can't be seen from outside of the
objects definition.
• C++, Java, and C# rely on the public, private, and protected
keywords in order to implement variable scoping and
encapsulation.
• In python, We don’t have public, protected or private keywords,
but we use underscore to restrict a variable for outside
accessibility.

16
Public, Protected and Private
• If an identifier doesn't start with an underscore character "_" it can
be accessed from outside, i.e. the value can be read and changed.
• Data can be protected by making members private or protected.
• Instance variable names starting with two underscore characters
cannot be accessed from outside of the class.
• At least not directly, but they can be accessed through private
name mangling.
• That means, private data __A can be accessed by the following
name construct: instance_name._classname__A

17
• If an identifier is only preceded by one underscore character, it is a
protected member.
• Protected members can be accessed like public members from
outside of class
Example:
class Encapsulation(object):
def __init__(self, a, b, c):
self.public = a
self._protected = b
self.__private = c

18
• The following interactive sessions shows the behavior of public, protected and
private members:

19
• The following table shows the different behavior Public, Protected
and Private Data:

20
Protected Members
• Protected members (in C++ and JAVA) are those members
of the class that cannot be accessed outside the class but
can be accessed from within the class and its subclasses.
• To accomplish this in Python, just follow the convention by
prefixing the name of the member by a single underscore
“_”.
• Although the protected variable can be accessed out of the
class as well as in the derived class(modified too in derived
class), it is customary(convention not a rule) to not access
the protected out the class body.

21
Protected Members
Example : Python program to demonstrate protected members
# Creating a base class
class Base:
def __init__(self):
# Protected member
self._a = 2
# Creating a derived class
class Derived(Base):
def __init__(self):
# Calling constructor of Base class
Base.__init__(self)
print("Calling protected member of base class: ", self._a)
# Modify the protected variable:
self._a = 3
print("Calling modified protected member outside class: ", self._a)

22
Protected Members
Example cont...
obj1 = Derived()
obj2 = Base()
# Calling protected member
# Can be accessed but should not be done due to convention
print("Accessing protected member of obj1: ", obj1._a)
# Accessing the protected variable outside
print("Accessing protected member of obj2: ", obj2._a)

23
Private Members
• Private members are similar to protected members, the
difference is that the class members declared private should
neither be accessed outside the class nor by any derived
class.
• In Python, there is no existence of Private instance
variables that cannot be accessed except inside a class.
• However, to define a private member prefix the member
name with double underscore “__”.
• Python’s private members can be accessed outside the
class through python name mangling.

24
Private Members
Example : Python program to demonstrate private members
# Creating a base class
class Base:
def __init__(self):
# Public member
self.a = “Welcome to Python”
# Private member
self.__c = “Welcome to Python”
# Creating a derived class
class Derived(Base):
def __init__(self):
# Calling constructor of Base class
Base.__init__(self)
print("Calling private member of base class: ")
print(self.__c)

25
Private Members
Example cont... # Driver code
obj1 = Base()
print(obj1.a) # Works fine
print(obj1.__c) # will raise an AttributeError
obj2 = Derived()
# will also raise an AtrributeError as private member of
base class is called inside derived class

26
Naming Using Underscore(_)
• Underscore(_) can be used to name variables, functions
and classes, etc.
 Single Pre Underscore:- _variable
 Single Post Underscore:- variable_
 Double Pre Underscores:- __variable
 Double Pre and Post Underscores:- __variable__
1. _single_pre_underscore (_name)
Single Pre Underscore is used for internal use. Most of us don't
use it because of that reason.
class Test:
def __init__(self):
self.name = "datacamp"
self._num = 7 obj = Test()
print(obj.name) print(obj._num)
obj = Test()
print(obj.name)
print(obj._num)
• single pre
underscore doesn't stop
you from accessing
the single pre
underscore variable.
• But, single pre
underscore effects the
names that are imported

27
_single_pre_underscore (_name) cont...
Create the following python file
Now, if you import all the methods and names
from my_functions.py, Python doesn't import the names which
starts with a single pre underscore.
## filename:- my_functions.py
def func():
return “Welcome to python"
def _private_func():
return 7
To avoid this error, import module
normally.

28
2. single_post_underscore (name_)
– Sometimes if you want to use Python Keywords as a variable,
function or class names, you can use this convention for that.
– You can avoid conflicts with the Python Keywords by adding
an underscore at the end of the name which you want to use.
Ex:
Single Post Underscore is used
for naming your variables
as Python Keywords and to
avoid the clashes by adding an
underscore at last of your
variable name.

29
3. Double Pre Underscore (__name)
– Double Pre Underscores are used for the name mangling.
– Name Mangling:- interpreter of the Python alters the variable
name in a way that it is challenging to clash when the class is
inherited.
Ex:
This code returns all the attributes of
the class object.
• self.a variable appears in the list without
any change.
• self._b Variable also appears in the list
without any change.
• Is there self.__c variable in the list?
• If you carefully look at the attributes
list, you will find an attribute
called _Sample__c. This is
the name mangling.

30
3. Double Pre Underscore cont...
– Let's create another class by inheriting Sample class to see
how overriding works.
Ex:

31
– Can access the Double Pre Underscore variables using
methods in the class
Ex:

32
– Can also use the Double Pre Underscore for
the method names.
Ex:

33
4. Double Pre And Post Underscore (__name__)
– In Python, you will find different names which start and end with
the double underscore. They are called as magic
methods or dunder methods.
Ex:

34
Inheritance
• Inheritance is the capability of one class to derive or inherit
the properties from another class.
Python Inheritance Syntax
– Example:
class Point:
x = 0
y = 0
class Point3D(Point): # Point3D extends Point
z = 0
...

35
Calling Superclass Methods
• methods: class.method(object, parameters)
• constructors: class.__init__(parameters)
class Point3D(Point):
z = 0
def __init__(self, x, y, z):
Point.__init__(self, x, y)
self.z = z
def translate(self, dx, dy, dz):
Point.translate(self, dx, dy)
self.z += dz

36
Inheritance Example
class Person: # Parent class
# Constructor
self.name = name
# To get name
def getName(self):
return self.name
# To check if this person is an employee
def isEmployee(self):
return False
# Inherited or Subclass
class Employee(Person):
# Here we return true
def isEmployee(self):
return True
# An Object of Person
emp = Person(“John”)
print(emp.getName())
print(emp.isEmployee())
# An Object of Employee
emp = Employee(“Ram”)
print(emp.getName())
print(emp.isEmployee())

37
Subclassing (Calling
constructor of parent class)
• A child class needs to identify which class is its parent class. This can be done by
mentioning the parent class name in the definition of the child class.
Eg: class subclass_name(superclass_name):
# parent class
class Person:
def __init__(self, name, idnumber):
self.name = name
self.idnumber = idnumber
def display(self):
print(self.name)
print(self.idnumber)
# Python code to demonstrate how parent constructors are called.
# child class
class Employee(Person):
def __init__(self, name, idnumber, salary, post):
self.salary = salary
self.post = post
# invoking the constructor of parent class
Person.__init__(self, name, idnumber)
# creation of an object variable or an instance
a = Employee('Rahul', 886012, 200000, "Intern")
# calling a function of the class Person using its instance
a.display()

38
Subclassing (Calling
constructor of parent class)
Python program to demonstrate error if we forget to invoke __init__() of
the parent
• If you forget to invoke the __init__() of the parent class then its instance
variables would not be available to the child class.
class A:
def __init__(self, n='Rahul'):
self.name = n
class B(A):
def __init__(self, roll):
self.roll = roll
object = B(23)
print(object.roll) # No Error
print(object.name) # Error

39
Types of Inheritance in Python
 Single Inheritance: Single inheritance enables a derived class to inherit
properties from a single parent class, thus enabling code reusability and
the addition of new features to existing code.
# Python program to demonstrate single inheritance
# Base class
class Parent:
def func1(self):
print("This function is in parent class.")
# Derived class
class Child(Parent):
def func2(self):
print("This function is in child class.")
# Driver's code
object = Child() Output:
object.func1()
object.func2()

40
 Multiple Inheritance: When a class can be derived from more than one
base class this type of inheritance is called multiple inheritances. (Unlike
java, python shows multiple inheritance.)
# Python program to demonstrate multiple inheritance
# Base class1
class Mother:
mothername = ""
def mother(self):
print(self.mothername)
# Base class2
class Father:
fathername = ""
def father(self):
print(self.fathername)
# Derived class
class Son(Mother, Father):
def parents(self):
print("Father :", self.fathername)
print("Mother :", self.mothername)
# Driver's code
s1 = Son()
s1.fathername = "RAM"
s1.mothername = "SITA"
s1.parents()

41
 Multiple Inheritance: When the method is overridden in both classes
Method Resolution Order (MRO) will take place from left to right.
class Class1:
def m(self):
print("In Class1")
class Class2:
def m(self):
print("In Class2")
class Class3(Class1, Class2):
pass
obj = Class3()
obj.m()
class Class1:
def m(self):
print("In Class1")
class Class2:
def m(self):
print("In Class2")
class Class3(Class2, Class1):
pass
obj = Class3()
obj.m()
Output: In Class1 Output: In Class2
NOTE: In the case of multiple inheritance, a given attribute
is first searched in the current class if it’s not found then it’s
searched in the parent classes. The parent classes are
searched in a left-right fashion and each class is searched

42
 Multilevel Inheritance: In multilevel inheritance, features of the base
class and the derived class are further inherited into the new derived
class. This is like a relationship representing a child and a grandfather.

43
# Python program to demonstrate multilevel inheritance
# Base class
class Grandfather:
def __init__(self, grandfathername):
self.grandfathername = grandfathername
# Intermediate class
class Father(Grandfather):
def __init__(self, fathername, grandfathername):
self.fathername = fathername
# invoking constructor of Grandfather class
Grandfather.__init__(self, grandfathername)
# Derived class
class Son(Father):
def __init__(self, sonname, fathername,
grandfathername):
self.sonname = sonname
# invoking constructor of Father class
Father.__init__(self, fathername, grandfathername)
def print_name(self):
print('Grandfather name :', self.grandfathername)
print("Father name :", self.fathername)
print("Son name :", self.sonname)
# Driver code
s1 = Son('Prince', 'Rampal',
'Lal mani')
print(s1.grandfathername)
s1.print_name()

44
 Hierarchical Inheritance: When more than one derived class are
created from a single base class, this type of inheritance is called
hierarchical inheritance.
# Python program to demonstrate Hierarchical inheritance
# Base class
class Parent:
def func1(self):
print("This function is in parent class.")
# Derived class1
class Child1(Parent):
def func2(self):
print("This function is in child 1.")
# Derived class2
class Child2(Parent):
def func3(self):
print("This function is in child 2.")
# Driver's code
object1 = Child1()
object2 = Child2()
object1.func1()
object1.func2()
object2.func1()
object2.func3()

45
 Hybrid Inheritance: Inheritance consisting of multiple types of
inheritance is called hybrid inheritance.
Hybrid
Inheritance
Multiple
Inheritance

46
# Python program to demonstrate Hybrid inheritance

47
Function Overloading
 Like other languages do, python does not support method overloading by
default. But there are different ways to achieve method overloading in
Python.
 The problem with method overloading in Python is that we may overload
the methods but can only use the latest defined method.
 Example1:
 Example 2:
Method1 (2 Args)
def product(a, b):
p = a * b
print(p)
>> Product(4,5) # Error
Method2 (3 Args)
def product(a, b,c):
p = a * b * c
print(p)
>> Product(2,3,4) # No error

48
How to Achieve Function
Overloading in Python
 Method1 :
If we want to implement the concept of function overloading, we
need to set the default values of the parameters of the function
as None. By setting the value of functional parameters as None,
we get the option of calling the function either with or without the
parameter.
 Method2:
By Using Multiple Dispatch Decorator
Multiple Dispatch Decorator Can be installed by:
pip3 install multipledispatch

49
Using Method 1: Calculate the area of figures(triangle, rectangle,
square).

50
Using Method 2: Using Multiple Dispatch Decorator
from multipledispatch import dispatch
#passing two parameter
@dispatch(int,int)
def product(first,second):
result = first*second
print(result);
#passing three parameters
@dispatch(int,int,int)
def product(first,second,third):
result = first * second * third
print(result);
#you can also pass data type of any value as per requirement
@dispatch(float,float,float)
def product(first,second,third):
result = first * second * third
print(result);
>> product(2,3)
>> Product(2,3,4)
>> product(2.2,3.4,2.3)

51
Method Overriding
 Method overriding is an ability of any object-oriented programming
language that allows a subclass or child class to provide a specific
implementation of a method that is already provided by one of its super-
classes or parent classes.
 When a method in a subclass has the same name, same parameters or
signature and same return type(or sub-type) as a method in its super-
class, then the method in the subclass is said to override the method in
the super-class.

52
Method Overriding
 Method Overriding Example:
# Defining parent class
>> class Parent():
def __init__(self):
self.value = "Inside Parent"
# Parent's show method
def show(self):
print(self.value)
# Defining child class
>> class Child(Parent):
def __init__(self):
self.value = "Inside Child"
# Child's show method
def show(self):
print(self.value)
>> obj1 = Parent()
>> obj2 = Child()
>> obj1.show()
>> obj2.show()

53
Method Overriding with Multiple
Inheritance
 Method Overriding with Multiple Inheritance Example:
>> class Parent1():
# Parent1's show method
def show(self):
print("Inside Parent1")
>> class Parent2():
# Parent2's show method
def display(self):
print("Inside Parent2")
>> class Child(Parent1, Parent2):
def show(self):
print("Inside Child")
obj = Child()
>> obj.show()
>> obj.display()

54
Method Overriding with
Multilevel Inheritance
 Method Overriding with Multilevel Inheritance Example:
>> class Parent():
# Parent's show method
def display(self):
print("Inside Parent")
>> class Child(Parent):
def show(self):
>> class GrandChild(Child):
def show(self):
print("Inside GrandChild")
>> g = GrandChild()
>> g.show()
>> g.display()

55
Calling the Parent’s method
within the overridden method
 Parent class methods can also be called within the overridden methods.
This can generally be achieved by two ways.
1. Using Classname: 2. Using Super()
class Parent():
def show(self):
def show(self):
# Calling the parent's class
# method
super().show()
# Driver's code
obj = Child()
obj.show()
class Parent():
def show(self):
def show(self):
# Calling the parent's class
# method
Parent.show(self)
# Driver's code
obj = Child()
obj.show()

56
Operator Overloading
 Operator Overloading means giving extended meaning beyond their
predefined operational meaning. For example operator + is used to add
two integers as well as join two strings and merge two lists.
# Python program to show use of + operator
for different purposes.
>> print(1 + 2)
# concatenate two strings
>> print("Geeks"+"For")
# Product two numbers
>> print(3 * 4)
# Repeat the String
>> print("Geeks"*4)

57
How to Overload an Operator
 To perform operator overloading, Python provides some special function
or magic function that is automatically invoked when it is associated with
that particular operator.
 For example, when we use + operator, the magic method __add__ is
automatically invoked in which the operation for + operator is defined.
Overloading binary + operator in Python :
• When we use + operator, the magic method __add__ is automatically
invoked in which the operation for + operator is defined.
• There by changing this magic method’s code, we can give extra meaning
to the + operator.

58
 Program to overload binary + operator
class A:
def __init__(self, a):
self.a = a
# adding two objects
def __add__(self, o):
return self.a + o.a
ob1 = A(1)
ob2 = A(2)
ob3 = A("Geeks")
ob4 = A("For")
print(ob1 + ob2)
print(ob3 + ob4)

59
 Program to overload comparison operators
Checking which object is greater
class A:
self.a = a
def __gt__(self, other):
if(self.a>other.a):
return True
else:
return False
ob1 = A(2)
ob2 = A(3)
if(ob1>ob2):
print("ob1 is greater than ob2")
else:
print("ob2 is greater than ob1")

60
 Overloading equality and less than operators :
>> class A:
self.a = a
def __lt__(self, other):
if(self.a<other.a):
return "ob1 is lessthan ob2"
else:
return "ob2 is less than ob1"
def __eq__(self, other):
if(self.a == other.a):
return "Both are equal"
else:
return "Not equal"
>> ob1 = A(2)
>> ob2 = A(3)
>> print(ob1 < ob2)
>> ob3 = A(4)
>> ob4 = A(4)
>> print(ob1 == ob2)

62
Exceptions
Even if a statement or
expression is syntactically correct, it
may cause an error when an attempt
is made to execute it. Errors
detected during execution are
called exceptions
What is an exception?

64
Handling Exceptions
It is possible to write programs
that handle selected exceptions.
Look at the following example, which
asks the user for input until a valid
integer has been entered, but allows
the user to interrupt the program
(using Control-C or whatever the
operating system supports); note
that a user-generated interruption is
signalled by raising the
KeyboardInterrupt exception.

65
Handling Exceptions
For Example

66
Handling Exceptions
The try statement works as follows.
First, the try clause (the statement(s)
between the try and except keywords)
is executed.
If no exception occurs, the except
clause is skipped and execution of the
try statement is finished.

67
Handling Exceptions
If an exception occurs during
execution of the try clause, the rest of
the clause is skipped. Then if its type
matches the exception named after
the except keyword, the except clause
is executed, and then execution
continues after the try statement.

68
Handling Exceptions
If an exception occurs which does
not match the exception named in the
except clause, it is passed on to outer
try statements; if no handler is found,
it is an unhandled exception and
execution stops with a message as
shown above.

69
The except Clause with No Exceptions

70
You can also use the except statement
with no exceptions defined as follows:
try:
You do your operations here;
except:
If there is any exception, then
execute this block…..
else:
If there is no exception then execute
this block. Contd..

71
This kind of a try-
except statement catches all the
exceptions that occur. Using this
kind of try-except statement is not
considered a good programming
practice though, because it catches
all exceptions but does not make the
programmer identify the root cause
of the problem that may occur.

75
Catching Specific Exception
A try statement can have more than
one except clause, to specify handlers for
different exceptions. Please note that at
most one handler will be executed.
try:
# statement(s)
except IndexError:
# statement(s)
except ValueError:
# statement(s)

76
Example : Multiple Exception Handling

77
Example : Multiple Exception Handling

78
Try with Else Clause
In python, you can also use the else
clause on the try-except block which must be
present after all the except clauses. The code
enters the else block only if the try clause
does not raise an exception.

80
raise statement
The raise statement allows the
programmer to force a specific exception to
occur. The sole argument in raise indicates
the exception to be raised.
Raising an exception breaks current
code execution and returns the exception
back until it is handled.
Syntax:
raise [expression1[, expression2]]

84
Some common exceptions
IOError
If the file cannot be opened.
ImportError
If python cannot find the module.
ValueError
Raised when a built-in operation or
function receives an argument that has the
right type but an inappropriate value.

85
Some common exceptions
KeyboardInterrupt
Raised when the user hits the interrupt key
(normally Control-C or Delete).
EOFError
Raised when one of the built-in functions
(input() or raw_input()) hits an end-of-file
condition (EOF) without reading any data

Python_Unit_2 OOPS.pptx

More Related Content

Similar to Python_Unit_2 OOPS.pptx (20)

Recently uploaded (20)

Python_Unit_2 OOPS.pptx

Editor's Notes