English - Office Hours 2 - Design of Computer Programs

0 0:00 - 0:03

Hi. Welcome to the second office hours.

3000 0:03 - 0:07

Again we had a lot of really good questions in the forum, so let's get started.

7000 0:07 - 0:12

The first question came from Matthew Atkinson.

12000 0:12 - 0:15

He has heard that you shouldn't use functions like eval and exec,

15000 0:15 - 0:17

which we did use in unit 2.

17000 0:17 - 0:20

He wants to know why shouldn't we be using these functions,

20000 0:20 - 0:22

and what's the problem with them.

22000 0:22 - 0:26

That's a great question. There's a couple reason to avoid these.

26000 0:26 - 0:30

On is for security, especially if you're going to be evaling

30000 0:30 - 0:35

a string that somebody passes in to you, you don't know what it's going to be doing.

35000 0:35 - 0:41

There are lots of dangerous commands that Python can execute like "delete all my files."

41000 0:41 - 0:45

You don't want to be asking somebody to type something in and then go execute that

45000 0:45 - 0:50

and allow them to do something dangerous. That's one reason.

50000 0:50 - 0:53

The other is just in terms of program structure.

53000 0:53 - 0:58

We like to write our programs so that the functions and variables and so on,

58000 0:58 - 1:00

have a set scope.

60000 1:00 - 1:03

This variable exists from here to here,

63000 1:03 - 1:06

and eval kind of breaks all that structure

66000 1:06 - 1:11

and goes outside of it and say now we're executing something right here,

71000 1:11 - 1:14

but it's not executing with respect to where we are in the code.

74000 1:14 - 1:19

It's executing someplace complete different. That makes it harder to follow the code.

79000 1:19 - 1:24

There's nothing wrong in terms of do you get the right answer but harder to understand.

84000 1:24 - 1:26

So we should minimize it.

86000 1:26 - 1:34

I used it in the assignment for week 2, because there was no other way to easily get around it.

94000 1:34 - 1:37

But you should minimize the use.

97000 1:37 - 1:40

Thanks. The next question comes from Sasheen.

100000 1:40 - 1:43

Sasheen want's to know a little bit more about this big-O notation

103000 1:43 - 1:46

that we introduced and saw a little bit of in Unit 2.

106000 1:46 - 1:52

Yeah. The answer to that question is a whole course in algorithms.

112000 1:52 - 1:54

We can't do that right here.

114000 1:54 - 2:00

But basically the idea is big O says approximately how many instructions

120000 2:00 - 2:02

is it going to take to execute this.

122000 2:02 - 2:05

Actually, big O is an upper bound on that.

125000 2:05 - 2:12

There's another notation less widely used with big theta which gives a more exact bound,

132000 2:12 - 2:19

but the idea is if I have a doubly nested loop that says for i = 1-n

139000 2:19 - 2:24

and then inside of that is nest for j = 1-n then that's the order n-squared,

144000 2:24 - 2:29

because we're going to n * n executions of the inner loop.

149000 2:29 - 2:35

The basic idea is that's more than if we were just doing what are n executions of the loop.

155000 2:35 - 2:39

So if you can get away with a single loop instead of a double loop, that's better.

159000 2:39 - 2:43

That's really all you need to know about big O.

163000 2:43 - 2:48

Alright. I should say there will be an algorithms class sometime in the near future

168000 2:48 - 2:51

for those of you who want to learn more about this.

171000 2:51 - 2:56

Thomas Grace had a question about these attributes you use--function attributes--

176000 2:56 - 3:00

specifically in the C function that had c.starts and c.items. What's going on there?

180000 3:00 - 3:07

So Dave Evans in CS101 chose not to really focus on Python classes,

187000 3:07 - 3:10

which is probably a good choice, because it's a big topic.

190000 3:10 - 3:15

The idea here is that classes of objects can have attributes.

195000 3:15 - 3:19

These are parts or components of the object,

199000 3:19 - 3:25

and they're named with this dot-notation--object, dot, then the name of a field

205000 3:25 - 3:28

that's a component of that object.

208000 3:28 - 3:31

In most languages you define all the fields ahead of time.

211000 3:31 - 3:36

When you define what a class looks like, you say these are the fields that compose this object.

216000 3:36 - 3:41

Python is a more dynamic language, and some classes of objects you're allowed to add

221000 3:41 - 3:46

fields to them as you go, and functions are one of those types of dynamic objects

226000 3:46 - 3:51

where you can at any you say I want to add a new attribute to this function.

231000 3:51 - 3:56

Other objects have that same approach where you can add to it.

236000 3:56 - 4:01

And so what was going on in the C function is that I needed two variables

241000 4:01 - 4:04

that I wanted to keep track of something. I needed two counters.

244000 4:04 - 4:10

I could have just used a global variable name, but that would be cluttering up the name space.

250000 4:10 - 4:17

There'd be no way for you to, if I just made up a name like cstarts and citems--

257000 4:17 - 4:20

by looking at the name of the variable you could figure out that they were related--

260000 4:20 - 4:24

but there'd be no structural way to say that these are all related. They belong together.

264000 4:24 - 4:29

You want to minimize the number of global variables, because people's memories are small.

269000 4:29 - 4:34

By putting everything into one object, we say this belongs together.

274000 4:34 - 4:41

Using c.start rather than a variable named cstart is a way of structuring things together.

281000 4:41 - 4:44

In Python you can do that automatically. You don't have to have a declaration.

284000 4:44 - 4:49

You can just say I want to add a new attribute to a function, and you go ahead and assign it.

289000 4:49 - 4:53

Great. I had no idea you could do that either. I was very excited to see that.

293000 4:53 - 4:56

Yeah. If you come from a language like Java or C, you're not used to that.

296000 4:56 - 5:02

There you've got to declare ahead of time what your attributes are going to be.

302000 5:02 - 5:05

Right. Next question comes from Tracy Zelman,

305000 5:05 - 5:09

and she just wants to hear a little bit about when do we use lambdas.

309000 5:09 - 5:12

How do you decide when to use a normal function versus lambda.

312000 5:12 - 5:18

All a lambda is is a function definition without assigning a name to it.

318000 5:18 - 5:22

In a normal function definition we say "def", then we say the function name,

322000 5:22 - 5:24

the arguments, and the body of the function.

324000 5:24 - 5:26

We're simultaneously doing two things.

326000 5:26 - 5:31

We're defining what the function does, and we're giving it a name.

331000 5:31 - 5:34

Now, what a lambda does is break those out

334000 5:34 - 5:36

to say we're defining a function, but we're not giving it a name.

336000 5:36 - 5:38

Why would you want to do that?

338000 5:38 - 5:40

Well, we do it all the time.

340000 5:40 - 5:46

If we have an expression--like say we have the arithmetic expression x + 1 * x - 1,

346000 5:46 - 5:51

we didn't both to give names to those subcomponents--the x + 1 and the x - 1.

351000 5:51 - 5:55

We just wrote them down. So a lambda is like that.

355000 5:55 - 5:59

It's a function that's a small thing. We didn't want to bother giving it a name.

359000 5:59 - 6:02

We just wanted to use it in place.

362000 6:02 - 6:08

So that's the advantage of lambda that you aren't bothered with a name,

368000 6:08 - 6:11

and you can just write it right there without having to define it at one point

371000 6:11 - 6:14

and then use it at a second point. That's the good thing about it.

374000 6:14 - 6:17

The bad thing about it is that it's limited.

377000 6:17 - 6:20

In Python lambda can only have an expression.

380000 6:20 - 6:26

It can't have statements in it, and it just doesn't really fit with the rest of the language.

386000 6:26 - 6:30

Some languages are really designed around expressions like that, and they go really well.

390000 6:30 - 6:33

In Python it doesn't fit that much.

393000 6:33 - 6:39

I think mostly you should avoid it and just define a function with its name in the normal way,

399000 6:39 - 6:42

but sometimes it's really convenient to put everything in one place

402000 6:42 - 6:46

rather than having to define in one place and use in a second place.

406000 6:46 - 6:51

Great. Udacer had some questions about the program design strategy that we've been using.

411000 6:51 - 6:54

Namely, should we implement the strategy that we've been using

414000 6:54 - 6:58

in every single problem we approach? Is there somewhere we don't really need it?

418000 6:58 - 7:02

If we chose not to use the strategy, what are some of the disadvantages?

422000 7:02 - 7:07

Well, whatever you can do to get your job done, go ahead and do it.

427000 7:07 - 7:09

I've given you some approaches.

429000 7:09 - 7:13

I wouldn't say that there is just one strategy, but rather there is a collection of strategies

433000 7:13 - 7:16

that you want to be able to understand what's going on,

436000 7:16 - 7:19

make your inventory of concepts,

439000 7:19 - 7:23

build those up. You have a lot of choices within that.

443000 7:23 - 7:29

Do I want to start top down, bottom up, middle out? That's all up to you.

449000 7:29 - 7:33

As long as you arrive at the end of a description of the whole domain,

453000 7:33 - 7:39

and the whole program and you get it right, then congratulations to you.

459000 7:39 - 7:43

I think every body develops their own style for how they go about addressing this,

463000 7:43 - 7:47

but there are ideas of what it means to have a high-quality program--

467000 7:47 - 7:50

correctness, efficiency, and so on.

470000 7:50 - 7:55

Then more driven by taste is what does it mean to be readable and extensible.

475000 7:55 - 7:58

You'll learn that over time.

478000 7:58 - 8:02

Great. For one last question, Takanzi wants to know if you have any good recommendations

482000 8:02 - 8:05

for computer science, and specifically Python, books.

485000 8:05 - 8:07

Oh, books. Okay.

487000 8:07 - 8:09

Yes, I do have some recommendations.

489000 8:09 - 8:14

If you search for Peter Norvig's library in Google Books, I have some there.

494000 8:14 - 8:19

With this question maybe I'll go and update them some more.

499000 8:19 - 8:21

I can mention a few.

501000 8:21 - 8:26

In terms of general programming books, I really like The Practice of Programming.

506000 8:26 - 8:30

I like The Elements of Programming Style, which is rather an old

510000 8:30 - 8:33

and somewhat dated book now in terms of the examples it uses,

513000 8:33 - 8:37

but still really up-to-date in terms of the advice.

517000 8:37 - 8:40

I like Structure and Interpretation of Computer Programs,

520000 8:40 - 8:46

which has been a standard textbook for introductory computer science.

526000 8:46 - 8:52

I like Programming Pearls is a nice collection of short essays.

532000 8:52 - 9:00

Then in Python books, there's a lot of them, and I haven't kept up with all the possibilities.

540000 9:00 - 9:05

There's a nice online book of How To Think Like a Computer Scientist that has a Python version.

545000 9:05 - 9:11

There's Python in a Nutshell, Python Cookbook, Learning Python.

551000 9:11 - 9:16

Headfirst Python, I think, is an interesting, somewhat different approach.

556000 9:16 - 9:20

There are a lot of them there, and I'll try to update my Google Books library

560000 9:20 - 9:24

to give a little bit of commentary on each one.

564000 9:24 - 9:28

Thank you. Thank you for all the question. Thank you for your answer.

568000 9:28 - 9:32

Stay tuned for the next unit, which will be posted on Sunday

572000 9:32 - 9:34

and also for a couple more editions to the Python glossary.

574000 9:34 - 9:37

All right. See you in class.

English subtitles

← Office Hours 2 - Design of Computer Programs

English subtitles

← Office Hours 2 - Design of Computer Programs

Embed video

Share