Anonymous functions are functions that don't have a name, hence being anonymous.

I say that, but it's not a 100% true.

You can give anonymous functions a name in Python, but you don't have to and

usually won't.

We call anonymous functions lambda's, borrowed from mathematics lambda calculus.

Remember that whole, programming is done with expressions bit?

We've come full circle.

Let's jump over to Workspaces and see how to use lambdas and

how they can be applied to our existing functionality.

So lambdas are anonymous functions in Python.

They let us just write a function somewhere that we need one, and

we don't wanna reference that function again.

We can give lambdas names, so they're not anonymous, but that's a little weird.

Most people don't do that.

And lambdas are really only meant to be one line long, and

lambdas can't contain assignments, so we can't do a equals five.

You might be thinking,

well that's an awful lot of rules, why do we even wanna have lambdas then?

It's because they're really useful for little one off problems.

They're very handy for, I don't wanna write a function,

I just need to throw this thing in there, so let me do that.

For instance, all these places that we've been writing functions up here,

with the exception of the maps.

So, this map here, the title case, and this map here, the sales price.

We have to do assignment in both of these.

So we can't do these as lambdas.

But we can do our functions and our reduces and stuff as lambdas.

So let's see about that.

Let's look at this one.

We just did this total one, right?

Total equals reduce add_book_prices, so let's repeat that.

So let's do total, and it's gonna be reduced, and

now I haven't written a function, but my function up there just did a + b, right?

So, we're going to do lambda, and

we're going to take two numbers, x and y, just like in algebra class.

And we're gonna add x and y.

And lambda's automatically return the last value that they calculate.

They have an implicit return, so

you can pretend that there's the return keyword right there.

But you don't wanna put that in.

Okay, so this is our lambda.

So we have lambda.

These are the arguments that the lambda takes.

In this case our lambda takes two arguments, x and y.

A colon cuz we're starting a block, but we're not indenting the block.

Lambdas are a little bit strange, huh?

And then this is the body of our function, just x plus y.

And that gets returned automatically.

So now it's a reduce so we have our function and

then we have our list of values right?

So let's say b.price for b in BOOKS So

when we run this we should get 225, so we did.

So, we got the same amount of work but

we didn't have to write a function just to add two things together.

So, that's pretty cool.

Let's do our long_books again.

So, it's a filter and lambda is x.

Now lambda can be anything, we're gonna say book.

Lambda book.

Cuz we're gonna get a book, right?

So book.number_of_pages.

[INAUDIBLE] equal to 600 and we're gonna do this out of BOOKS.

All right, so now since I want to be able to print,

let's do len(list(long_books)).

So how many long books do we have?

We have 12 long books.

If I remember correctly, that was the number before.

So lambdas are really handy for being able to stick in places that we

don't wanna have to write a function that's only gonna get used one time.

We could do, good_deals = filter (lambda book:

book.price <= let's say 5.99, all right,

we'll do 6, so if the book's than $6 this time.

Out of books and we're gonna print len(listgood_deals)) and

let's see if there are any good cheap books.

There's 6, cool.

So 6 books that are nice and cheap.

So again lambdas are just something that you use instead of having to

write a function for something that you're only gonna do once.

That's where lambdas come in really really handy.

You might have heard the expression, when all you have is a hammer,

everything looks like a nail.

Well, lambdas are often a big hammer in the Python world.

You learn about them, and then you want to use them in all sorts of places and

situations.

Most of the time, a lambda is the wrong choice unless you're sure that you're only

going to need a particular bit of functionality once and

only in one location.

Writing our full functions might be a bit more trouble and take up more room, but

it will usually serve you better in the long run.