I think we're going to leave our role playing game characters behind.

They were really handy for exploring brand new classes but a lot of the power in

object oriented design comes from taking advantage of the classes and

objects provided by your language.

Python gives us tons of objects that we can use as the basis of our

own custom ones.

We've been really heavy into magic methods in this stage.

That's not gonna change now.

When you're dealing with custom versions of built-ins,

there are two magic methods that you'll want to know about above all others.

Init and new.

You've already seen init,

we use it when we want to customize how a new instance of a class is created.

New works very similarly but

has some special magic that we're not quite ready for it just yet.

The major difference between the two though is when you use them.

If you're customizing a mutable data type like list, you override init.

If you're customizing an immutable type, you use new.

Let's go to work spaces to try these new methods out.

All right, so let's start with an immutable class first.

How about we make a version of string, of STR that is always reversed.

I know, I know, you just thought of a million uses for such a thing.

How it's not already built into the library,

I don't know, we'll just have to submit I guess.

[LAUGH] First things first, I have a file named reversedstr.py,

and we need to go ahead and create our class.

So I'm gonna call it ReversedStr, because that's what it is, right?

I don't wanna confuse anyone.

I don't want them thinking this is a normal string.

And instead of going straight to the colon,

I'm going to extend it with str or I'm going to make it extend str.

So then I'm just going to say pass.

And if I use the class right now, it's a string.

Now let's just go ahead and do it.

So Python from reversesdtr import ReversedStr.

rs = ReversedStr('hello'),

and rs is hello, right?

And len(rs) I get 5.

So yep, that's a string.

Okay, so we want to change what happens when the string is created.

Since strings are immutable,

the only place we should change them is at creation time.

We do that in new for immutable objects.

So we're gonna say def __new__( And

this is going to take whatever args and kwargs come in, just in case.

And then, we're gonna say, self =, and self here is just a variable name,

we don't have to call it self, but self = str._

_new_ _ (args, kwargs).

And then we're gonna say self = self reversed, ::-1.

And then we're going to return self.

Unlike init, new does a return.

Now did you notice that new doesn't take self?

That's because new is a special kind of method known as a class method.

We'll talk more about them in a later video, but for now,

just now that they're methods that operate on a class, and not on an instance.

And inside of here, why aren't we using super?

Well, with immutable types like this,

it can actually be unsafe to use super inside of new.

It's safer and easier to explicitly use the new method of the class that

you're extending directly, which is why we did the str.__new__.

And then of course, we're gonna go ahead and reverse our string, and return it.

So does this work?

Let's find out.

Python, let's just import reversedstr, that's a little bit easier.

And then let's say rs = reversedstr.ReversedStr( And

I'm gonna say hello again.

And now let's look at rs.

I got olleh, ole.

It does, all right.

Well, great.

That was easier than I expected.

What if we wanted to make a sub-class of list, though?

Now, since list is mutable, we'll have to override init instead of new.

We should come up with something to make first, though.

Let's borrow something from the data science world, at least partially, very,

very partially.

And build a list that can be prefilled with a certain number of numbers.

So I'm gonna make a New File for this, I'm gonna call it filledlist.py

And then inside of here I'm actually going to import a library called copy,

and then I'll make my class, FilledList.

And this is going to extend list, and I need to override init.

And I know init takes self.

All right, so I'm gonna take args and

kwargs because If anybody passes me an iterable or

something like that that they want made into a list, I want to accept that.

But basically I'm going to ignore it.

I want two other arguments.

I want a count argument, and

a value argument, so how many do you want, and what do you want, right?

So I want five zeros.

So, first things first, let's go ahead and super, and then init.

And we're going to ignore everything that was passed in.

I don't care what they gave me.

All I want is an empty list when I get to the end of this, okay?

So at this point,

right now, I have a brand new, empty list instance, stored inside of self.

That I can just do whatever I want with.

So now, I use a for loop that'll go through the count and we'll do something.

Now this underscore here ignores

the number that would come out of range, right?

So, range would normally be zero, one, two, three, four, five,

whatever I don't care about that, so I'm going to ignore it.

And that's what underscore let's me do.

I could just use like x and then never use x there.

But underscore is cleaner and implies that you don't care about this value.

All right, so then I'm going to append a copy

of whatever it is that they gave me, whatever the value is that they gave me.

So I'm gonna use copy.copy.

And then value.

So I will append five copies or ten copies or whatever.

Now why am I using copy.copy?

Well, if they send in something mutable, like say, another list,

each member in that filled list or each member in our filled list

that was a copy of that list would be the same member if we weren't using copy.copy.

If you changed one of them it would change all of the others too

because we're just putting in references to that list.

Okay, let's try this one out.

With copy.copy though we're not getting references.

We're just getting brand new versions of those lists.

So let's say import filledlist and we'll say fl = filledlist.FilledList.

And I want this to have 9 copies of the number 2.

So let's do len(fl), it's 9, cool.

Now let's do fl and there's a whole bunch of 2s, nice.

Now let's make sure that the copy part is working, right?

So let's do fl2 = filledlist.FilledList.

And I want two copies of the list 1, 2, 3.

Okay, so if I look at fl, sorry, if I look at fl2, I get 1, 2, 3, 1, 2, 3, great.

Let's change, on fl2, the first item's second item to be a 5.

So we should have 1, 5, 3, 1, 2, 3.

So if I look at fl2, that's what I have, 1, 5, 3, 1, 2, 3.

So excellent, that's working too.

Now we could go another way, too, and just change some of the abilities of a class.

We don't have to totally change the class, and just destroy everything.

So let's make a new file.

And let's call this one javascriptobject.py.

Maybe you can guess what I'm gonna do here.

Let's make a dictionary that sorta kind acts like a JavaScript object.

Or rather, it has one thing that we want,

which is the ability to look up keys with a dot.

So there's a matching method called getAttribute.

And that method is use whenever we ask for an attribute using dot notation.

So let's try to use that to give us a key.

So well call us class JavaScriptObject.

This is going to extend dict.

And then we're gonna find getattribute__(self, item).

And we're gonna try, return self[item], except KeyError, so

if that key doesn't exist, if item isn't a valid key,

then return super().__getattribute__(item).

So if the key does exist, then we'll get that off of the dict.

If the key doesn't exist though, we fall back to the dict version

of getattribute, which actually looks to see if there's an attribute,

an actual real attribute with that name, okay.

So let's give that one a try now.

We're just making weirder and weirder things?

Okay, so lets say import javascriptobject.

Okay, and lets call this jso = javascriptobject.JavaScriptObject,

and we're gonna give this one key, which is a (name).

And I always like to use my name, feel free to use your own.

Let's set an actual attribute on this, so

jso.language and will set that language to python, okay.

So, jso.name is Kenneth it went locked up the key as an attribute, cool.

And if I do jso.language I get Python, and if I do jso.fake, so

that means it doesn't exist at all, I get an AttributeError.

And now an interesting thing here is, if we scroll up just a little bit,

we see that our traceback, we got this KeyError, which that's fine, right?

That's the KeyError that happened here.

And then while that KeyError happened, it came in here into this attribute, and

it couldn't find that attribute.

So it threw a second error, which was this AttributeError.

Hopefully this gives you some ideas, of how you can customize the building classes

to do what you need, with writing minimal code of your own.