Object Oriented Programming (OOP)¶

we've been using procedural programming paradigm; focus on functions/procedures
OOP paradigm is best used in large and complex modern software systems which make it easy to maintain and improve over time
focus is on creation of objects which contain both data and functionality together under one name
typically, each class definition corresponds to some object or concept in the real world with some attributes/properties that maintain its state; and the functions/methods correspond to the ways real-world objects interact

class¶

we've used classes like str, int, float, dict, tuple, etc.
class keyword lets programmer define their own compound data types
class is a collection of relevant attributes and methods like real world objects
e.g., a clas that represents a point in 2-D coordinates

class className:
    [statement-1]
    .
    .
    [statement-N]

a simple Point class example¶

In [32]:

class Point:
    pass
a = Point()
a.x = 0
a.y = 0
print(a.x, a.y)
# OK but NOT best practice!

0 0

better class example¶

In [33]:

class Point:
    """
    Point class to represent and manipulate x, y coords
    """
    count = 0 # class variable/attribute
    
    # constructor to customize the initial state of an object
    # first argument refers to the instance being manipulated;
    # it is customary to name this parameter self; but can be anything
    def __init__(self, xx=0, yy=0):
        """Create a new point with given x and y coords"""
        # x and y are object variables/attributes
        self.x = xx
        self.y = yy
        Point.count += 1 # increment class variable
     
    def __del__(self):
        Point.count -= 1

class members¶

like real world objects, object instances can have both attributes and methods
use . dot notation to access members
x and y are attributes of Point class
init() (constructor) and del() (destructor) are sepcial methods
can have as many relevant attributes and methods that help mimic real-world objects

In [34]:

# instantiate an object
p = Point()
# what is the access specifier for attributes?
print(p.x, p.y) 
print(Point.count) # access class variable outside class
p1 = Point(2, 3)
print(p1.x, p1.y)
print(Point.count)

# Run this cell few times and see the value of Point.count
# How do you fix this problem? Use __del__ destructor method.

visualizing class and instance attributes using pythontutor.com¶

https://goo.gl/aGuc4r

In [35]:

from IPython.display import IFrame
src = """http://pythontutor.com/iframe-embed.html#code=class%20Point%3A%0A%20%20%20%20%22%22%22%0A%20%20%20%20Point%20class%20represents%20and%20manipulates%20x,y%20coords%0A%20%20%20%20%22%22%22%0A%20%20%20%20count%20%3D%200%20%23%20class%20variable/attribute%0A%20%20%20%20%0A%20%20%20%20%23%20constructor%20to%20customize%20the%20initial%20state%20of%20an%20object%0A%20%20%20%20%23%20first%20argument%20refers%20to%20the%20instance%20being%20manipulated%3B%0A%20%20%20%20%23%20it%20is%20customary%20to%20name%20this%20parameter%20self%3B%20but%20can%20be%20anything%0A%20%20%20%20def%20__init__%28self,%20xx%3D0,%20yy%3D0%29%3A%0A%20%20%20%20%20%20%20%20%22%22%22Create%20a%20new%20point%20with%20given%20x%20and%20y%20coords%22%22%22%0A%20%20%20%20%20%20%20%20%23%20x%20and%20y%20are%20object%20variables/attributes%0A%20%20%20%20%20%20%20%20self.x%20%3D%20xx%0A%20%20%20%20%20%20%20%20self.y%20%3D%20yy%0A%20%20%20%20%20%20%20%20Point.count%20%2B%3D%201%20%23%20increment%20class%20variable%0A%20%20%20%20%20%20%20%20%0Ap%20%3D%20Point%28%29%0Aprint%28p.x,%20p.y%29&codeDivHeight=400&codeDivWidth=350&cumulative=false&curInstr=0&heapPrimitives=false&origin=opt-frontend.js&py=3&rawInputLstJSON=%5B%5D&textReferences=false"""
IFrame(src, width=900, height=600)

Out[35]:

exercise: add a method dist_from_origin() to Point class¶

computes and returns the distance from the origin
test the methods

In [56]:

class Point:
    """
    Point class represents and manipulates x,y coords
    """
    count = 0
    
    def __init__(self, xx=0, yy=0):
        """Create a new point with given x and y coords"""
        self.x = xx
        self.y = yy
        Point.count += 1
        
    def dist_from_origin(self):
        import math
        dist = math.sqrt(self.x**2+self.y**2)
        return dist
    
    def __str__(self):
        return "({}, {})".format(self.x, self.y)
    

In [37]:

p1 = Point(2, 2)
print(p1.dist_from_origin())

2.8284271247461903

objects are mutable¶

can change the state or attributes of an object

In [38]:

p2 = Point(3, 2)
print(p2)
p2.x = 4
p2.y = 10
print(p2)

(3, 2)
(4, 10)

better approach to change state/attribute is via methods¶

move(xx, yy) method is added to class to set new x and y values for a point objects

In [39]:

class Point:
    """
    Point class represents and manipulates x,y coords
    """
    count = 0
    
    def __init__(self, xx=0, yy=0):
        """Create a new point with given x and y coords"""
        self.x = xx
        self.y = yy
        Point.count += 1
        
    def dist_from_origin(self):
        import math
        dist = math.sqrt(self.x**2+self.y**2)
        return dist
    
    def __str__(self):
        return "({}, {})".format(self.x, self.y)
    
    def move(self, xx, yy):
        self.x = xx
        self.y = yy

In [40]:

p3 = Point()
print(p3)
p3.move(10, 20)
print(p3)

(0, 0)
(10, 20)

sameness - alias or deep copy¶

In [41]:

import copy
p2 = Point(3, 4)
p3 = p2 # alias or deepcopy?
print(p2 is p3) # checks if two references refer to the same object
p4 = copy.deepcopy(p2)
print(p2 is p4)

True
False

passing objects as arguments to functions¶

In [42]:

def print_point(pt):
    #pt.x = 100
    #pt.y = 100
    print('({0}, {1})'.format(pt.x, pt.y))

In [43]:

p = Point(10, 10)
print_point(p)
#print(p)
print(p.x, p.y)

(10, 10)
10 10

are objects passed by value or reference?¶

how can you tell?
write a simple program to test.

returning object instances from functions¶

In [44]:

def midpoint(p1, p2):
    """Returns the midpoint of points p1 and p2"""
    mx = (p1.x + p2.x)/2
    my = (p2.x + p2.y)/2
    return Point(mx, my)

In [45]:

p = Point(4, 6)
q = Point(6, 4)
r = midpoint(p, q)
print_point(r) # fix this
print(r)

(5.0, 5.0)
(5.0, 5.0)

exercise 1: design a class to represent a triangle and implement methods to calculate area and perimeter.

composition¶

class can include another class as a member
let's say we want to represent a rectangle in a 2-D coordinates (XY plane)
corner represents the top left point on a XY plane

In [46]:

class Rectangle:
    """ A class to manufacture rectangle objects """

    def __init__(self, posn, w, h):
        """ Initialize rectangle at posn, with width w, height h """
        self.corner = posn
        self.width = w
        self.height = h

    def __str__(self):
        return  "({0}, {1}, {2})".format(self.corner, self.width, self.height)

box = Rectangle(Point(0, 0), 100, 200)
bomb = Rectangle(Point(100, 80), 5, 10)    # In my video game
print("box: ", box)
print("bomb: ", bomb)

box:  ((0, 0), 100, 200)
bomb:  ((100, 80), 5, 10)

copying objects¶

can be challenging as assigning one object to anohter simply creates alias

In [47]:

r1 = Rectangle(Point(1, 1), 10, 5)
r2 = copy.copy(r1)

In [48]:

# r1 is not r2 but two corners are same
r1 is r2

Out[48]:

False

In [49]:

r1.corner is r2.corner

Out[49]:

True

In [50]:

r1.corner.move(10, 10)

In [51]:

# both r1 and r2 moved
print(r1)
print(r2)

((10, 10), 10, 5)
((10, 10), 10, 5)

In [52]:

r3 = copy.deepcopy(r1)

In [53]:

r1 is r3

Out[53]:

False

In [54]:

print(r1, r3)

((10, 10), 10, 5) ((10, 10), 10, 5)

In [55]:

r1.corner.move(20, 20)
# r1 is moved but not r3
print(r1, r3)

((20, 20), 10, 5) ((10, 10), 10, 5)

In [ ]: