Objects

Python supports many different kinds of data

1234
3.14159
"Hello"
[13,5,17,11,13]
{"DEL": "Delhi", "MUM": "Mumbai"}

Each is an object, and every object has:
- a type
- an internal data representation (primitive or composite)
- a set of procedures for interaction with the object
An object is an instance of a type
- 1234 is an instance of an int
- "hello" is an instance of a string

Object Oriented Programming (OOP)

Everythng in Python is an Object (and has a type)
can create new objects of some type
can manipulate objects
can destroy objects
- explicitly using del or just "forget" about them
- python system will reclaim destroyed or inaccessible objects -- called "garbage collection"

What are objects?

An Objects is a data abstraction that captures:
1. An internal representation through data attributes
2. An interface for interacting with object (a) through methods (aka procedures or functions); and (b) defines behaviours but hides implementation.

Example: [1,2,3,4] has type list

How are lists represented internally? Linked list of cells
How to manipulate lists?
- L[i], L[i:j]
- len(), min(), max(), del(L[i])
- L.append(), L.extend(), L.count(), L.index(), L.insert(), L.pop(), L.remove(), L.reverse(), L.sort()
Internal representation should be private.
Correct behaviour may be compromised if you manipulate internal representation directly.

Advantages of OOP

Bundle data into packages together with procedures that work on them through well-defined interfaces.
Divide-and-conquer development
- Implement and test behaviour of each class separately
- Increased modularity reduces complexity
Classes make it easy to reuse code
- Many Python modules define new classes
- Each class has a separate environment (no collision on function names)
- Inheritance allows subclasses to redefine or extend a selected subset of a superclass' behaviour

Creating and using your own types with Classes

Make a distinction between creating a class and using an instance of the class
Creating the class involves:
- Defining the class name
- Defining class attributes
- For example, someone wrote code to implement a list class
Using the class involves:
- Creating new instances of objects
- Doing operations on the instance
- For example, L=[1,2] and len(L).

Define your own types

Use the class keyword to define a new type

class  Coordinate(object):   # "class keyword"  "name/type Coordinate"  "class parent object"
  # define attributes here

Similar to def, indent code to indicate which statements are a part of the class definition.
The word object means that a Coordinate object is also a Python object and inherits all its attributes (inheritance next lecture)
- Coordinate is a subclass of object
- object is a superclass of Coordinate

What are attributes?

Data and procedures that "belong" to the class
Data attributes
- Think of data as other objects that make up the class
- For example, a coordinate is made up of two numbers
Methods (procedural attributes)
- Think of methods as functions that work with this class
- How to interact with the object
- For example, you can define a distance between two coordinate objects but there is no meaning to a distance between two list objects

Defining how to create an instance of a class

First, have to define how to create an instance of object

Use a special method called __init__ to initialize some data attributes

class Coordinate(object):
  # special method to create an instance. __ is double underscore
  def __init__(self, x, y):  # "self" is a parameter to refer to an instance of the class.
                             # "x" and "y" are data to initialize a Coordinate object
    self.x = x  #x is a data attribute for every Coordinate object
    self.y = y  #y is a data attribute for every Coordinate object

Actually creating an instance of a class

c = Coordinate(3, 4)  # create a new object of type Coordinate and pass in 3 and 4 to the __init__ method
origin = Coordinate(0, 0)
print(c.x)  # use the dot to access an attribute of instance c
print(origin.x)  # similarly, access an attribute of instance origin

Data attributes of an instance are called instance variables
Do not provide argument for self, Python does this automatically

What is a method?

Procedural attribute, like a function that works only with this class
Python always passes the object as the first argument
- convention is to use self as the name of the first argument of all methods
The "." operator is used to access any attribute
- A data attribute of an object
- A method of an object

Define a method for the Coordinate class

class Coordinate(object):
  def __init__(self, x, y):
    self.x = x
    self.y = y
  def distance(self, other): # self refers to the instance on which this method is called
                            # other is another parameter to the function call
    x_diff_sq = (self.x - other.x)**2  #dot notation to access data
    y_diff_sq = (self.y - other.y)**2
    return (x_diff_sq + y_diff_sq)**0.5

other than self and dot notation, methods behave just like functions (take params, do operations, return).

How to use a method

The following is an example of a method definition:

def distance(self, other):
  # code here

Using a class:

Conventional way

c = Coordinate(3, 4)
zero = Coordinate(0, 0)
print(c.distance(zero))
# "c" is an object to call method on
# "distance" is the name of the method
# "zero" represents parameters not including self; self is implied to be c

This is equivalent to

c = Coordinate(3, 4)
zero = Coordinate(0, 0)
print(Coordinate.distance(c, zero)) #Coordinate
# "Coordinate" is a name of class
# "distance" is the name of the method
# "zero" represents parameters including an object to call the method on, representing self

Print representation of an object

>>> c = Coordinate(3,4)
>>> print(c)
< __main__.Coordinate object at 0x7fa918510488

uninformative print representation by default
define a __str__ method when used to print on your class object
you choose what it does! Say that when we print a Coordinate object, want to show
```
>>> print(c)
<3,4>
```

Defining your own print method

class Coordinate(object):
  def __init__(self, x, y):
    self.x = x
    self.y = y

  def distance(self, other):
    x_diff_sq = (self.x - other.x)**2
    y_diff_sq = (self.y - other.y)**2
    return (x_diff_sq + y_diff_sq)**0.5

  def __str__(self): # __str__ is the name of a special method
    return "<"+str(self.x)+","+str(self.y)+">"  #the return value must be a string

Wrapping your head around types and classes

Can ask for the type of an object instance

>>> c = Coordinate(3,4)
>>> print(c)
<3,4>     #return value of the __str__ method
>>> print(type(c))
<class __main__.Coordinate>  #type of object c is a class Coordinate

This makes sense since:

>>> print(Coordinate)
<class __main__.Coordinate>  #a Coordinate is a class
>>> print(type(Coordinate))
<type 'type'>  #a Coordinate class is a type of object

use isinstance() to check if an object is a Coordinate:
```
>>> print(isinstance(c, Coordinate))
True
```

Special Operators

+,-,==,<,>,len(),print, and many others
https://docs.python.org/3/reference/datamodel.html#basic-customization
like print, can override these to work with your class

define them with double underscores before/after

__add__(self, other)   # self + other
__sub__(self, other)   # self - other
__eq__(self, other)    # self == other
__lt__(self, other)    # self < other
__len__(self)          # len(self)
__str__(self)          # print(self)
... and others

Example: fractions

Create a new type to represent a number as a fraction
Internal representation is two integers
- numerator
- denominator
Interface a.k.a. methods a.k.a how to interact with Fraction objects
- add, subtract
- print representation, convert to a float
- invert the fraction

The power of OOP

Bundle together objects that share
Common attributes and
Procedures that operate on those attributes
Use abstraction to make a distinction between how to implement an object vs how to use the object
Build layers of object abstractions that inherit behaviours from other classes of objects
Create your own classes of objects on top of Python's basic classes