PYTHON CLASSES

(download slides and .py files to follow along)

6.100L Lecture 17
Ana Bell

1
OBJECTS

 Python supports many different kinds of data

1234 3.14159 "Hello" [1, 5, 7, 11, 13]
{"CA": "California", "MA": "Massachusetts"}
 Each is an object, and every object has:
• 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 str

6.100L Lecture 17
OBJECT ORIENTED
PROGRAMMING (OOP)

 EVERYTHING 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”

6.100L Lecture 17
WHAT ARE OBJECTS?

 Objects are a data abstraction

that captures…
(1) An internal representation
 Through data attributes
(2) An interface for
interacting with object
 Through methods
(aka procedures/functions)
 Defines behaviors but
hides implementation

6.100L Lecture 17
EXAMPLE:
[1,2,3,4] has type list

 (1) How are lists represented internally?

Does not matter for so much for us as users (private representation)
L = 1 ->2 -> 3
or L = 1 -> 2 -> 3 -> 4 ->
 (2) How to interface with, and 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 behavior may be compromised if you manipulate internal
representation directly
5

6.100L Lecture 17
REAL-LIFE EXAMPLES

 Elevator: a box that can change floors

 Represent using length, width, height, max_capacity, current_floor
 Move its location to a different floor, add people, remove people
 Employee: a person who works for a company
 Represent using name, birth_date, salary
 Can change name or salary
 Queue at a store: first customer to arrive is the first one helped
 Represent customers as a list of str names
 Append names to the end and remove names from the beginning
 Stack of pancakes: first pancake made is the last one eaten
 Represent stack as a list of str
 Append pancake to the end and remove from the end
6

6.100L Lecture 17
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 behavior 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’ behavior

6.100L Lecture 17
 BIG IDEA
You write the class so you
make the design decisions.
You decide what data represents the class.
You decide what operations a user can do with the class.

6.100L Lecture 17
 Implementing the class Using the class

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 the class
• Doing operations on the instances
• for example, L=[1,2] and len(L)

6.100L Lecture 17
A PARALLEL with FUNCTIONS

 Defining a class is like defining a function

 With functions, we tell Python this procedure exists
 With classes, we tell Python about a blueprint for this new data type
 Its data attributes
 Its procedural attributes

 Creating instances of objects is like calling the function

 With functions we make calls with different actual parameters
 With classes, we create new object tinstances in memory of this type
 L1 = [1,2,3]
L2 = [5,6,7]

10

6.100L Lecture 17
COORDINATE TYPE
DESIGN DECISIONS
Can create instances of a  Decide what data elements
Coordinate object constitute an object
• In a 2D plane
• A coordinate is defined by
(3 , 4) an x and y value

 Decide what to do with

coordinates
• Tell us how far away the
coordinate is on the x or y axes
• Measure the distance between
(1 , 1) two coordinates, Pythagoras

11

6.100L Lecture 17
 Implementing the class Using the class

DEFINE YOUR OWN TYPES

 Use the class keyword to define a new type

class Coordinate(object):
#define attributes here

 Similar to def, indent code to indicate which statements are

part of the class definition
 The word object means that Coordinate is a Python
object and inherits all its attributes (will see in future lects)
12

6.100L Lecture 17
WHAT ARE ATTRIBUTES?

 Data and procedures that “belong” to the class

 Data attributes
• Think of data as other objects/variables that make up the class
• for example, a coordinate is made up of two numbers
 Methods (procedural attributes)
• Think of methods as functions that only 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

13

6.100L Lecture 17
 Implementing the class Using the class

DEFINING HOW TO CREATE AN INSTANCE OF A

CLASS
 First have to define how to create an instance of class
 Use a special method called __init__ to initialize some
data attributes or perform initialization operations
class Coordinate(object):
def __init__(self, xval, yval):
self.x = xval
self.y = yval

 self allows you to create variables that belong to this object

 Without self, you are just creating regular variables!
14

6.100L Lecture 17
 Image © source unknown. All rights
reserved. This content is excluded from
our Creative Commons license. For more

WHAT is self?
information, see https://ocw.mit.edu/
help/faq-fair-use/

ROOM EXAMPLE
 Think of the class definition as a  Now when you create ONE instance
blueprint with placeholders for (name it living_room), self becomes
actual items this actual object
 self has a chair  living_room has a blue chair
 self has a coffee table  living_room has a black table
 self has a sofa  living_room has a white sofa
 Can make many instances using
the same blueprint

15

6.100L Lecture 17
 BIG IDEA
When defining a class,
we don’t have an actual
tangible object here.
It’s only a definition.

16

6.100L Lecture 17
 Implementing the class Using the class

Recall the __init__ method in the class def:

def __init__(self, xval, yval): ACTUALLY CREATING
self.x = xval
self.y = yval AN INSTANCE OF A CLASS

 Don’t provide argument for self, Python

does this automatically
c = Coordinate(3,4)
origin = Coordinate(0,0)

 Data attributes of an instance are called instance variables

 Data attributes were defined with self.XXX and they are
accessible with dot notation for the lifetime of the object
 All instances have these data attributes, but with different values!
print(c.x)
print(origin.x)
17

6.100L Lecture 17
VISUALIZING INSTANCES

 Suppose we create an instance of

a coordinate
c = Coordinate(3,4) Type: Coordinate
c x: 3
 Think of this as creating a y: 4
structure in memory
 Then evaluating
c.x
looks up the structure to which
c points, then finds the binding
for x in that structure

18

6.100L Lecture 17
VISUALIZING INSTANCES:
in memory
 Make another instance using
a variable
a = 0 Type: Coordinate
c x: 3
orig = Coordinate(a,a) y: 4

orig.x a 0

 All these are just objects in Type: Coordinate

memory! orig x: 0
y: 0
 We just access attributes of
these objects

19

6.100L Lecture 17
VISUALIZING INSTANCES:
draw it

class Coordinate(object):
def __init__(self, xval, yval):
self.x = xval
self.y = yval
(3 , 4)
c
c = Coordinate(3,4)
origin = Coordinate(0,0)
print(c.x)
print(origin.x)

(0 , 0)
origin

20

6.100L Lecture 17
WHAT IS A METHOD?

 Procedural attribute
 Think of it 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

21

6.100L Lecture 17
Implementing the class Using the class

DEFINE A METHOD
FOR THE Coordinate CLASS

class Coordinate(object):
def __init__(self, xval, yval):
self.x = xval
self.y = yval
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
 Other than self and dot notation, methods behave just
like functions (take params, do operations, return)
22

6.100L Lecture 17
HOW TO CALL A METHOD?

 The “.” operator is used to access any attribute

 A data attribute of an object (we saw c.x)
 A method of an object
 Dot notation
<object_variable>.<method>(<parameters>)

 Familiar?
my_list.append(4)
my_list.sort()
23

6.100L Lecture 17
 Implementing the class Using the class

Recall the definition of distance method:

def distance(self, other):
HOW TO USE A METHOD
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

Using the class:

c = Coordinate(3,4)
orig = Coordinate(0,0)
print(c.distance(orig))

 Notice that self becomes the object you call the

method on (the thing before the dot!)
24

6.100L Lecture 17
 VISUALIZING INVOCATION

 Coordinate class is an object in

memory self.x
self.y
 From the class definition Coordinate __init__: some code
distance: some code
 Create two Coordinate objects
Type: Coordinate
c = Coordinate(3,4) c x: 3
y: 4
orig = Coordinate(0,0)
Type: Coordinate
orig x: 0
y: 0

25

6.100L Lecture 17
 VISUALIZING INVOCATION

 Evaluate the method call

c.distance(orig) self.x
self.y
Coordinate __init__: some code
 1) The object is before the dot distance: some code

 2) Looks up the type of c Type: Coordinate

c x: 3
 3) The method to call is after the y: 4

dot. Type: Coordinate

 4) Finds the binding for orig x: 0
y: 0
distance in that object class
 5) Invokes that method with
c as self and
orig as other
26

6.100L Lecture 17
Implementing the class Using the class

HOW TO USE A METHOD

 Conventional way  Equivalent to

c = Coordinate(3,4) c = Coordinate(3,4)
zero = Coordinate(0,0) zero = Coordinate(0,0)
c.distance(zero) Coordinate.distance(c, zero)

27

6.100L Lecture 17
 BIG IDEA
The . operator accesses
either data attributes or
methods.
Data attributes are defined with self.something
Methods are functions defined inside the class with self as the first parameter.

28

6.100L Lecture 17
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 behaviors
from other classes of objects
 Create our own classes of objects on top of Python’s
basic classes

29

6.100L Lecture 17
MITOpenCourseWare
https://ocw.mit.edu

6.100L Introduction to Computer Science and Programming Using Python

Fall 2022

For information about citing these materials or our Terms ofUse,visit: https://ocw.mit.edu/terms.

30