Python Jumpstart by Building 10 Apps Transcripts
Chapter: App 8: File Searcher App
Lecture: Generator play: a simple example

Login or purchase this course to watch this video and the rest of the course contents.
0:01 Let's explore generator methods and we'll use the Fibonacci numbers,
0:05 an infinite series of numbers to do this.
0:08 Here we have this Fibonacci numbers that are defined to be 1 and 1
0:12 and apparently I left one out,
0:13 and then the next one is the sum of the previous two,
0:15 so 1+1 is 2, 1+2 is 3, 2+3 is 5, 3+5 is 8 and so on.
0:22 Now this is an infinite series of numbers, so let's write a function,
0:26 a traditional function like you've seen us write with lists and building up the data
0:31 and then passing them back to generate this.
0:33 So we are going to define a Fibonacci function,
0:36 initially I am going to give it a limit, if there is no limit,
0:39 you'll see we'll just flat out run out of memory and crush our application,
0:42 so we are going to have something like a list that holds the numbers,
0:46 and then we'll have the way you compute this is you have a current number
0:50 and you have a next number, then I'll say while current is less than a limit,
0:57 and the implementation in Python is actually really fantastic so what you do is
1:02 you can use tuple projection and avoid having a temporary variable,
1:07 a lot of times you will sort of see 3 steps to do this we can do it in like one, it's cool,
1:11 so we'll say current,next and we'll do- that's the variable so we want to do
1:16 a tuple unpacking into them so current is going to be signed next
1:20 and next is going to be next + current.
1:23 And then, we want to add to our numbers current,
1:28 and then we'll just going to return the numbers,
1:31 so let's print Fibonacci
1:33 and let's say we want all the Fibonacci numbers that are less than 100.
1:37 Now we still have the factorial stuff above but don't worry about it,
1:40 just pay attention to the last line.
1:42 So here are our Fibonacci numbers computed
1:44 up to a sort of including the last number there,
1:49 so let's actually print this out in a slightly different way
1:51 where we have a little more control to go through,
1:53 so let's say for n in Fibonacci like so,
1:57 and we'll just print(n) and we'll do that end = just a little comma thing
2:01 so we can have on the same line, let's run that, perfect,
2:04 it looks basically the same but here is the key thing,
2:07 let's put a break point here and actually step through,
2:11 we'll actually step through this function call,
2:14 now there is nothing fancy here,
2:16 there is nothing that should be surprising to you here,
2:19 we are just going to step into this code and step through it.
2:22 So I want to come down here and say while this is not the case
2:25 we are just going to step along, you can see on the right the numbers are changing,
2:28 3 next should be 5, then next should be 8 and so on,
2:32 and we are building up this list of numbers
2:34 here you can see the list is highlighted but here you can see this list is building up,
2:39 and all of the computation is happening in this method,
2:44 and then, in the very end, we decide we've had enough,
2:48 few more and we'll be there,
2:50 then we return it and then we loop over like so.
2:54 Ok, that is how traditional methods work,
2:58 but what I am about to show you is not a traditional method,
3:02 it's something called the co-routine and it's extremely powerful.
3:06 So let's take the same method and let's define a second variation of it.
3:10 So let's call this Fibonacci co and down here we'll call Fibonacci co.
3:18 Now we are going to take two steps to go through this and understand it,
3:22 first we are going to just change this to work exactly the same
3:27 and then we can see we could even do better.
3:30 So instead of letting all the work happen in the Fibonacci method
3:33 and then processing the results what would be better
3:36 when we have these large sort of pipelines of data processing
3:41 would be to pull one back and then inspect it,
3:43 do a little work with it then throw it away.
3:46 And then pull the next one, inspect it, do some work with it, throw it away.
3:50 That way, even if we are processing a billion items,
3:53 we only pull one into memory to work with at a time.
3:56 And you can see that we'll do the same thing here,
3:58 so instead of putting this into a list we can use this keyword called yield
4:05 so I come over and I can just simply say yield current,
4:07 and the way this works is when I start using the yield keyword
4:10 this becomes a co routine,
4:13 and when I say yield some item I am basically declaring to the Python interpreter
4:17 what I want you to do is create a sequence that can be one item at a time computed.
4:23 And, here is one of the items, every time I say yield something,
4:27 I say here is one of the items, I never have to return all the items at the end
4:31 I just say here is an item, here is an item,
4:34 and when I stop saying here is more items than that's the end of the sequence.
4:37 Let me just use some quick formatting here so that things appear correctly,
4:40 so we'll say via list and via yield, now it's running.
4:43 We can see via list we get those numbers and via yield look at that,
4:47 we get exactly the same thing, but have we really gained anything,
4:51 ok we have this cool yield keyword, we don't have to have the list,
4:54 that got a little shorter, but what you'll see is
4:56 we've actually gained something tremendous,
4:58 so let me put a break point here and debug it again.
5:01 So we'll step in, now this should look kind of similar,
5:04 we'll step along here, and we are computing the first round,
5:08 and before we are adding it to our list,
5:10 watch what happens now if I step into this, well,
5:13 unpack here I only computed a single item right,
5:16 notice that n is 1 and now if I go around again and I step in again watch,
5:24 we should go straight to line 49 or maybe 47.
5:28 Straight back to 47, we are not rerunning this method,
5:31 we are resuming this method, right here and if I step,
5:36 step let me step down here now n is 1 again because that happens twice,
5:40 then if I step in again here we are n is 3 and so on,
5:45 so as we get them back we get the first item
5:47 and we've only had to do enough work to compute the first item, moreover,
5:51 we don't have to put this into a list to gather up all the results so then return them,
5:57 you know we are never holding on to all the results
6:00 at once we are just giving an item at a time.
6:04 So to make that point kind of extreme,
6:06 let's suppose we want it all the Fibonacci numbers,
6:09 the infinite sequence of numbers.
6:12 We could remove this limit and we could just say I want to do this forever,
6:16 now obviously doing this forever is going to sort of be a problem, it won't crash,
6:22 it will just keep going and getting slower and slower, and so on,
6:24 but it does let us down here as a consumer decide when we've had enough
6:29 so we could say if n > 1000 then break,
6:34 but we have access to the entire infinite series.
6:38 Now, if I did this with the list, this would just run for a long time,
6:41 run out of memory and then crash, but that's not what happens here,
6:45 we just get one compute the next, compute the next
6:47 and any step along that path is super cheap,
6:50 basically a couple of additions and a return value, so let's run this again.
6:55 Boom, look at that, with yield we got the infinite series of numbers
7:00 and it only took microseconds to compute it.
7:03 All right, and you can take these generator methods and combine them
7:09 with other generator methods and create a pipeline of processing
7:12 and that's exactly what we are going to go do in our file searcher app.