Heads up! To view this whole video, sign in with your Courses account or enroll in your free 7-day trial. Sign In Enroll
Preview
Start a free Courses trial
to watch this video
What if our instances should be able to be used with mathematical operations? Let's define that!
Just like the other magic methods, there are a lot of math-related ones, too. Again, don't feel like you have to memorize them, but definitely play around with a few to get a feel for how they work.
Related Discussions
Have questions about this video? Start a discussion with the community and Treehouse staff.
Sign upRelated Discussions
Have questions about this video? Start a discussion with the community and Treehouse staff.
Sign up
There are several magic methods
that are used in Math operations.
0:00
I don't think it make sense
to go over all of them.
0:05
But let's look at a couple, and
0:07
at least get our class to a point
where we can add things to it.
0:08
And then by that point you should
be able to figure out how to
0:12
add the other math operations yourself.
0:14
The first is dunder add,
so let's do dunder add.
0:17
And this takes two arguments,
0:22
this is our first one that
takes more than one argument.
0:23
It takes self, and
then normally we just call this one other.
0:26
But you can call this whatever you want,
0:29
this represents the other thing on
the other side of the plus sign.
0:31
So, we're gonna return
self.value + str(other).
0:35
Okay, so let's try that out.
0:40
And we want to go into Python.
0:46
From numstring, import NumString.
0:49
And let's say, five = NumString(5).
0:52
And let's try to do five + 4.
0:58
54.
1:01
54, I don't know how useful that is,
I mean,
1:02
it's fun, it's a bit cheeky,
it gives us this JavaScript kind of thing,
1:05
right?, but
it seems like something I would use never.
1:10
Okay, it'd definitely be more useful to
get back a nine from that than a five,
1:14
four, right?, or a 54.
1:18
So, let's hop out of there,
and let's come edit this __add__.
1:20
So, let's do a bit of logic here, right?
1:25
So if there's a dot self.value,
1:27
then we want to return
float(self) + other.
1:32
Otherwise, we're just gonna
return the int(self )+ other.
1:38
And we don't need that line.
1:43
It would never get run anyway,
because it's after our always return.
1:44
All right, so we checked to see if
there's a period inside the value.
1:49
If there is, we're going to
consider that to be a float.
1:55
And, if so, then we're gonna return
the float version of our object,
1:58
plus whatever the other object is.
2:02
And if there's not a dot,
we consider it to be an int,
2:05
and then we'll return the int version
of our object plus the other object.
2:07
All right, let's try that out.
2:12
And let's say,
from numstring import NumString.
2:16
And let's just try,
let's not make instances of this.
2:20
But let's say, NumString(4) + 5.
2:23
We get back 9, cool.
2:26
What about NumString(2.2) + 2?
2:28
I should get 4.2, and I do.
2:31
That's a lot more useful, right?
2:34
Now, this only works when our NumString
2:37
is on the left hand side of
the plus sign though, right?
2:39
Let's try this like 2 + NumString(2).
2:42
I should get 4, but no I get TypeError.
2:46
If our instance is on the right hand side,
we get a TypeError right now.
2:49
It's, because we're missing
another magic method.
2:52
We need to implement
the dunder radd dunder method.
2:55
Now, you might think the r is for right,
2:59
cuz I just said we have to do this
thing for dunder on the right side.
3:01
But it's actually not for
right, it's for reflected.
3:05
Python tries to do the normal math int +
NumString, but doesn't know how to do that
3:09
since NumString isn't a type
it knows how to do math with.
3:14
So, then it checks how to swap or
reflect the values around, but
3:17
NumString doesn't have a, here's how to
do math with me when you've reflected me,
3:21
method, so that fails too.
3:26
So, let's add our radd method,
3:28
it's gonna take self and
it's gonna take other.
3:32
If we were to type this out,
it would be identical to our __add__..
3:37
We would check to see if
there's a plus sign, and if so
3:41
return the float plus the other.
3:44
Otherwise, return the int plus the other.
3:46
And we could write all that out.
3:49
Or we could just do the right
thing in the method.
3:51
Because really what we want,
is we want to return self + other.
3:54
So, just whatever that would be,
so when you reflect me,
3:56
just reflect me on back to the other side.
3:59
Now, we'll just do normal addition anytime
we have to do reflective addition.
4:02
Now, that won't always be
the correct solution for your class.
4:06
You have to think about your class,
4:11
think about how your class should handle
when it's on one side versus the other.
4:12
But this is the way ours is gonna work for
now.
4:17
Let's look for one more addition related
magic method before we go test this out.
4:21
Now, right now our NumString is for
all intents and purposes, immutable.
4:27
We can could change the value attribute,
4:31
but an outsider wouldn't
even know it was there.
4:33
They wouldn't know to go
five dot value equals ten.
4:35
They would just know that they
had this string-like number, and
4:40
they could add things to it.
4:43
Well, what if we want to be able to
do something like age is equal to
4:45
NumString(25), and then age plus equals 1.
4:50
We can't.
4:53
At least not yet,
4:54
to bring in this behavior we have to
create the dunder iadd, dunder method.
4:55
The i stands for in place.
4:59
So, let's say, dunder iadd self, and
5:02
again, this takes an other,
it takes something to add to it.
5:06
And we'll say, self.value = self + other.
5:09
And then we'll return self.value.
5:14
Cuz I like to get something back
from my methods if I can help it.
5:16
All right.
Let's try this out.
5:21
Let's make sure that our __radd__, and
5:22
our __iadd__ are working just
like we expect them to do.
5:25
From numstring import NumString.
5:30
And let's say,
that name is equal to NumString (25).
5:33
We'll pretend that I'm 25.
5:36
All right, so
let's do age + 5 you should get 30, okay.
5:38
5 + age, we should get 30, cool.
5:42
So, we know that __add__ and __radd__
are working.
5:45
And it's being my birthday, so I'm
gonna do age += 1, I would get 26 back.
5:48
And if I look at age I get 26.
5:54
Now, I didn't actually get anything back,
5:56
because += doesn't Print out
the value that was returned.
5:58
But if I had something that was doing
that, that's what I would now see.
6:01
And then when I look at age,
age is now 26.
6:05
So, cool, that really wasn't that bad.
6:07
As you can imagine, there are magic
methods for implementing division,
6:11
multiplication, exponents and more.
6:14
I have links to the docs for them in
the teacher's notes, so check them out.
6:16
You might just need them
in the next code challenge.
6:19
You need to sign up for Treehouse in order to download course files.
Sign upYou need to sign up for Treehouse in order to set up Workspace
Sign up