Python Jumpstart by Building 10 Apps Transcripts
Chapter: App 9: Real Estate Analysis App
Lecture: Data mining with list comprehensions

Learn more about this course
Login or purchase this course to watch this video and the rest of the course contents.
0:00 All right, I said there is a better way than using these
0:02 procedural loops to answer these questions.
0:05 Now, check this out, let's change this here,
0:08 let's write some code that maybe is a little surprising to you
0:12 unless you have seen it,
0:14 so we'll say again prices, and what we want to generate is a list of numbers,
0:17 we wrote this code which generated a new list,
0:20 it's equivalent to saying list, like so
0:23 and then we iteratively looped over,
0:26 and down here you can see we even added a test in our loop
0:29 now there is a concept that lets us write a more declarative style of code
0:33 where the implementation actually handles the looping and all that for us,
0:36 so we can come down here and write what looks like brackets,
0:40 we are going to define a list, but we are going to put something different in there
0:43 we are put in an expression,
0:44 first line is always going to be the projection or items to create,
0:49 something like this,
0:51 so what do we want, we want the purchase.price, here,
0:53 now it's a little bit backwards because you have to imagine, all right,
0:56 there is a variable p, that I am about to talk about,
0:59 and it's going to be a purchase so I want the price
1:02 and then the next thing down here is going to be the set to process,
1:07 for lack of a better word, so here we'll say for p in data:,
1:11 so what we want is we want to go through all the data,
1:17 grab out every one of those we are going to call it this p
1:20 and we are going to pull out the price, now we could pull things like a tuple,
1:22 I could say p.beds like that, and even like p.state,
1:28 no that's not going to be interesting, it's all the same state,
1:30 let's say city, maybe we'll get something there and I could just print prices,
1:36 I think in this case I need some parenthesis, yes,
1:40 one of the rare cases where tuples need parenthesis,
1:43 and let's just say return so it doesn't actually crash.
1:46 And notice, we looped through here and here is the price,
1:49 here is the number of beds, here is the city, price, beds,
1:54 price, beds city,
1:56 so this is like a projection, kind of like if you are
1:58 familiar with SQL, queries and those kinds of things,
2:00 that's what this is but we just want one item, which is just the prices.
2:05 So here you can see all the prices.
2:07 If you want to know what type that is it's just a list, class list, that's its values.
2:14 So think about this for a minute, before what we did we had to allocate the price,
2:18 loop over each item, and then do some processing,
2:21 granted this processing is very simple, it's just added to the list,
2:24 so it's a little harder to see the value here
2:27 but here we can just declare expression that will build the list,
2:31 and it uses the same mechanism as the list here,
2:34 let's take the same idea and apply it the more interesting scenario here,
2:38 this, so here we have the same thing,
2:43 and the last part that I hadn't shown you before is the test or condition,
2:47 if you are familiar with data bases this would be like the where clause,
2:50 so we could say if p.beds, so now if I run this,
2:56 we should get the same answer below,
2:58 and we do exactly as we had before, but we don't need these tests,
3:03 what we are really after is not just the average price of a two bedroom home,
3:07 we also want to know the average number of bathrooms
3:10 and maybe the average square footage,
3:12 so this can get a little more interest in here,
3:16 so we'll say the average price of a two bedroom home
3:19 let me tighten this a little bit,
3:21 so we'll say the average two bedroom home is
3:24 some price with a certain number of baths and a certain square footage,
3:26 now I put the 0 here so just this will run,
3:29 here you can see we are still getting the same answers.
3:31 Now, suppose I want to know this, well,
3:33 previously with this looping mechanism,
3:35 I would have to come up with another list of let's say baths=something like this,
3:42 and down here I would have to also say bath.append pur.baths, and so on.
3:48 With the conciseness of these lists here,
3:52 we could do something like this, we could just say two bed homes like this,
3:57 and let's get back here like so,
4:01 and so what we'll get is a list of two bedroom homes
4:04 and then down here we can say the average price is going to be the mean,
4:07 now if we try to give it two bedroom homes, remember, this was crashing,
4:10 so as I don't know what to do with, purchases,
4:13 but we can go into this set and we can just write in line here
4:17 and say what I would like is p.price for p in this.
4:22 And now we are back to our average, so I said look,
4:26 write in this little bit of code here,
4:28 we are just going to do this little projection,
4:30 now, let's get the average baths.
4:33 So here I can say baths, and the average square feet.
4:37 All right, now let's see what their answer is,
4:41 maybe we could round this off here,
4:44 so we'll just use the round function here,
4:47 so the average two bedroom home in Sacramento that was for sale
4:53 were actually sold in 2008 was sold for 165,000 dollars,
4:57 it had 1.4 baths and the square footage of 957.2 square feet.
5:03 How cool is that?
5:05 All right, so this concept here is called a list comprehension,
5:11 and it's really cool, it has some performance benefits,
5:16 and some performance drawbacks.
5:17 You will see that there is something extremely similar to it,
5:20 called a generator expression,
5:22 but first let's look at the concept of list comprehensions.