Effective PyCharm (2021 edition) Transcripts
Chapter: Debugging Python applications
Lecture: A debugging example

Learn more about this course
Login or purchase this course to watch this video and the rest of the course contents.
0:00 Well let's take PyCharm's. Debugger for a spin.
0:03 And I've got an interesting little program here that we can play with because it has
0:06 some pretty unique flow and we'll be able to use the step over step into step
0:11 out of actually see some interesting things about how python works.
0:16 You might be familiar with the Fibonacci numbers there,
0:19 these numbers and then the next number is generated by taking the previous two and adding
0:23 them. So one plus two is 3 plus three is 5 plus three is 8
0:27 13. Anyone on and on or infinity.
0:32 I've got this program and we've got our other file here that's going to generate this
0:37 Fibonacci sequence. I've got this other math tricks thing that will given a sequence,
0:45 generate a subsequent of it for just the odd numbers.
0:50 So if we give it 112358,
0:52 it's gonna give us 1135 etc.
0:56 What's interesting about this is this is an infinite sequence and that is modeled here in
1:00 python were actually generating an infinite sequence.
1:03 And when we feed this one an infinite sequence,
1:05 the results is itself an infinite sequence,
1:08 assuming it has infinitely many odd numbers I suppose.
1:12 So what we're gonna do is we're going to explore how that flows know it might
1:16 sound tricky to generate an infinite series but in fact with the yield keyword it's ridiculously
1:22 simple. We're here, we're generating the numbers starting with 10,
1:27 they want to do this add together here,
1:29 we do the step to calculate them and then this yield is going to return the
1:33 value, we'll go work with it and then when we need more these co-routines
1:38 will allow us to jump back to where we left off basically this line and just
1:42 keep running one time and then another through that loop.
1:46 Same thing here we go through whatever series we find an odd one.
1:49 We give it up, it's on,
1:52 we're going to combine these two things in some interesting ways.
1:56 So first let's just run it and see what we get because this is an infinite
2:00 series. We can't just print them out.
2:03 Going to gather them up in this list actually then print it,
2:07 we have to say after some point,
2:09 I'm no longer interested in looking at the Fibonacci numbers so let's stop.
2:13 So let's run this real quick and there you have it.
2:17 1135 13 21. And then boom,
2:20 this stuff takes off super quick.
2:22 It's really interesting how big these get how quickly,
2:25 So isn't that cool? We generated this infinite sequence and then we filtered it down
2:30 and then we stopped. So let's go and actually set a breakpoint here and just
2:36 see what's going on. So we already have a run configuration so I can click
2:39 this, I could sort of skip it,
2:41 I guess by going debug here,
2:42 but just press this here we are in our definition of defining data,
2:48 we've done our import but that's about it.
2:51 We could step into we don't want to more likely to step into my code is
2:56 what we want. But I'm just going to step over for now.
2:59 We're just gonna look at this particular file the first time through first of all notice
3:03 right over here, there's this really cool grey thing at the end that wasn't there
3:08 before. And look at this,
3:10 this is the value of this list.
3:12 It's not very interesting yet it's empty but you can even see that we can interact
3:16 with it kind of like a hyperlink drop down thing.
3:19 Incredible. Now these are going to return what are called generators if you hover over
3:24 it, PyCharm even knows this is a generator didn't show us to us there
3:28 but if we weren't in the debugger it would show us that we step over
3:32 here is our generator named 'fibs'.
3:36 And then this one is going to be a generator named fib so look how quick
3:39 we generated to infinite series. That's because they're lazily evaluated.
3:44 Find some way to keep going.
3:45 We've got our variable O and are odd fibs and we're going to start to go
3:49 over them. Let's keep going.
3:51 Step along notice here's our one are always one when append.
3:55 Watch what happens online for appear around data.
3:59 Oh yeah, so it changed and because it changed,
4:04 it changes in this little overlay mode to orange,
4:07 that means had a value and now it's got a new value.
4:10 So that's really cool and you can see down here we can even expand out the
4:13 list and see it has one item.
4:15 Let's keep going. But one again now we should have our data has more,
4:20 see the index where it changes Now we have our three,
4:24 remember the Fibonacci sequence is 1123 but we filtered out the two with our generator for
4:30 the odd numbers. I keep going and just see it stepping along here.
4:37 Super cool. Now what if we said I'd like to see at this point exactly
4:41 what would happen if O was 9000?
4:44 So no problem. We can come down here,
4:48 we can click set value Or we could add as an in line.
4:52 Watch down here but I'm gonna just set the value.
4:53 What do you want to be said?
4:55 9000. Remember this is a situation that basically because of this function couldn't exist but
5:01 I want to figure out what happens if it's the case.
5:04 So now we've got these numbers and what should happen is we're going to break out
5:08 of this. Right? So we step done,
5:11 I printed out gone back over here are console there,
5:16 that's not the same output as before because we played with the debugger and we
5:19 changed it. How cool is that?
5:22 I cannot tell you how much it delights me to see the variables over laid and
5:26 code. Let's just go down here and say I want to run,
5:29 put a breakpoint first Run down here,
5:33 then I want to just go straight to this location bam.
5:35 Run to cursor and we've got there for the first time.
5:40 Notice all the variables here, but I cannot tell you how delightful it is to
5:43 be able to see these without,
5:44 you know, fiddling with this stuff down here or some other window,
5:47 You just see it right there and you can even interact with it as we've seen
5:51 So super, super cool.
5:54 Let's do another thing. Let's try to understand the flow.
5:58 These restartable co-routines,
6:00 they are mind bending if you have not played with them before.
6:03 So let's go back over here,
6:05 start to debugger. I'm gonna step into my code.
6:10 I just called that function and it didn't go into it.
6:14 That is weird. I'm gonna step into this one also didn't go into it.
6:18 Okay, confusing. A normal function it would step into,
6:21 but with the generators, what we do is we create these lazily evaluated sequences.
6:25 It's not until we first begin to interact with them,
6:28 like loop over them or try to get to some of them or something like that
6:31 but we actually execute them.
6:33 So here, vice type step into were in our odd series and then if I
6:39 type step into that, it's going to pull on the series.
6:42 The series is actually the Fibonacci generator.
6:44 You can see right there again.
6:46 Fantastically. Just over laid. All right.
6:49 Step, we're at the beginning,
6:51 this is the first time we call this function.
6:53 So we're going to step compute this now.
6:55 That's one and one. We're going to yield that.
6:57 It's going to come back for the value here.
6:59 So hold on for that. Oh,
7:01 there we are. And as one now,
7:02 we're going to yield that back over here.
7:05 This looks good when I put it on the list.
7:07 Now, if I step back into normal functions,
7:10 would go back to the beginning but not co routines and generators remember in is already
7:16 one going to step in again,
7:18 look where it went to, what's going to happen to current?
7:21 not 2, there's our to actually the next one will be too.
7:25 So this is one going to append it.
7:27 Step in again, this one is to we're not going to yield it,
7:32 so we're gonna loop inside. Go back here,
7:34 that'll be three and so on.
7:37 Hopefully that gives you a sense of what these generators are doing.
7:40 Their flow through code is very different than standard code.
7:44 But look how easy it was for us to see that just using step into my
7:48 code, basically. Really, really need to be able to do this with the
7:52 debuggers. And again, when we were in here we could see that the
7:55 series that was passed. Is this Fibonacci generator. Super cool.