Python Jumpstart by Building 10 Apps Transcripts
Chapter: App 7: Wizard Battle App
Lecture: Initializing classes and creating objects

Login or purchase this course to watch this video and the rest of the course contents.
0:00 We have this concept of defining a creature as a thing in memory
0:04 and wizard as a thing in memory
0:07 but they don't really do anything or have any behaviors or data,
0:10 so let's go over here and look at this,
0:12 let's look at the creature first.
0:14 So what might the creature have, well,
0:16 maybe the creature is going to have to have a level,
0:19 and let's have it have a name,
0:21 so we can say something like toad of level 7, something like this.
0:26 So there is actually several ways to add those features as data to this class.
0:31 And the way that I am going to show you will generate
0:34 what are called instance attributes or instance variables,
0:37 and these are only going to be tied specifically to a particular version
0:42 or particular create instance of the creature,
0:44 so the data related to this creature will not at all be shared with this creature,
0:49 there is way to have sort of what you think of a static shared data
0:52 but we are going to use what is called a magic method.
0:55 Now, to add methods, magic or otherwise to classes
0:58 just like normal methods you say def
1:00 but you have them indented into the class body.
1:03 Now, I could have a method that is called run away,
1:06 like this and then that would be a standard method there,
1:09 but we are going to use what I said a magic method,
1:12 so magic methods start with double underscores often called dunder,
1:16 and you can see there are a lot of them,
1:19 so here you can see length,
1:23 if we had some kind of collection and we wanted to talk
1:26 about how many items were in it,
1:28 we could implement __len__() and when somebody says len (our object)
1:33 it would implicitly call this method.
1:35 If we wanted to change how our creature appeared when you just said print creature,
1:40 it was no special formatting we could implement __str__()
1:43 and then we would get some kind of special string representation.
1:47 But the one we are looking for is __init__().
1:50 So here there is something a little bit unusual in this method,
1:53 notice when I hit enter there, PyCharm put this self and this self has a color,
1:58 while other variables in here, parameters,
2:01 they wouldn't have this purple color,
2:04 remember, the class is the blueprint and then there are the object instances
2:07 and each one of them has their own special copy of data
2:10 and that's what this self represents, this is the pointer to the one
2:14 that has been used to call this method,
2:16 so in this case it's the pointer to the object that is actually being created in init.
2:20 so we want to have a couple of things,
2:22 we want to have a name and a level,
2:24 remember this is kind of like dungeon and dragons type thing,
2:27 so we have a name and a level that you have to pass in,
2:30 these are not optional parameters on the initializer for creatures,
2:34 you will see in just a minute,
2:35 and then the way we define instance variables is
2:37 we use this self parameter and we just say something like
2:40, and self.level=level.
2:46 Now, these don't have to match,
2:48 let's just change this to like the level to make it really obvious
2:51 that there is no real name relationship between them,
2:54 but self. this is actually the creation,
2:56 the definition of name attribute or field in the creature class.
3:00 It's highly discouraged to do this outside of the init method.
3:04 Now, while we are at it, let me show you a cool PyCharm trick
3:07 so if I had another thing here like let's say experience or whatever,
3:11 notice that it's not assigned to any member variable or used in any way,
3:17 so I can come over here in PyCharm,
3:19 I can hit enter and say add this field to the class.
3:22 And bam, it'll go here and automatically do what you just saw me do,
3:25 so we are not actually going to have this experience
3:28 but you can use PyCharm to kind of automate this, it's very nice.
3:30 Now, it turns out that the wizard is going to be very similar
3:34 so let me copy this over here
3:36 and I'll just change this form the level to level, like so,
3:41 so now we should be able to create our wizard
3:44 and create our creature and they should have data associated with them,
3:47 the next we are going to give it behaviors
3:49 like maybe it has an attack method here
3:51 and it can attack other creature, or just a creature,
3:55 and down here we'll put something that has to do with attacking a creature.
3:59 So I told you that these are required,
4:02 if I try to run this app again, it's going to crush,
4:05 and it crashes right here and says, wow,
4:07 we are missing two required positional arguments, name and the level,
4:12 I can do things like give it default value like
4:14 so I could say by default the level is 10
4:17 unless they specify it then it will be something else.
4:19 So then you'll see, only one required parameter is missing,
4:23 because if you don't specify the level, hey it's 10 so all good.
4:25 That didn't actually make a lot of sense in our particular game here,
4:30 so I'll take that back away.
4:32 All right, so let's go figure out what's wrong and fix this,
4:35 so I can just click right here and navigate right to where the error was
4:38 and you see PyCharm has this kind of lit up
4:41 and color here saying not such a good idea,
4:43 all right so what do we have here, we have the name,
4:46 remember, let's see we have a toad and the level of toad was quite low,
4:50 and we had a tiger and the level of tiger was modernly high,
4:54 I think we had the bat, the level of the bat was not particularly high it was 3,
4:58 we had a dragon and the level of the dragon was pretty high
5:01 and we had the evil wizard, so now our list of creatures will actually contain
5:08 particular copies of the creature object, five of them,
5:12 and each one of them will have a separate name
5:15 and a separate level tied together.
5:17 one thing that is a little bit off here is using this creature class
5:21 for a wizard when we also have a wizard class,
5:24 so let's leave it like this for a minute and we'll get back to it,
5:27 so now here we have the same problem,
5:29 we have exactly the same requirements to create this,
5:32 so let's say this is Gandolf, and his level is 75.
5:35 Ok, let's run this and see if we can get down pass line 27.
5:39 It looks great, let's actually run it in the debugger
5:42 and we'll have a look at these in memory.
5:45 So here we are at the break point, we've got our local variables
5:47 and we have a hero and you can see we can open this up,
5:50 we have this hero has a level 75 and his name is Gandolf,
5:53 and we actually have a list of creatures,
5:56 and you see there is various creature objects,
5:58 these are manifestations or things created from the blueprint of creature,
6:01 there are different memory addresses,
6:03 everything in Python points to somewhere in memory
6:05 and so the elements of this list all point to different places
6:09 and the debugger happens to show you that if you really care about it.
6:13 We can open this up and see there is our bat,
6:16 there is our tiger, there is our toad and so on.
6:19 So we spoke a little bit about magic methods,
6:22 and you can see that this is not the most amazing experience
6:25 for looking at what is in this list of creatures
6:28 and that's not the only place it showed up,
6:30 if I were to come here and just say print the creatures, and I run this,
6:35 you can see basically I have the same output here,
6:37 there is some kind of actor.creature at these various addresses.
6:42 And we can use the magic methods to change how this works.
6:45 so my creature, I can down here and I can say
6:48 define __repr__(), for representation,
6:51 and then I could just say return some kind of string
6:54 so let's say creature of the name of level-
6:58 something there we'll do a little format like so
7:01 and so when you say self when you refer to the variables
7:04 of the particular instance of the type of class like so
7:08 the particular creature here, I'd say, and self.level.
7:13 Of course maybe format instead of forma, have a little better chance there.
7:17 So we are going to return a string that could be used in various places,
7:20 so now if I run this you can see we have a creature toad of level 1,
7:24 maybe like so or something.
7:29 Creature, toed of level 1, creature tiger of level 12 and so on,
7:35 so we are only getting started with our classes and modelling the actors in our game,
7:40 but you can see we are already after a good start we have a list of creature objects,
7:46 they have their particular data associated with them,
7:49 and we have our hero which is a wizard named Gandolf of level 75.