Python for Absolute Beginners Transcripts
Chapter: Problem solving techniques for writing software
Lecture: Demo: Find the winner, good version
Login or
purchase this course
to watch this video and the rest of the course contents.
0:00
Well we had our find winner done.
0:02
I mean it's technically working
0:03
but remember, this loop is the same as this loop
0:07
is the same as this loop
0:09
so let's think about this for a second.
0:11
What we want to do is we want to come up with some lists
0:15
that are just a bunch of cells and check them.
0:17
So here we're saying, the lists of cells we want to check
0:20
and are the rows.
0:23
And we want to go through each row and check it.
0:24
Here we say the list of cells that we want to check
0:27
are the columns and then we want to go through
0:29
each one of those, here and we want to go through
0:31
each one of those and check it.
0:33
Here are the list of cells we want, are the diagonals.
0:36
We want to go through and check it.
0:37
What we can do that's better is we can say
0:40
come up with a function that says, give me all the lists
0:43
of cells you need to check.
0:44
Give me the rows, give me the columns, give me the diagonals
0:46
because once you have those, it's just three symbols
0:49
in a row, and it doesn't matter if they
0:51
originated from thinking about a diagonal
0:54
or thinking about a row or thinking about a column.
0:56
The test that you're going to do is just these three lines
0:59
so let's make this a lot better.
1:01
Let's say, def get winning, winnable, winning, sequences
1:06
from the board.
1:08
So what we're going to do is we're going to come up with a list
1:11
that isn't just the list the rows
1:13
or just the list of diagonals, but it's the rows
1:15
the columns, and the diagonals
1:17
so let's come over here again.
1:19
I want to go get the rows, take that away.
1:23
I'll even take the little comment bit here
1:25
'cause that's still relevant.
1:28
We want to have the columns.
1:34
And we want to have the diagonals.
1:40
Go back over, okay.
1:42
I'll say sequences is empty
1:46
and then instead of just saying create separate columns
1:50
we're just going to say when we find a column
1:52
put it into the sequences you care about.
1:54
When we get the diagonals, put them in there
1:56
and now if you have a list and you want to put all the items
1:58
in there, you can say this and say instead of append
2:00
which is put one item, say extend
2:03
which means take all the items in the other sequence
2:06
and put 'em one at a time in here.
2:07
So we want that there and we also want that here like this.
2:11
Extend rows.
2:13
Alright, we could just in line this
2:15
but I think it makes a little more obvious what's happening.
2:17
So the sequence gets all the rows, all the columns
2:20
and all the diagonals and we just return the sequence.
2:23
Now we don't need to have three loops over here.
2:28
And we just say, sequence is equals find
2:32
what'd we call it?
2:33
Get winning sequences for the board
2:36
put those there
2:38
call this cells, cells, cells.
2:42
And tighten that up a little bit.
2:44
Look how much nicer this is.
2:46
That was yucky.
2:47
And thinking about this, this makes it really easy
2:50
to understand when we're over here, what are we doing?
2:52
We're saying, there's different ways you can win.
2:54
You can win by filling up a row.
2:56
You can win by filling up a column
2:58
and you can win by filling up a diagonal.
2:59
But as far as checking those, it doesn't matter.
3:01
Just if any of those are filled up, we're good.
3:04
So we can break that into two parts
3:06
and make it much easier to reason and maintain both of them.
3:09
See, this isn't too bad anymore.
3:12
I guess we should check.
3:13
Play a few games to make sure this works.
3:16
I'm going to try to win by the diagonal.
3:20
And it's easy 'cause I get the first pick.
3:23
Alright, so 3, 3
3:25
this should be the end of the game.
3:27
Boom, Michael wins, game over.
3:28
Let's try another where the computer wins in a column
3:31
and we'll call it good if that works.
3:40
Alright, getting close.
3:41
Every one.
3:43
All right, I know if I fill up that two, two one
3:46
I'm going to be good but the computer's going to beat me
3:47
with a 3, 2.
3:51
Boom, game over. Isn't that cool?
3:53
Isn't that a super slick way that this comes out?
3:56
The realization that all we have to do
3:58
is verify a bunch of different sequences of cells
4:02
or of symbols, makes this so nice.
4:04
So, here's three, so we add three rows
4:07
and those are just three lists
4:09
each of which has the cells to verify.
4:10
Here we have to come up with the columns.
4:12
Kind of going against the grain of our data structure
4:14
but not badly.
4:15
And we put the three in there, and we put the two diagonals.
4:18
Then we just go to this and say, you know
4:20
here's a bunch of different potential ways
4:22
somebody could of won, check them all
4:24
using this common algorithm.
4:26
Are they all the same symbol?
4:28
Done. So this, I think, is really nice way
4:31
to cap off this project.
4:33
We thought about the most simple thing we could do
4:36
we broke it up using divide and conquer
4:38
we started working on them.
4:40
The data structure was important.
4:41
A lot of the stuff was pretty straightforward.
4:43
This one though, maybe we didn't have a great way
4:46
on the find the winner.
4:48
We just said, well we're going to do something gross
4:50
and just replicate, duplicate a bunch of code
4:52
make it really just hard to read.
4:55
But let's get it working.
4:56
And then we came to this realization like
4:58
actually, this is a lot better and this is what I was
5:00
getting at with the get started.
5:02
I didn't have this idea when I first created this thing.
5:05
You know, I haven't technically gone through it
5:07
before I hit record, but the first time I did go through it
5:09
I didn't have the idea that it's just
5:11
it doesn't matter when you're verifying it
5:13
if it came from a row, column, or a diagonal.
5:15
I just said, well there's these cases I got to check
5:18
and then I realize, this could be put together
5:20
much, much, nicer.
5:21
So you don't have to have all the answers
5:23
or the slickest way to do something to get started.
5:26
You build it out and as you build it
5:28
you get better visibility into it, more insight
5:31
and it comes up with what I think is a really nice version
5:34
of the game here.
5:35
Let me do two super quick things.
5:37
At the beginning let's just say print out something.
5:40
Welcome to Tic-Tac-Toe from Talk Python.
5:46
There we go, and then down here
5:48
I'm not a huge fan of this.
5:53
Let's do a little print and let's just do
5:56
game over or something like that.
5:58
'Cause I want to make sure that this is a little more obvious.
6:01
Right now, it's not entirely clear that the game is over.
6:04
I'll do one more print at the end.
6:05
There we go. I think our game is done.