Python for Absolute Beginners Transcripts
Chapter: Cleaner code with common data structures
Lecture: Improving win-tracking with dictionaries
0:00 Now let's look at one other thing
0:02 that we had to do a lot of coordination
0:05 I guess is the best way to put it
0:06 in order to keep track of who won the game
0:09 if somebody's won the game and so on.
0:11 You notice we have to know
0:12 how many rounds there are.
0:13 There's how many times has player_1 won
0:16 how many times has player_2 won
0:18 and then we have to check it like this
0:20 and we got to check it like that
0:22 and then down here, we have an if else statement
0:24 where we check if the name is this
0:26 we can increment that number
0:27 if the name of that one
0:28 we can increment that number.
0:30 Woo, that's not pretty.
0:31 So let's go write another function here.
0:35 Find a winner.
0:36 Now find_winner
0:37 is going to look for an overall game winner.
0:40 So what we're gonnna do
0:41 is we're going to create a dictionary
0:43 that keeps track of given someone's name
0:45 how many times have they won
0:47 and we're going to have a list of names.
0:49 So let's just say return false for a second.
0:54 So this whole part up here
0:56 we'll just be able to say
0:57 we need something let's just type wins
0:59 that doesn't exist yet
1:00 and names we're just going to put a list of player_1
1:03 player_2, like that.
1:05 We could store this in different way
1:06 but we can just stick it here this can be okay.
1:08 Now wins, let's go and create a dictionary for wins.
1:12 And it's going to be player_1 is the value.
1:15 Actually, let's write it like this.
1:18 I'll show you the not easy way
1:21 but the easy to understand way
1:23 but not the clean, pretty way
1:25 and then I'll show you a better way.
1:26 So we can come here and say, like this.
1:29 Yeah, I guess we can create like this.
1:30 So we say player_1 equals 0
1:33 player_2 equals 0.
1:34 There's some cool tricks that we can do
1:36 to make that a little bit nicer but that's okay.
1:37 Let's come over here and get rid of this.
1:40 Now we're going to pass a wins
1:41 and the names over and this one could even be better.
1:44 This might be something like wins .keys
1:48 like this, right?
1:49 All right, those are going to be player_1, player_2.
1:50 So let's go over and do this find winner.
1:52 How's this going to work?
1:53 Well remember wins as the name
1:55 and then how many times each one won.
1:58 So we'll have how many rounds we want to play
2:01 and then we're just going to do this for name and names.
2:05 How do we know the game is over?
2:06 If somebody has won as many times
2:08 as we're playing the best of.
2:09 So how many times has whoever this is
2:12 player_1, player_2 won?
2:14 We'll say if wins, get name
2:17 that's greater than or equal to best of who won.
2:22 Otherwise, if you make it all the way through
2:24 however many names there are
2:25 nobody's gotten more than the best of
2:27 then there's no winner.
2:29 Now this might crash potentially.
2:31 So we can put a 0 there just in case.
2:33 The way we put it together
2:34 surely they're going to be there
2:36 but there's going to be, you know
2:38 a value for that.
2:39 But just to be a little bit safe
2:40 I'll put a 0 so we get a number back
2:42 that we can still compare against the best of.
2:45 Now, that works up here
2:48 but how does this work down there?
2:50 Well check this out.
2:52 Here we can just say if there is a winner
2:54 all we're going to do is go to our wins
2:56 and find whoever the winner is
2:59 and then increment their wins by one.
3:01 So all that is now replaced
3:03 with that one line 53 there.
3:05 We don't have to check if it's player_1
3:06 change players one's variable
3:07 if it's player_2, change player_2's variable.
3:10 No, this data structure, this dictionary
3:12 holds all of the players
3:13 and all of their scores
3:15 so we just have to go find the winner
3:17 get their score and change it.
3:19 Now, down here and we're going to need
3:21 a little bit of something as well.
3:23 This will be player_1
3:25 and this will be wins of player_2.
3:29 And this part here about the overall winner
3:31 remember all this, checking here
3:33 if this or that and so on.
3:35 All of this here can be replaced
3:37 with a very simple overall winner equals
3:42 we wrote a function, takes the wins
3:44 and the wins.keys just like that.
3:47 Again, this complicated if statement
3:49 is now replaced with just a simple
3:51 little dictionary thing
3:52 instead of having multiple variables
3:54 and checking and so on
3:55 all of that now like this.
3:57 If we did things right
3:58 this should work.
3:59 And the essential thing that we did here
4:01 was right there, was using this dictionary
4:06 to track the wins.
4:07 And each time through I'll print out
4:10 and we'll take this away again
4:11 but I'll print out current win status
4:14 I'll print out wins.
4:17 All right should work the same
4:19 none wins the game. Yeah, I'm going to say no.
4:22 Say well there's not a winner
4:23 I know a little bit backwards didn't I.
4:26 Okay, there's not a winner
4:27 so we got to keep playing.
4:28 Available rolls, what is your roll?
4:31 I roll rock, computer rolls rock
4:34 and that means it's a tie, nothing's changed.
4:36 Okay, I'm going to roll scissors
4:38 computer rolls paper, I win.
4:40 So here's the current win status.
4:42 I guess I got to do it one more time
4:44 need to show it.
4:45 Here's what it should be
4:46 it's out of order.
4:47 I got one, computer has 0
4:49 but now again I have two
4:51 so just not printing it soon enough.
4:54 Now if I were to print it one more time
4:55 and say you three, computer 0.
4:57 See how we're using this dictionary
4:59 to keep track of that?
5:00 I'll go ahead and just move this
5:01 where it should've gone down here
5:05 and then I'll comment it out.
5:06 Okay, so we're able to use these dictionaries
5:08 these data structures
5:09 to dramatically simplify the juggling of
5:12 well there's three players maybe
5:14 and all these different rolls
5:15 and if this player plays that roll
5:17 then we change that variable.
5:19 No, we just have these couple of data structures
5:21 that store it
5:22 and we're only touching the surface
5:24 of how awesome this is going to be.
5:26 This is going to be way better.
5:27 Think mods, think all kinds of cool stuff
5:30 that we can do going forward.
5:32 But for now we're going to leave it here
5:34 with the same program doing the same thing
5:37 but much nicer on the inside.