Effective PyCharm Transcripts
Chapter: Refactoring
Lecture: Refactoring methods and functions

Login or purchase this course to watch this video and the rest of the course contents.
0:00 Let's look at some code we haven't touched yet.
0:02 So, here is a little wizard project and it has a couple of classes.
0:07 Let's go ahead and compress this down a little bit you can see.
0:11 So we've got a wizard a little higher.
0:13 We have a creature object a class.
0:17 Some behaviors you can create one of them and it can do this.
0:20 Get defensive role is going to be a little role playing dungeons and dragon type game
0:23 And then there are other more specialized things in here.
0:27 Like there's a wizard that derives from creature,
0:29 there's a small animal, there's a dragon and so on.
0:34 Now let's just run it real quick so you can see what it does.
0:37 So it has this cool little header here that looks like a dragon.
0:40 The wizard battle app. And you can see it's in the smoky breath or the
0:44 fire of the dragon. And turner says a level a tiger of level 12 has
0:49 appeared from a dark and foggy forests.
0:51 And you have some options here.
0:52 We could look around, we could attack it.
0:54 We're pretty strong so we can attack it and look the Wizard gained attacks the tiger
0:58 We rolled 900. The tiger rolls 108.
1:02 The wizard has handily triumphed over the tiger.
1:05 All right, So this is what the program does.
1:06 We can also look around and we can run away and we can quit.
1:12 So what we want to do.
1:13 Not so much play the game is we want to look around and see where are
1:17 some code smells. There are some things that we might be able to make better
1:20 And let's get started at a real simple thing over here,
1:23 this is the start up of the whole program.
1:26 We do this big print statement here,
1:28 notice here's the dragon text, A huge welcome to the dragon game on the wizard
1:35 game with the big fiery breath writing set up here.
1:38 It's a bunch of text and we're just printing that out and then we'd run the
1:42 game. Well this this formatting just right in line in this main method.
1:47 It's not beautiful, is it?
1:49 It would be nice if we could just real quickly read what's happening main like,
1:52 oh, we're gonna show the header that we're going to run the game loop,
1:55 but that's not what's happening here.
1:56 We've got to figure out what does this print mean,
1:58 Why is it all here? And then we run the game loop.
2:01 So the first thing we want to do maybe is to make this its own function
2:05 with its own name. So instead of saying,
2:09 we'll show the header as a comment.
2:13 Remember this is a bit of deodorant for this.
2:16 Not so great code for this code smell.
2:19 What would be better is to just make it more clear with some kind of
2:23 refactoring and that brings us to the refactoring features.
2:26 So there's a couple of ways to get to them.
2:28 I almost always use this first one 'Ctrl+t' on mac Os.
2:32 And it's something else on the others.
2:33 You will see in a moment what that is and what I would like to do
2:37 is just go highlight the code and say,
2:39 well what can I do to make this better?
2:41 But you could be more specific.
2:43 Like if we were on a variable,
2:45 we could rename it or a function,
2:46 we could change the signature, we could introduce a variable,
2:50 a field, a parameter object.
2:52 Remember I talked about the function that takes too many arguments.
2:55 This is one of the proposed fixes.
2:57 We create a method and so on.
3:00 We can also not with what I have selected,
3:02 but in general we could reverse that.
3:04 We get in line a variable in line of function and just make it happen right
3:08 there. I said this is this parallel refactoring and the anti re factoring and
3:14 both times they're useful and they're both useful but at different times.
3:17 Right? So you want to keep in mind what we're doing here?
3:20 All right. So what we want to do is we want to instead of just
3:23 do this, we want to have a function that has a name that kind of
3:26 tells us what's happening. So I come down here and get ctrl+t or
3:29 You can see I can get control shift t on windows or Linux.
3:33 I'm going to go down here and have a bunch of options.
3:35 I know I want to extract a method,
3:37 you can see there's a hotkey for it.
3:39 Option command M for me, but what I can actually do is I could just
3:43 type start typing method until it gets to be a nice short list.
3:47 You can actually search or narrow down this list.
3:49 We have that, we get this thing here,
3:51 it says show header or something like that.
3:55 And if we choose it had arguments or if it were using variables that need to
3:59 be passed through as an argument,
4:01 it would allow us to put them here and change the order and stuff.
4:04 But this doesn't have any. So we'll just say go and look at that.
4:08 It means the same thing. If we run,
4:09 it's going to do the same thing.
4:12 See down here is the wizard just like before the wizard text being shown.
4:17 But when you read it now def main we'll show the header,
4:21 show header. Do you think we need this deodorant here anymore.
4:24 Is it smart to leave this comment?
4:26 No, because it doesn't make sense to have it when the code is so simple
4:30 and it just so clean. It just says show header.
4:33 Alright, this is silly. So we'll take it away.
4:35 That's one of those cases where the code was acting as deodorant. That's how we can invoke different refactoring tools.