The following content is
provided under a Creative
Commons license.
Your support will help
MIT OpenCourseWare
continue to offer high quality
educational resources for free.
To make a donation or
view additional materials
from hundreds of MIT courses,
visit MIT OpenCourseWare
at ocw.mit.edu.
PROFESSOR: All right everyone.
Let's get started.
So today's lecture and
Wednesday's lecture,
we're going to talk
about this thing called
object oriented programming.
And if you haven't
programmed before,
I think this is a fairly
tough concept to grasp.
But hopefully with
many, many examples
and just by looking at the
code available from lectures,
you'll hopefully get
the hang of it quickly.
So let's talk a little
bit about objects.
And we've seen objects
in Python so far.
Objects are basically
data in Python.
So every object that we've
seen has a certain type.
OK, that we know.
Behind the scenes,
though, every object
has these two additional things.
One is some data representation.
So how Python represents the
object just behind the scenes
and what are different
ways that you
can interact with the object.
So for example, every one of
these is a different object.
For example, this
is the number 1,234.
It's a specific object
that is of type integer.
The number 5 is a different
object that's of type integer
and so on.
We've seen floats.
We've seen strings.
We've seen lists.
Lists and dictionaries are
more complicated objects.
Object types.
Sorry.
But every object has a
type, some sort of way
that it's represented
in Python and some ways
that we can interact with them.
OK.
So the idea behind object
oriented programming
is, first of all, everything
in Python is an object.
We've said that before
and in this lecture
I think we'll really
get at what that means.
So we've seen strings,
integers, dictionaries, lists.
Those are all objects.
When we did functions,
we saw that we
could pass as a parameter
another function.
So functions were also
objects in Python.
So literally everything
in Python is an object.
So what are the kinds of
things we can do with objects?
Well, once you have a type,
you can create a new object
that is of some type.
And you can create
as many objects
as you'd like of that
particular type, right?
An integer 5 and integer 7.
Those all work in a program.
Once you've created
these new objects,
you can manipulate them.
So for a list, for example,
you can append an item
to the end of the list,
you can delete an item,
remove it, concatenate
two lists together.
So that's ways that you
can interact with objects.
And the last thing you can
do is you can destroy them.
So and with lists,
we saw explicitly
that you can delete
elements from a list,
or you can just
forget about them
by reassigning a variable
to another value,
and then at some
point, Python will
collect all of these dead
objects and reclaim the memory.
So let's continue
exploring what objects are.
So let's say I have these
two separate objects.
One is a blue car.
One is a pink car.
So objects are really
data abstractions.
So these two cars can be
created by the same blueprint.
OK?
This is a blueprint for a car
and if an object is a data
abstraction, there's two
things that this abstraction
is going to capture.
The first is some sort
of representation.
What is going to represent the
car, what data represents a car
object?
And the second is
what are ways that we
can interact with the object?
So if we think about
a car blueprint,
some general
representation for a car
could be the number of wheels
it has, the number of doors
it has, maybe its
length, maybe its height,
so this is all part of what
data represents the car.
OK?
The interface for
the car is what
are ways that you
can interact with it.
So for example, you
could paint a car, right?
So you could change its color.
You could have the
car make a noise
and different cars might
make different noises.
Or you can drive the car, right?
So these are all ways that
you can interact with the car.
Whereas the representation
are what makes up the car.
What data abstractions
make up the car.
Let's bring it a little closer
to home by looking at a list.
So we have this data
type of list, right?
We've worked with lists before.
The list with elements 1, 2, 3,
and 4 is a very specific object
that is of type list.
Again, we think about it
in terms of two things.
One is what is the data
representation of the list?
So behind the scenes how
does Python see lists?
And the second is, how do
you interact with lists?
So what are ways that
you can manipulate a list
object once it's created?
So behind the scenes
you have a list, L,
which is going to be made up
of essentially two things.
One is going to be the
value at specific index.
OK?
So at index 0, it has
the value 1, right,
because it's the first
element in the list.
And the second thing
that represents a list
is going to be this second
part, which is a pointer.
And internally this
pointer is going
to tell Python
where is the memory
location in the computer where
you can access the element
index 1.
So it's just essentially
going to be a chain,
going from one
index to the other.
And at the next memory location
you have the value at index 1,
and then you have
another pointer
that takes you to the
location in memory
where the index 2 is located.
And in index 2 you
have the value and then
the next pointer,
and so on and so on.
So this is how Python
internally represents a list.
OK?
How you manipulate lists,
we've done this a lot, right?
You can index into a list, you
can add two lists together,
you can get the length, you can
append to the end of a list,
you can sort a list, reverse a
list, and so many other things,
right?
So these are all
ways that you can
interact with the list object
as soon as you've created it.
So notice both of these,
the internal representation
and how you
manipulate lists, you
don't actually
know internally how
these are represented, right?
How did whoever
wrote the list class
decide to implement a sort.
We don't know.
You also weren't aware of how
these lists were represented
internally.
And you didn't
need to know that.
That's the beauty of
object oriented programming
and having these
data abstractions.
The representations are
private of these objects
and they are only known by what
you can find out how it's done,
but they only should be known
by whoever implemented them.
You, as someone who
uses this class,
doesn't really need to know
how a list is represented
internally in order
to be able to use it
and to write cool
programs with them.
OK?
So just find a
motivation here before we
start writing our
own types of objects
is the advantages of
object oriented programming
is really that
you're able to bundle
this data, bundle some
internal representation,
and some ways to interact with
a program into these packages.
And with these packages,
you can create objects
and all of these
objects are going
to behave the exact same way.
They're going to have the
same internal representation
and the same way that you
can interact with them.
And ultimately, this is going to
contribute to the decomposition
and abstraction ideas
that we talked about when
we talked about functions.
And that means that
you're going to be
able to write code that's a lot
more reusable and a lot easier
to read in the future.
OK.
So just like when we
talked about functions,
we're going to sort
of separate the code
that we talk about today into
code where you implement a data
type and code where you use
an object that you create.
OK?
So remember when we
talked about functions,
you were thinking about it in
terms of writing a function,
so you had to worry
about the details of how
you implement a function.
And then you had
to worry about just
how to use a function, right?
So it's sort of the
same idea today.
So when you're thinking about
implementing your own data
type, you do that with
this thing called a class.
And when you create
a class, you're
basically going to
figure out what name you
want to give your
class and you're
going to find some attributes.
And attributes are
going to be the data
representation and ways that you
can interact with your object.
So you, as the
programmer of this class,
are going to decide
how you want people
to interact with the object
and what data this object
is going to have.
So for example,
someone wrote code
that implements a
list class, right,
and we don't actually
know how that was done.
But we can find out.
So creating the class is
implementing the class
and figuring out data
representation and ways
to interact with the class.
Once that's done, you
can then use your class.
And you use the
class by creating
new instances of the class.
So when you create
a new instance,
you essentially
create a new object
that has the type, the
name of your class.
And you can create as many
objects as you'd like.
You can do all the
operations that you've
defined on the class.
So for example,
someone wrote the code
to implement list class
and then you can just
use the list class like this.
You can create a new list, you
can get the length pf the list,
you can append to the end of
the list, and so on and so on.
So let's start defining
our own types, OK?
So now you're going
to define classes,
you're going to
write classes which
are going to define your
own types of objects.
So for today's
lecture we're going
to look at code
that's going to be
in the context of a
coordinate object.
And a coordinate
object is essentially
going to be an object
that's going to define
a point in an xy plane.
So x, y is going to be a
coordinate in a 2D plane.
So we're going to
write code that's
going to allow us to
define that kind of object.
So the way we do that is
we have to define a class.
So we have to tell Python,
hey, I'm defining my own object
type.
So you do that with
this class key word.
So you say class, then you
say the name of your type.
In this case, we're creating
a type called coordinate.
Just like we had type list,
type string, and so on.
This is going to be a
type called coordinate.
And then in
parentheses here, you
put what the parents
of the class are.
For today's lecture, the
parent of the classes
are going to be this
thing called object,
and object is the very
basic type in Python.
It is the most basic
type in Python.
And it implements things like
being able to assign variables.
So really, really
basic operations
that you can do with objects.
So your coordinate
is therefore going
to be an object in Python.
All right.
So we've told Python we
wanted to define an object.
So inside the class definition
we're going to put attributes.
So what are attributes?
Attributes are going to be
data and procedures that
belong to the class, OK?
Data are going to be the data
representations and procedures
are going to be ways that we
can interact with the object.
The fact that they
belong to the class
means that the data and the
procedures that we write
are only going to work with
an object of this type.
OK.
If you try to use any of
the data or the procedures
with an object of
a different type,
you're going to get an
error because these data
and these attributes will
belong to this particular class.
So the data attributes is,
what is the object, right?
What is the data that
makes up the object?
So for our coordinate
example, it's
going to be the x and y
values for coordinate.
We can decide that
can be ints, we
can decide that we can
let them be floats,
but it's going to have one
value for the x-coordinate
and one value for
the y-coordinate.
So those are data attributes.
And procedure attributes
are better known as methods.
And you can think of a
method as a function.
Except that it's a
function that only
works with this
particular type of object.
So with a coordinate
object, in this case.
So the methods are
going to define how you
can interact with the object.
So in a list, for
example, we've said
that you can append an item
to the end of the list,
we can sort a list,
things like that.
So when you're defining
methods, you're
defining ways that people can
interact with your object.
So for example, for
a coordinate object,
we can say that we can take
the distance between two
coordinate points.
OK?
And that's going to be a
way that you can interact
with two coordinate points.
And just to be clear,
these are going
to belong to this
class, which means
that if you try to use this
distance method on two lists,
for example, you're
going to get an error.
Because this distance method was
only defined to work with two
coordinate type objects.
All right, so let's
carry on and continue
implementing our class.
So we've written this
first line so far,
class coordinate object.
So now let's define attributes.
First thing we're going to
define are data attributes.
Generally you define data
attributes inside this init,
and this is underscore,
underscore, init, underscore,
underscore, and it's a special
method or function in a class.
And the special
method tells Python,
when you implement
the special method,
it tells Python when you first
create an object of this type,
call this method or
call this function.
So how do we do that?
So let's implement it.
So we say df because
it's just a function.
The name is the
special name, init.
And we give it some
parameters, right,
just like any other function.
These last two
parameters are x and y,
which are going to represent how
you create a coordinate object.
So you give it a value
for the x-coordinate
and you give it a value
for the y-coordinate.
The self, however, is
a little bit trickier.
So the self is going
to be a parameter when
you define this
class that represents
a particular instance
of the class.
So we're defining
this coordinate object
in sort of a general way, right?
We don't have a
specific instance
yet because we haven't
created an object yet.
But this self is
going to be sort
of a placeholder for
any sort of instance
when you create the object.
So in the definition
of the class,
whenever you want to
refer to attributes
that belong to an instance,
you have to use self dot.
So this dot notation.
And the dot is going to say
look for a data attribute
x that belongs to this class.
So for methods that
belong to the class,
the first parameter is
always going to be self.
It can be named
anything you want,
but really by convention
it's always named self.
So try to stick to that.
And then any other
parameters beyond it
are going to be just
parameters as you
would put in a normal function.
OK.
In this particular
case, we're going
to choose to initialize
a coordinate object
by two values, one for
the x and one for the y.
And inside this
init method, we're
going to have two assignments.
The first one says,
the x data attribute
of a coordinate object.
I'm going to assign it to
whatever was passed in.
And the y data attribute
for a particular object
is going to be assigned
whatever y was passed in.
Questions so far about
how to write this init?
Yeah, question.
AUDIENCE: [INAUDIBLE]
PROFESSOR: How do you
make sure that x and y
are inits or floats?
So this is something
that you could
write in the specifications,
so the docstring
with the triple quotes.
So whoever uses the
class would then
know that if they do something
outside the specification,
the code might not
work as expected.
Or you could put
in a cert statement
inside the definition
of the init just
to sort of force that.
Force that to be true.
Great question.
Yeah, question.
AUDIENCE: [INAUDIBLE]
PROFESSOR: Does the x,
does this self x and this x
have to be the same name.
The answer is no.
And we're going to
see in class exercise
that you can have
it be different.
OK.
Great.
So this defines the way
that we create an object.
So now we have sort
of a nice class.
It's very simple, but
we can start actually
creating coordinate objects.
So when you create
coordinate objects,
you're creating
instances of the class.
So this line here, C is
equal to coordinate 3,4,
is going to call
the init method.
It's going to call the init
method with x is equal to 3
and y is equal to 4.
I'm just going to go over here
and I wrote this previously,
because notice when we're
creating an object here,
we're only giving
it two parameters.
But in the init method, we
have actually three parameters,
right?
We have these three
parameters here,
but when we're
creating an object,
we only give it two parameters.
And that's OK because
implicitly, Python
is going to say self is going
to be this object C, so just
by default, OK?
So when you're creating
a coordinate object,
you're passing it all the
variables except for self.
So this line here is
going to call the init
and it's going to do every
line inside the init.
So it's going to create
an x data attribute for C,
a y data attribute
for C, and it's
going to assign 3 and 4
to those respectively.
This next line here is
origin equals coordinate 0,
0 creates another object.
OK?
It's another coordinate
object whose value for x is 0
and whose value for y is 0.
So now we have two
coordinate objects.
We can access the
data attributes
using this dot notation and
we've seen that before, right?
When we've worked with lists
we'd say something like,
L dot append, right,
when we create a list.
So the same dot notation can
be used with your own objects
in order to access
data attributes.
So here, this is
going to print 3
because the x value
for object C is 3,
and the next line,
print origin x
is going to print 0 because the
x value for the object origin
is 0.
OK.
So we've created a
coordinate object.
We have to find the
init method so we
have a way to create objects
when we use the class.
And then we can access
the data attributes.
But that's kind of lame, right,
because there isn't anything
cool we can do with it.
There isn't ways to
interact with this object.
So let's add some methods.
Remember methods are going to
be procedural attributes that
allow us to interact
with our object.
Methods are like functions
except that there's
a couple of differences
which you'll see in a moment.
And when you're
calling methods, you're
using the dot operator, like
L dot append, for example,
for lists.
So let's go back to defining
our coordinate class
and let's define
a method for it.
So so far we've defined
that part there,
class coordinate and an init.
So we have that.
So in this slide we're going
to add this method here.
So this method here
is going to say
I'm going to define a
method called distance
and I'm going to pass
in two parameters.
Remember self, the
first parameter,
is always going to be
the instance of an object
that you're going to
perform the operation on.
So pretty much by convention
it's always named self.
And then for this
particular method,
I'm going to give it
another parameter,
and I can name this
whatever I want.
I'm naming it other.
And this is going to represent
the other coordinate object
for which I want to find
the distance from my self.
So here I'm going
to just implement
the Euclidean distance formula,
which is x1 minus x2 squared,
plus Y1 minus Y2 squared,
and square root of all that.
So that's what I'm
doing inside here.
Self and other are
coordinate objects.
Inside this method, I have
to refer to the x data
attributes of each
object if I want
to find the difference between
the 2x values from them.
So that's why I'm doing
self dot x here, right.
If I just did x, I would be
accessing just some variable
named x in a program which
actually isn't even defined.
So you always have to
refer when as we're
thinking about
classes, you always
have to refer to
whose data attribute
do you want to access?
In this case, I want
to access the x data
attribute of my self, and I
want to subtract the x data
attribute of this
other coordinate,
square that, same for y,
square that, and then add those
and take the square
root of that.
So notice this method is pretty
much like a function, right?
You have DF, some name,
it takes in parameters.
It does some stuff and
then it returns a value.
The only difference is the
fact that you have a self here
as the first thing and
the fact that you always
have to be conscious about
whose data attributes
you're accessing.
So you have to use the
dot notation in order
to decide whose data
attributes you want access.
So we've defined the
method here, distance.
So this is in the
class definition.
Now how do we use it?
So let's assume that the
definition of distance
is up here.
I didn't include the code.
But really all you need
to know is what it takes.
It takes a self and an other.
So when you want
to use this method
to figure out a distance
between two coordinate objects,
this is how you do it.
So the first line, I create
one coordinate object.
Second line, I create
another coordinate object.
First one is named C, the
second one is named 0.
These are two separate objects.
And I'm going to
find the distance.
And I want to first
call it on one object,
so I'm going to say C dot,
so I'm using the dot notation
to call the method
distance on object C.
So Python says this object
C is of type coordinate.
It's going to look
up at the class
coordinate that you defined.
It's going to find this
method called distance
and then it's going to say
what parameters does it take?
So it takes another parameter,
right, for the other
and then, in the
parentheses, I just
have to give it this
other perimeter.
An easier way to
see what happens
is by looking at what this
line here is equivalent to.
So the third line
here prints C dot
distance 0 is equivalent
to this one on the right.
And this one on the
right essentially
says, what's the
name of the class,
dot, dot notation, what's
the method you want to call,
and then in
parentheses you give it
all of the variables
including self.
OK.
So in this case you're
explicitly telling Python
that self is C and other is 0.
So this is a little bit easier
to understand, like that.
But it's a little cumbersome
because you always
have to write coordinate dot,
coordinate dot, coordinate dot,
for every data
attribute you might want
to access, for every
procedural attribute you
might want to access.
So by convention,
it's a lot easier
to do the one on the left.
And as I mentioned,
Python implicitly says,
if you're doing the
one on the left,
you can call this method
on a particular object
and it's going to look
up the type of the object
and it's going to essentially
convert this on the left
to the one on the right.
And this is what you've
been using so far.
So when you create a list,
you say L is equal to 1, 2,
and then you say L.append,
you know, 3 or whatever.
So we've been using this
notation on the left
pretty much from the
beginning of class.
So we have a
coordinate class, we
can create a
coordinate object, we
can get the distance
between two objects.
As you're using
the class, if you
wanted to use this
coordinate class,
and you were maybe debugging
at some point, a lot of you
probably use print as a
debug statement, right?
And maybe you want to print the
value of a coordinate object.
So if you create a
coordinate object,
C is equal to
coordinate 3, 4, right?
That's what we've done so far.
If you print C, you
get this funny message.
Very uninformative, right?
It basically says, well,
C is an object of type
coordinate at this memory
location in the computer.
Which is not what you
wanted at all, right?
Maybe you wanted to know what
the values for x and y were.
That would be a lot
more informative.
So by default, when you
create your own type, when
you print the
object of that type,
Python tells you this
sort of information
which is not what you want.
So what you need
to do is you need
to define your own
method that tells
Python what to do
when you call print
on an object of this type.
So this is going to be
a special method, just
like init is, because
it starts and ends
with double underscores.
And the name of the method is
underscore, underscore, str,
underscore, underscore.
And if you define this method in
your class, that tells Python,
hey, when you see a
print statement that's
on an object of type
coordinate, call this method,
look what it does, and do
everything that's inside it.
And you can choose to make
it do whatever you want
inside your definition of str.
In this case, let's say when
we print a coordinate object,
we're going to print its
x and y values surrounded
by angle brackets.
That seems reasonable, right?
So then from now on when you
print coordinate objects,
you're going to see
things like this, which
is a lot more informative.
So how do we define this?
So so far we've defined
all that and the last part
is going to be new.
So we define the init
and the distance,
and let's define this str.
So underscore, underscore,
str, underscore, underscore, is
a method.
It's only going to take self
because you're just calling
print on the object itself.
There's no other
parameters to it.
Str has to return a string,
and in this particular case,
we're going to return
the string that's
the angle brackets concatenated
with the x value of the object,
self.x, concatenated
with a comma,
concatenated with the y value
of this particular instance
of an object, self.y,
and then concatenated
with the angle brackets.
So now any time you have
print on an object of type
coordinate, you're going to
call this special method str,
if it's implemented
in your code.
Any questions?
OK.
So let's try to wrap our
head around types and classes
because we've seen a lot today.
Let's create a
coordinate object,
assign it 3, 4, as we have been,
and assign it to variable C.
We've implemented the str
method, so when we print C,
it's going to print out this
nice three comma for our angle
brackets.
If we print the type
of C, this is actually
going to give us class main
coordinate, which tells us
that C is going to
be an object that
is of type class coordinate.
If we look at
coordinate as a class,
if we print what coordinate is,
coordinate is a class, right?
So this is what Python tells
us, if we print coordinate,
it's a class named coordinate.
And if we print the
type of a coordinate,
well that's just
going to be a type.
So class is going to be a type.
So you're defining
the type of an object.
If you'd like to figure out
whether a particular object is
an instance of a
particular class,
you use this special
function called is instance.
So if you print is instance
C comma coordinate,
this is going to print true
because C is an object that
is of type coordinate.
Couple more words on
these special operators.
So these special
operators allow you
to customize your classes which
can add some cool functionality
to them.
So these special
operators are going
to be things like
addition, subtraction,
using the equal equal sign,
greater than, less than,
length and so on and so on.
So just like str,
if you implement
any of these in your classes,
this is going to tell Python.
So for example, if we've
implemented this underscore,
underscore, add, underscore,
underscore in our class,
this is going to
tell Python when
you use this plus operator
between two objects of type
coordinate to call this method.
If you have not
implemented this method
and you try to add two
objects of type coordinate,
you're going to get an error
because Python doesn't actually
know right off
the bat how to add
two coordinate objects, right?
You have to tell
it how to do that.
And you tell it how to
do that by implementing
this special method.
Same with subtract.
Same with equals.
So if you want to figure out
whether two objects are equal.
And when you implement these
methods in your own class,
you can decide exactly
what you want to do.
So what happens when you
add two coordinate objects?
Do you just add the x values,
do you just add the y values,
do you get them both
together, do you
do whatever you'd like to do.
And then you document
what you've decided.
So let's create a
fraction object.
So we've looked
at coordinate, we
saw sort of a higher
level car object.
Let's look at a fraction object.
Fraction object
is going to be, is
going represent a number that's
going to be a numerator slash
denominator.
OK.
So that's going to
be a fraction object.
So the way I've decided to
internally represent a fraction
object is with two numbers.
And I've decided that I
will not let them be floats.
They have to be integers,
hence the assert over here.
So inside the init,
I've decided I'm
going to represent my
fracture with two numbers, one
for the numerator and
one for the denominator.
So when I create
a fraction object,
I'm going to pass in a
numerator and a denominator.
And a particular
instance is going
to have self dot
numerator and self dot
denominator as its
data attributes
and I'm assigning those to be
whatever's passed into my init.
Since I plan on debugging this
code maybe possibly sometime
in the future, I'm also
including an str method
and the str method is going
to print a nice looking string
that's going to represent
the numerator, and then
a slash, and then
the denominator.
And then I've also implemented
some other special methods.
How do I add two fractions?
How do I subtract two fractions?
And how do I convert
a fraction to a float?
The add and subtract
are almost the same,
so let's look at the
add for the moment.
How do we add two fractions?
We're going to take self, which
is the instance of an object
that I want to do
the add operation on,
and we're going to
take other, which
is the other
instance of an object
that I want to do the
operation on, so the addition,
and I'm going to
figure out the new top.
So the new top of the
resulting fraction.
So it's my numerator multiplied
by the other denominator
plus my denominator multiplied
by the other numerator
and then divided by the
multiplication of the two
denominators.
So the top is going to be that,
the bottom is going to be that.
Notice that we're
using self dot, right?
Once again, we're
trying to access
the data attributes of
each different instance,
right, of myself and the other
object that I'm working with.
So that's why I have
to use self dot here.
Once I figure out the top and
the bottom of the addition,
I'm going to return,
and here notice I'm
returning a fraction object.
It's not a number, it's not
a float, it's not an integer.
It's a new object that is of
the exact same type as the class
that I'm implementing.
So as it's the same
type of object,
then on the return
value I can do
all of the exact same
operations that I can do
on a regular fraction object.
Sub is going to be the same.
I'm returning a fraction object.
Float is just going to
do the division for me,
so it's going to
take the numerator
and then divide it
by the denominator,
just divide the numbers.
And then I'm defining here
my own method called inverse.
And this is just going to take
the inverse of the instance I'm
calling this method on.
And so it's going to also return
a new fraction object that just
has the denominator
as the top part
and the numerator
as the bottom part.
So then we have some code here.
So that's how I implement
my fraction object.
So now let's use it and
see what it gives us.
A is equal to a fraction 1, 4.
This is going to
be 1 over 4 for a.
And b is going to
be 3 over four.
When I do C, notice I'm using
the plus operator between two
fraction objects, right?
A and b are fraction
objects so Python's
going to say, OK, is there an
underscore, underscore, add,
underscore, underscore,
method implemented?
It is and it's just going to
do whatever's inside here.
So it's going to say self
dot numerator plus other dot
denominator.
It's going to calculate
the top and the bottom.
It's going to turn a
new fraction object.
So this is going to be 4 plus 12
divided by 16, and 16 over 16.
So C as a fraction
object is going
to be 16 for the numerator
and 16 for the denominator
because it's a fraction object.
If I print C, it should
print 16 over 16,
so we can even run it,
so print 16 over 16.
If I print floats C, so this
special method float here
is going to say, is there a
method that converts a fraction
to a float and there is.
It's this one
implemented right here.
So it's just going to divide
the two numbers, top and bottom,
which gives me 1.
So it's this one here and here.
Notice I'm doing the
exact same method call,
except I'm doing it
the other way where
you type in the name of the
class, name of the method,
and then what you're
calling it on,
and this gives the exact
same value here, 1.0.
And then here I'm calling
the method inverse
on object B which is going to
invert 3 over 4 to be 4 over 3.
And then I'm converting
it to a float
and then I'm printing the value.
So it gives me 1.33.
So take a look at this
code in more detail
and see if you can trace through
all of those different things
and see if you can also write
your own new fraction objects.
OK.
So last slide.
Power of object
oriented programming
is that you can bundle
together objects that
are of the exact same type.
And all of these
objects are going
to have the same
data representation
and the same methods
that you can do on them.
And ultimately, you're
going to be building
these layers of abstraction.
So you're going to be building
on a basic object type
in Python, you're going to have
integer objects, float objects.
On top of those, you can
create lists, dictionaries.
And on top of
those, you can even
create your own object types as
we saw in this lecture today.
