- Controlling Conversion 6:24
- Dream Car 1 objective
- Math 6:22
- Multiplication 2 objectives
- Emulating Built-ins 8:01
- Iterable Album 1 objective
- Subclassing Built-ins 10:28
- Double 3 objectives
- Frustration 1 objective
- Constructicons 5:26
- Dream Vacation 1 objective
- Special Methods 7:30
- Proper Properties 2 objectives
Preview
Video Player
00:00
00:00
Math
6:22What if our instances should be able to be used with mathematical operations? Let's define that!
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