Object Oriented Programming

Programming paradigms

• Modules, Data structure and

procedures that operate upon
them
Procedural • Focus on procedure ex: C

• Focus on data
• Solving real world problem
Object Oriented • Example: C++,Java, Python
 Overview of OOP Terminology
 Class: A user-defined prototype for an object that defines a set
of attributes that characterize any object of the class. The
attributes are data members
It’s a template to create object.
A way to create User defined data type to be able to
represent real world object and hence solve real word problem.
 Class variable: A variable that is shared by all instances of a
class. Class variables are defined within a class but outside any
of the class's methods. Class variables are not used as
frequently as instance variables are.
 Inheritance: The transfer of the characteristics of a class to
other class. Facilitates Code Reusability and feature
enhancement.
 Data member: A class variable or instance variable that holds
data associated with a class and its objects.Classes that are
derived from it.
 Overview of OOP Terminology (Contd..)
 Instance: An individual object of a certain class. An object obj
that belongs to a class Circle, for example, is an instance of the
class Circle.
 Instance variable: A variable that is defined inside a method
and belongs only to the current instance of a class.
 Instantiation: The creation of an instance of a class.
 Method : A special kind of function that is defined in a class
definition.
 Object: A unique instance of a data structure that's defined by
its class. An object comprises both data members class variables
and instance variables and methods.
 Encapsulation : Dividing the code into a public interface, and
a private implementation of that interface
Object Oriented Programming
in Python:
Defining Classes
 It’s all objects…
 Everything in Python is really an object.
• We’ve seen hints of this already…
“hello”.upper()
list3.append(‘a’)
dict2.keys()
• These look like Java or C++ method calls.
• New object classes can easily be defined in
addition to these built-in data-types.
 In fact, programming in Python is typically
done in an object oriented fashion.
 Defining a Class

 A class is a special data type which defines

how to build a certain kind of object.
 The class also stores some data items that
are shared by all the instances of this class
 Instances are objects that are created which
follow the definition given inside of the class
 Python doesn’t use separate class interface
definitions as in some languages
 You just define the class and then use it
 Methods in Classes

 Define a method in a class by including

function definitions within the scope of the
class block
 There must be a special first argument self
in all of method definitions which gets bound
to the calling instance
 There is usually a special method called
__init__ in most classes
 We’ll talk about both later…
 A simple class def: student

class student:
“““A class representing a
student ”””
def __init__(self,n,a):
self.full_name = n
self.age = a
def get_age(self):
return self.age
Creating and Deleting
Instances
 Instantiating Objects
 There is no “new” keyword as in Java.
 Just use the class name with ( ) notation and
assign the result to a variable
 __init__ serves as a constructor for the
class. Usually does some initialization work
 The arguments passed to the class name are
given to its __init__() method
 So, the __init__ method for student is passed
“Bob” and 21 and the new class instance is
bound to b:
b = student(“Bob”, 21)
 Constructor: __init__
 An __init__ method can take any number of
arguments.
 Like other functions or methods, the
arguments can be defined with default values,
making them optional to the caller.

 However, the first argument self in the

definition of __init__ is special…
 Self
 The first argument of every method is a
reference to the current instance of the class
 By convention, we name this argument self
 In __init__, self refers to the object
currently being created; so, in other class
methods, it refers to the instance whose
method was called
 Similar to the keyword this in Java or C++
 But Python uses self more often than Java
uses this
 Self
 Although you must specify self explicitly
when defining the method, you don’t include it
when calling the method.
 Python passes it for you automatically

Defining a method: Calling a method:

(this code inside a class definition.)

def set_age(self, num): >>> x.set_age(23)

self.age = num
 Deleting instances: No Need to “free”

 When you are done with an object, you don’t

have to delete or free it explicitly.
 Python has automatic garbage collection.
 Python will automatically detect when all of the
references to a piece of memory have gone
out of scope. Automatically frees that
memory.
 Generally works well, few memory leaks
 There’s also no “destructor” method for
classes
Access to Attributes
and Methods
 Definition of student

class student:
“““A class representing a student
”””
def __init__(self,n,a):
self.full_name = n
self.age = a
def get_age(self):
return self.age
 Traditional Syntax for Access

>>> f = student(“Bob Smith”, 23)

>>> f.full_name # Access attribute

“Bob Smith”

>>> f.get_age() # Access a method

23
Accessing unknown members

 Problem: Occasionally the name of an attribute

or method of a class is only given at run time…
 Solution:
getattr(object_instance, string)

 string is a string which contains the name of

an attribute or method of a class
 getattr(object_instance, string)
returns a reference to that attribute or method
getattr(object_instance, string)
>>> f = student(“Bob Smith”, 23)
>>> getattr(f, “full_name”)
“Bob Smith”
>>> getattr(f, “get_age”)
<method get_age of class
studentClass at 010B3C2>
>>> getattr(f, “get_age”)() # call it
23
>>> getattr(f, “get_birthday”)
# Raises AttributeError – No method!
hasattr(object_instance,string)

>>> f = student(“Bob Smith”, 23)

>>> hasattr(f, “full_name”)
True
>>> hasattr(f, “get_age”)
True
>>> hasattr(f, “get_birthday”)
False
Attributes
 Two Kinds of Attributes
 The non-method data stored by objects are
called attributes
 Data attributes
• Variable owned by a particular instance of a class
• Each instance has its own value for it
• These are the most common kind of attribute
 Class attributes
• Owned by the class as a whole
• All class instances share the same value for it
• Called “static” variables in some languages
• Good for (1) class-wide constants and (2)
building counter of how many instances of the
class have been made
 Data Attributes
 Data attributes are created and initialized by
an __init__() method.
• Simply assigning to a name creates the attribute
• Inside the class, refer to data attributes using self
—for example, self.full_name
class teacher:
“A class representing teachers.”
def __init__(self,n):
self.full_name = n
def print_name(self):
print self.full_name
 Class Attributes
 Because all instances of a class share one copy of a
class attribute, when any instance changes it, the value
is changed for all instances
 Class attributes are defined within a class definition
and outside of any method
 Since there is one of these attributes per class and not
one per instance, they’re accessed via a different
notation:
• Access class attributes using self.__class__.name notation
-- This is just one way to do this & the safest in general.

class sample: >>> a = sample()

x = 23 >>> a.increment()
def increment(self): >>> a.__class__.x
self.__class__.x += 1 24
 Data vs. Class Attributes

class counter: >>> a = counter()

overall_total = 0 >>> b = counter()
# class attribute >>> a.increment()
def __init__(self): >>> b.increment()
self.my_total = 0 >>> b.increment()
# data attribute >>> a.my_total
def increment(self): 1
counter.overall_total = \ >>> a.__class__.overall_total
counter.overall_total + 1 3
self.my_total = \ >>> b.my_total
self.my_total + 1 2
>>> b.__class__.overall_total
3
 Function Overloading
We generally don't need to overload functions in
Python. Python is dynamically typed, and supports
optional arguments to functions.

Read More: http://python-history.blogspot.in/2009/02/pythons-use-of-

dynamic-typing.html
 Operator Overloading
 This feature in Python, allows same operator to have
different meaning according to the context.
 For example, the + operator can be used to, perform
arithmetic addition on two numbers, merge two lists
and concatenate two strings.
Example
A Final Example
 Resources
 https://docs.python.org/3/tutorial/classes.html
 http://www.tutorialspoint.com/python/pdf/python_class
es_objects.pdf
 http://www.programiz.com/python-programming/class
 http://www.programiz.com/python-
programming/inheritance
 Assignment

 Write a menu driven banking program to

support the functionalities as shown below