[MUSIC]

How many of you.

So, a lot of you do Python. How many of you have done

functional programming in Python, JavaScript, any language that supports it,

which is most of them?

Some of you?

All right. So,

functional programming is a fun little area.

So the basic idea is that you do all of your computing,

all your programming just by evaluating functions.

So you always have expressions like this thing is equal to that thing.

Thank you.

And it really helps when firs, functions are first class citizens of the language,

which means you can pass functions around.

Ooh.

So you can send functions to other functions.

You can make a variable just equal to a function, and

then call that thing over and over again.

You can do all that fun stuff.

All of this applies to Python, which is great.

Another rule for functional programming.

And this is one we're gonna bring up a lot,

is that functions shouldn't have side effects.

So if I run a function with the same data,

I should get the exact same output every single time.

That seems kinda obvious, but let's talk about it.

So in Python, if I do this.

What is the list that I passed then on the outside?

Right, I had a list and I passed it in, yeah?

Let's just do it. [BLANK_AUDIO]

All right.

[SOUND] So we're in Python.

[BLANK_AUDIO]

42, 28, 1, 105 and 2.

All right, messy list, yeah?

[SOUND] Now cheating.

All right, so there's my function.

If I call reverse list, and I pass in a.

What'd I get back?

>> [INAUDIBLE] >> Right.

So now what is A?

Is it my old list or is it the reversed list?

>> [INAUDIBLE] >> Nope.

This function has a side effect, because this function calls list.reverse,

which reverses list in place, because lists are mutable.

You don't want that.

You don't want side effects.

'Kay.

So.

Eww.

>> [LAUGH].

>> Because we don't want side effects.

So we're gonna talk about addressing side effects in a moment.

But we'll go through some more bullet points here.

Functions should also be limited in their scope and their functionality.

You wanna write small little functions.

Lots of them.

But they're really small.

Right? They just do a little bit.

For instance, this is very ew.

Let's look at this and we'll see part of why it's bad too.

So we taken a list, we reversed the list, we swapped the first and

last items of the list, we stick a thing into the list.

If it's a string, then we reverse the first thing that's in the list.

Or sorry, if the first thing in the list is a string,

we reverse the first thing in the list.

Otherwise if it's a number, then we int divide it by 2,

and then we eventually return the list.

This is horrible, it does a lot of stuff.

It doesn't have any side effects though.

Which is nice and weird but it's still ugly.

So we can break it apart into nice, small functions, right?

Cuz we want them to be limited in what they do.

Small scopes, small amounts of functionality.

This isn't necessarily better cuz it's still doing really ugly stuff down

there on the bottom but it's better.

Cuz it's small.

Right?

Okay, last thing and we'll get to some code.

Well, almost last thing.

It's great if functions can chain.

So if I can multiple functions that always give me back more data,

I can put those functions inside of each other,

and I can do a whole lot of stuff in one line that's all very explicit, but

it's not scattered out doing crazy weird stuff in each function.

Okay, so that means we're gonna use return a lot, way more than you may be expecting.

And, like we said before with the list.reverse, we don't want mutations,

we don't want to return like, things that have been mutated.

Okay, we get some chaining-friendly things from Python, yay.

So let's start with map.

Anybody heard of map?

Few people. Anybody want to tell me what map does?

Without reading this!

I know it's already up there, but without reading it what does map do?

So what map does [LAUGH] map takes a function.

Map is a function, it takes a function.

And then it takes an iterable.

And map runs that function on everything that's in the iterable.

And gives us back a new iterable, right?

So, if I have a function that turns numbers, turns things into strings.

Right?

It's really annoying that I can't Cmd+Tab from there.

All right.

You've all seen str, right?

The string class?

And if I do str and a number, I get back a string of the number.

Yeah?

Nothing crazy there?

'Kay.

So if I send in the string function to map.

You know, hold on.

There we go.

If I send in the string function to map and I give it a list of numbers.

Thanks Python 3 for making me look silly.

I get back this map object which is a generator.

All right, there we go.

I get back a list of strings of numbers.

So really handy if I want to make sure everything in here's a string.

Make sure this is all strings, right?

So all I've done is I applied the string function to everything that's in the list.

All right.

We could do the opposite of that.

[BLANK_AUDIO]

Now we see how well I can, [SOUND] wow.

>> [INAUDIBLE] [SOUND].

>> There we go. And

now we got ints instead of strings, 'kay?

We're gonna do some crazier stuff with map in a moment.

But, that's the idea of map.

Run a function over everything that's in a list, or a dict, or a tuple, or whatever.

Okay.

Filter is our next one.

How many of you have messed with filter?

Nah, a couple people.

All right.

So filter is a handy way of saying, make sure all this stuff is true.

Or is like I want it to be.

So, ignore the or none for right now.

If we pass a function into filter, that function must return true or false.

For everything that's in the iterable, we run that function.

If that function gives back true, that thing that was in the iterable gets kept.

If it returns false that thing is discarded.

'Kay?

So if I'm like, I've got a list of people and

I wanna make sure all these people are 21 or over.

They'll have an age attribute.

I can write a function that checks the age.

Make sure the age is 21 or up.

And if it is, returns true, otherwise returns false.

All right?

So a quick easy way to filter through a bunch of people.

The none is a fun little shortcut.

You just pass none instead of a function,

it only returns things in the iterable that are truthy in Python.

So no zeroes, no empty strings, no empty lists, nothing like that.

But you'll get back all of your lists that, or

all of your strings that actually have content.

All of your numbers that are not zero.

All that kind of stuff.

We'll do a lot of stuff with filter too.

And our last one we're gonna talk about is reduce.

Reduce is a little weird, compared to filter and map.

Reduce always gives you back just one thing.

And the function always takes two arguments.

So what it does, is for

the first two items in the iterable, it runs the function with them.

Takes whatever the answer to that function is, runs it against the third item in

the iterable and so on, until there's just one answer that comes out.

So if my function just adds two numbers together, I pass it a big list,

I get the sum of the list.

If it multiplies things together, I get the product of the list.

All right?

We'll do stuff with reduce as well.

That's enough talk.

so.

Let's go do stuff.

All right.

Wow, I got a lot of things open.

[SOUND] So, there was a GitHub repo that had these three files over here,

test_filter, test_map, and test_reduce in it.

And we can test all of those at once by running python unittest.

All of our tests pass.

Because we ran 15 tests and we had 15 failures.

So lets fix that.

So which one do you want to do first, filter, map, or reduce?

>> I don't care, we can do any of them.

>> Filter, map and reduce?

All right, lets do filter.

I'm going to close this one.

And all right, there we go.

So we just have Emacs.

Yes, Emacs.

I think I was on vim the last time I presented up here.

All right, so we got a bunch of stuff up here.

We've got some nums, we got the states, we got some some values,

we got a bunch of strings, and then we've got this string of numbers.

Which this is a generator pattern.

I talked about how filter gives us back generators.

We're not gonna worry about what generators are.

Just, yeah.

That's why it's a stream instead of like number_list.

And then we have this word_list function that opens up

my dictionary that's built into my computer.

And gives me back all of the words that are in that dictionary.

Which is a lot of words.

>> [LAUGH] >> Safe enough for this.

All right, so then we've got some tests.

So let's look here at our first test.

Our first test is positive numbers, so I wanna make sure that all

of the numbers that are in this positive numbers variable, are greater than or

equal to zero.

So no negative numbers.

'Kay, but if I look at nums I got a negative two in there.

And I want to get rid of that.

And I'm going to be, somewhat obtuse and not just use remove.

So let's write this.

So positive numbers has to equal something.

So filter, there's gonna be a function and there's gonna be nums right?

So, I want interaction on this by the way, you can all yell out things at me.

And I will ignore the things I don't like.

So, we need to write a function that only gives us back the numbers that

are greater than zero.

So what are we gonna call it?

Anybody?

How about positives?

Yeah, does that work?

Okay, and it needs to take a single item, so it's gonna take a num.

Or an nu.

Okay, inside of this function how do we check the numbers greater than zero?

Or greater than negative one, rather.

Return num greater than or equal to zero.

Does that work?

Good for everybody?

'Kay?

That's it. That's my entire function.

All I'm doing is making sure that number's bigger than that.

And in here I have to tell it what function to run.

All right, I'll scroll that up a little.

As much as I can since I'm at the bottom of my file.

So all we're doing is we're using filter.

We're using our positive function we just wrote.

And we're using our nums list that's up at the top.

'Kay?

Shall we see if it works?

Yay.

It does. Cuz we only have six errors out of

seven tests.

So we got that one to work.

Somewhere up here will be a little sign that says it worked.

Yeah, there's our dot.

The rest are all e's.

All right that's our way we're gonna do this, this whole TDD thing so.

Let's go to another one, yeah?

[BLANK_AUDIO]

Okay, our next test is no non-zero numbers.

So all the numbers that are not zero.

So short cut on this one, anybody tell me the short cut real quick?

We talked about what filter does.

>> [INAUDIBLE].

>> Right.

So, non_zero_numbers is what we have to call this.

So, filter None and nums, right?

Cuz zero is falsey thanks to the glory of Python.

Sorry for things like, flashing up there, my, my Emacs likes to do a lot of things.

All right.

I also think it's kinda cool that I wrote way more lines of code for

tests than I have to write for solving this.

And we're gonna make it even shorter by the end if we get to lambdas.

So, yay.

Or list comprehensions.

All right, let's see if that passes.

It does. Five errors, not seven.

All right.

What's our third one?

No vowels in one word.

So I got a word.

My word is California.

I don't want there to be any vowels in it.

So vowel is my variable here.

Sorry let me find my word back up here again.

State, that's my word.

Okay so what function would I write?

[BLANK_AUDIO]

Actually that's not gonna be a word that comes in.

Gonna be a letter.

Because when we look at a word as an interval we just get the letters.

Right?

So how do we get rid of the vowels?

If letter in aeiou, actually

we'll do it easier, not in [NOISE].

Or return true, either way.

Returning the letter is truthy, returning true is very truthy, because it's true.

All right, and then no vowels.

All right.

See if it works.

Oh, it didn't work.

Why didn't that work?

No_vowel_word.

That's what I'm supposed to call it?

No_vowel_word.

Wow, I picked weird variable names.

Still didn't work.

[BLANK_AUDIO]

Okay, I'm gonna cheat for a second.

[BLANK_AUDIO]

no_vowel_word.

Oh, that's right.

I gotta pass in an actual word.

All right.

Okay.

[BLANK_AUDIO]

I apologize.

I wrote these like late one afternoon.

So, some of them are gonna make a lot more sense than others.

There we go, four errors.

Okay, I'll go back to how I did that one.

So what we did was we just joined all the letters together.

Cuz we get back this list-like object from the filter.

So we just joined them all back together into one word.

Just to make sure it was a word.

I probably shoulda left it as a list but whatever.

It works.

Okay so we call a filter with no vowels on our state name lower cased.

Right, and then that gives us back this list-like object and

so we join it back together with no spaces.

So that it's a string again instead of this list-like object.

That's only cuz of how the test was written that we have to do that.

If the test wasn't written to where

it's calling this .lower, then it wouldn't have had to do that.

But it's okay. [COUGH]

[BLANK_AUDIO]

Cool, okay any questions at this point?

We've done three things for filter.

Everybody feeling okay with filter?

All right, you want me to leave the rest for you to do later, and

we can go onto map.

Let's do one more filter.

All right, that was awfully quiet.

[LAUGH] Let's skip the no false-y cuz that's pretty easy.

What I got here?

Only modulo three?

Only words over ten characters.

That'll be a fun one.

All right, so, I got my word list here, right?

All these words.

Tons and tons of words.

In fact if we do ipython from test_filter import as let's do import test_filter.

We get back this generator.

[SOUND] Wait I need two of those.

[BLANK_AUDIO]

Len list.

So we get back 235,000 words.

I only want the ones that are over ten characters.

All right?

That's easy, right?

How hard is it to, to only have words over ten characters?

'Kay. So let's do that.

>> Can you show what you had [INAUDIBLE] last one?

>> Yup.

That right there. [BLANK_AUDIO]

I will make all of the answers available at the end as well.

I'll set up a, a branch on the repo that's answers, and

that'll have the completed ones.

[BLANK_AUDIO]

Just in case anything gets missed.

All right so let's start ten letter words.

And I actually had to do this several times to make sure that like ten letter

words was still something feasible.

Cuz I started at like eight and it was still like 10,000 words.

And that was just stupid.

okay.

So ten_letter_words has to be words that are ten letters or more.

So let's do like word_length for our function.

And then we're gonna pass in word_list.

All right.

So help me write word_length.

It's gonna get a word, what do I wanna send back?

[BLANK_AUDIO]

So return, len word greater than or equal to 10.

>> So you're changing [UNKNOWN] cuz if it's only words over 10 characters.

>> [INAUDIBLE] Characters.

>> yeah. Good catch.

Bonus points.

All right so, our word length just says,

hey is this word more than ten letters long or equal to ten letters.

We could have also just done greater than 9.

Since words always have whole numbers, for

their length, you can't have a half a letter.

Give that a try.

Only three problems, yay.

All right.

I'll go back to this in case anybody missed word length, or 10 letter words.

This filter make sense?

You get a pretty good idea of how filter works.

It's just for truthy things, right?

[COUGH].

>> Inside of, now we say, well,

my memory works, maybe Craig can remind me itertools, I think.

There's filter false.

Is that itertools or functools?

One of those two, either inside of itertools or

functools, there's filter false, which is the opposite of filter.

So, filter only gives you back truthy things,

filter false only gives you back falsey things.

So depending on what your scenario is.

It's really not that hard to swap a Boolean,

when you're writing filter stuff and just, make it work the other way.

But, if you just can't do that for some reason, [UNKNOWN] does exist.

And it's pretty cool.

Works exact same way.

There's tons of cool stuff in functools and itertools yeah.

We'll eventually teach them, cuz I like them.

Okay, so let's move on, let's do map.

All right, I think maps actually are little bit simpler.

But, that's cool, alright, so we've got a bunch of numbers again.

We've got numbers from one to 20.

We've got some time zone strings, how many of you watched the dates and time scores.

Couple, all right, it's not the most exciting course.

And we've got a format string that we're gonna put stuff into and

we have some dictionaries that we're going to put into that format string.

Alright, so the first thing I want is I want to

get back the double of all of my numbers.

So I've got all these numbers, I want to double them all.

So instead of one, I want two, instead of two, I want four, that kinda thing, right?

And we're gonna put those in a variable called double_nums cuz, creative.

Double_nums = map, something against nums.

All right. This should be an easy function to write.

How do we double numbers?

[BLANK_AUDIO]

So we'll return num times 2.

[BLANK_AUDIO]

All right.

So double num, so we're just gonna run map.

And I'm gonna pass it doubler,

which is our function that returns number times 2 for each of the numbers.

All right?

[SOUND] Let's do another one before we before we test this.

Let's do the half numbers, cuz that's, that's the same idea, right?

[SOUND] So we've got half nums, and it's gonna be, we'll say, halver.

Halfer?

>> [LAUGH].

>> Whatever it would be.

[LAUGH] naming things is one of the hard problems in computer science.

[BLANK_AUDIO]

All right, and this would return num divided by 2.

Right?

So double nums we're multiplying by 2, half nums we're dividing by 2.

Really straightforward, yeah?

Okay?

By the way, I like map.

Map is just like, oh yeah.

[NOISE] Obviously that's the one I'm gonna do.

So five tests, only three of them failed.

So the time zones, the num strings, and the format strings are all bad still.

Let's fix those.

All right.

Num strings looks pretty easy.

Num strings actually looks insanely easy, because all we're wanting to do is

make each of our numbers a string.

I did this one like 15 minute ago.

Remember what it was?

All right, we're just gonna

pass our string function, or our string class that acts like a function or other.

And we give it to the, the nums variable, all right?

And the the nice thing about this is since there's no side effects,

our nums never changes, right?

We can do all sorts of stuff to nums,

we can do anything we want, and nums is never gonna change.

That's really good because if I'm getting data from a source like say, Twitter.

And I wanna parse this data repeatedly.

If I go and change it, I'm never really sure what state its in.

But if I'm always just processing it from its raw state,

then I know what state its in.

Its in the state that Twitter gave it to me.

So I don't have to deal with, okay let's make sure that this thing is still there.

Or, make sure that I didn't rename this part or whatever.

All right [SOUND] yay.

All right.

So, we just have two more.

You wanna solve these?

Let's solve these.

Which one do you wanna do first?

Do you wanna do time zones?

Whoo, time zones.

Or do you [LAUGH] wanna do the string formatting?

>> [SOUND] Time zones.

>> Time zones, all right, time zones.

Time zones.

Map.

[SOUND] And, what did I call that thing up there?

Time zone strings.

All right.

So what our test is wanting.

Where is it? There's what are test is wanting.

Are test wants all of the, we want a datetime.tzinfo instance, for

each of the timezones that are there.

So, actually forgot how I did that one.

I've been doing way too much time on stuff lately.

I used pytz, of course, which is why pytz is imported.

All right. So, let's make a method,

[SOUND] that makes timezones for us.

All right, if you haven't watched the course,

you may not know how to do this one, or if you haven't played with pytz yourself.

So, all we want to do is we want to

return pytz.timezone [SOUND] with the name that was passed in

[BLANK_AUDIO]

That makes sense?

We got the names, we're just generating all these timezones.

All right?

All right.

Let's see if that one passes, and then we're gonna hopefully make it simpler.

Air pass all right.

So, we know that map calls a function on everything.

What do we pass in, right?

So, I should be able to do,

[SOUND] pytz.timezone because that's a function, right?

It generates a time zone or

a tz info thing, we really don't want to go into what timezones are.

So I should be able to just call that method straight from there,

without having to use my time zoner.

Yep, I can.

So, I don't even have to write this code, that's useless code.

I wasted two whole lines and a blank liner, too.

Don't waste lines of code, they're precious.

Okay.

So, our last one is this format strings,

we've got the string up top, let's go look at it.

This format string, that it has a couple of named placeholders.

One of them's called name, the other is called thing.

It's a very creative sentence.

And then we have these dictionaries, that have keys and values in them.

We're gonna put those into the string.

Yeah?

All right.

So, we actually have to write code for this one.

What's this supposed to be?

Statements, map let's do formatter.

And we want to pass in here, is the dictionaries.

Cuz that's what we're gonna loop through, all these dictionaries.

[NOISE].

[BLANK_AUDIO]

See how hard it is naming things, I can't even come up with a good variable name.

All right trying to get this so you can see more.

So what we wanna do is we wanna return format-string.format and

we're gonna pass in the values as keyword arguments.

Is the star star surprising and new to anybody?

All right. So, star star is really cool in Python.

It turns a dictionary, into keyword arguments.

So, normally it have like, key colon value in your dictionary.

In your function call, you now have key equals value.

So, you don't have to find those values yourself,

you don't have to deal with reformatting stuff in whatever weird way.

You don't have to do, like, you know,

my_dict(key)=my_dict(value) when you're filling something

out, because that would be really annoying and take forever.

So the star star turns that into keyword arguments, which is really handy.

All right.

So, we call formatter on our bunch of dictionaries.

That in turn has whatever value comes in, or

sets the value since the dictionary with multiple values, right?

We send into our format strings format function, method.

Yay, all the tests pass.

All right, are there any questions about map?

Is map weird or confusing to anybody?

It's a little strange so if you have questions, feel free to ask.

No? Everybody's good?

All right.

You had your chance.

Now we're going on to reduce.

All right.

So, reduce.

The refresher takes a function, applies that function to the first two items in

an interval, takes that result and applies it to the third item, fourth, fifth,

sixth, so on, so we end up with only one item at the end.

'Kay?

And it looks like I left the functions in there.

So, that's handy.

All right.

[LAUGH] So, we wanna add some numbers.

so, add nums is reduced.

Which I imported, yay.

And our function is going to be add_two_nums.

And we're going to pass it nums.

So what does add_two_nums do?

It adds two numbers.

This is probably the worst example I have tonight,

because you should really just do the sum function with this, instead of reduce and

a function that adds numbers together.

But regardless, it's there, you get the idea of how it works.

All right.

Let's do multiply numbers as well.

So, this should be multiply nums.

We're gonna write a call reduce,

multiply two nums, and our nums.

So multiply two nums, as you can probably guess, multiplies two numbers together.

So again, instead of the sum of the product, we get the, or sum of the list,

we get the product of the list.

This isn't one that's built in as far as I know.

So, you'd have to write this one.

>> [INAUDIBLE].

>> There, not for

multiplying a list as it is there is a built in way to solve this problem without

having to write a function though, and we can talk about that in a minute.

It's a really cool library called Operator,

that's part of the standard library.

That has tons and tons of stuff in it, but one of the cool things it

has is a function called mul that multiplies two numbers together.

So you just use operator mul, instead of writing multiply two nums.

All right and then let's solve longest.

[SOUND] And what did I call it?

Did I call it states?

I did.

[BLANK_AUDIO]

Okay.

So we'll look at this one.

It takes two strings.

Yeah? Two strings.

And it returns if one is bigger than two,

then it returns one, otherwise it returns two.

There's another way of doing this too,

but we'll talk about that later if we have time.

All right, so

we used three already written functions, but this should solve our tests.

We're good.

There's our tests.

All right, any questions about reduce?

Does that one make sense?

Function that rates over sets of things.

Gives you back one final answer.

What was that?

Oh, work they were just doing?

Yeah, so, we have two strings that come in,

which we're creatively calling string one and string two.

We're checking to see if the length of string one is greater than the length of

string two.

And if it is then we send back string one.

If it's not, which means that string two must be longer or

they're equal, which I've made sure they weren't then it returns string two.

Yeah, so the first time through it's gonna have Ohio and Alaska.

So which one's longer?

Alaska, so the next time though,

Alaska becomes state one, and California comes in.

So, which one's longer?

California.

So, state one becomes California, state two becomes Oklahoma.

California is still longer so, there's nothing else to take as another argument,

so it says okay, California's your answer.

And sends that back.

So this works with a lot of things.

If you're like hey, I've got, again, maybe all these people, I need to know

which one's been employed the longest, and they all have, you know, start date.

Make a date time from when they got started,

subtract it from now, you find out hey, this dude's been here for

10 years and this women's been here for 12, so she's got seniority.

Reduce is actually a lot more handy than filter or

map, but it's one that you won't see used as often, which is weird.

So, lets see what's next in my key note.

[NOISE] More blank slides, functions to know and love.

I don't want to cover every single of these, but

if you look through the tests you'll see some of these used.

These are functions that come up pretty often and

functional programming in python.

So the first two are related, max and min.

Max gives back the biggest of the things that are sent in,

min gives back the smallest of the things that are sent in.

So, your state names you should be able to do max and min on those.

Although that may do alphabetical sorting, I don't remember.

We can test it later.

Any and all are related.

Any takes an iterable, and it gives you back a true,

if any of the things in the interable are true.

So, it can have 1,000 false things and one true thing, and it'll come back as true.

Cuz at least one of those things is, is true, right.

All is kind of the exact opposite of that,

it will only tell you true if every single thing in there is true.

You'll see me use all a lot in the tests.

And if you could see your code challenge tests, you'll see all used a lot,

because I love all.

All's especially great if you put conditions inside of there.

So, your list items are like, x is 5 or x is less than 2.

Those are gonna evaluated as the true or false.

And then reversed takes an irritable and

you remember how we did list dot reverse and we got, the list reversed in place.

So reversed will actually send you back a new list,

that has been reversed from the old list.

So, it doesn't overwrite your old one.

Cuz we don't wanna mutate things.

And then sorted is the same idea, instead of calling list.sort you

can use sorted on a list and you get back a sorted version of the list.

Sorted has some other stuff you can add to it, to change how it sorts.

But that is beyond tonight.

We will end up covering all of this stuff at some point so, yeah.

[INAUDIBLE] It'll do a natural sort.

okay. First, let me repeat that.

[LAUGH] since [UNKNOWN] pointed that out.

so, if you don't provide a way to sort, to sort it, what does it do?

So it does a natural sort.

And what a natural sort is, is kind of how you think of things as being sorted.

So, like, numbers will come first, and then characters.

Right? I may have that backwards.

I'm pretty sure that's right.

So you'd get,

you know, numbers one through ten, or whatever your order is, yeah?

And then you'd get your words and they would be sorted alphabetically.

>> So [INAUDIBLE]

>> I think caps may come first, but I don't remember.

So all these things you can play with.

Sorted is pretty handy on its own.

Once you start writing the sorting functions that it expects,

it opens up like whole new worlds.

Cuz you can just sort by crazy,

like I wanna sort by these five nested attributes, and it'll handle it for you.

What else is in here?

Questions, we'll come back to that one, cuz it hasn't been that long.

Okay.

Let's talk about lambdas.

Anybody use lambdas?

You have, probably.

Who's written anonymous functions in Javascript?

Where you just pass function into something, those are lambdas.

They just don't call them a cool name.

okay.

So let's go write a lambda real quick.

So we'll have nums, I'll again make it a list of one through 20.

All right.

So, nums is just some numbers, right?

And we had earlier, we had this map and

we had a doubler function when we passed the nums, right?

You remember doing that?

All right, I don't wanna write doubler, because I'm lazy.

All right, so nums I still have,

I don't wanna write doubler, so I'm gonna write map.

I'm going to write the word lambda, which I have a really hard time typing so

tell me if I misspell it.

So lambda is an ominous function.

Functions take arguments, right?

So after we say lambda which says give me an ominous function we can tell it

what arguments that function is going to take.

So.

>> Doesn't matter, I'm gonna call it num.

Okay.

And we do a colon, cuz it's a function, it starts with a colon.

And the weird thing with lambdas and

Python is you can't press return, so they all have to fit on one line.

There's a cheat around that, but don't worry about that for right now.

You're new to lambdas, just write them like they are.

And then they have an implicit return,

they automatically return whatever they calculate.

So we're just gonna do num times 2, 'kay.

That's my function.

This lambda thing, all it does is return num times 2.

Then I pass in nums.

And I'm gonna make this a list so that you'll be able to

see the numbers instead of seeing a map object, which will make no sense.

Yay!

So I don't have to write functions if I don't want to.

As long as it's something short.

I mean, if you were doing all sorts of complex stuff, you obviously probably

don't wanna use lambda's, unless you can break it up into a lot of little steps.

But if you're just doing something short and quick, lambdas are amazing.

So what that means [SOUND] is we

can do all of these without functions.

So let's solve solve this modulo three one,

modulo_three_nums is gonna be a filter, and we're doing it with nums.

All right, so I have a lambda, right?

And it takes a number, and

I'm gonna return if that number modulo 3 is equal to 0, 'kay.

Cuz modulo is weird as Dave can tell you.

And we have to make sure that it's equal to zero, all right.

Now, we'll, we'll see if anybody gets this.

You should.

Why do I have to make sure that it's equal to 0, instead of just doing modulo three?

Because if I just do modulo three, I get back either a number or I get back zero.

Right?

So on ones where it actually is modulo three, I'd get back zero, which is falsy.

Which would make filter not included.

So that's what we have to do the, is equal to zero, so we get back true.

It's a weird one but it works.

And it makes sense sorta.

Lambdas in their very simple, simple sense.

Anybody completely lost on lambdas?

There's all sorts of crazy ways you can break them,

but we're not gonna worry about those right now.

And then you can break Python using lambdas too which is really fun.

I'll show you how to do that in a minute if you want.

All right, so that was in filter.

Let's run that.

All right.

So we just have two wrong ones now instead of three.

We had three wrong ones before, just two now.

All right.

That is lambda.

Let's do lambda inside of one of our maps as well, oh we already did a doubler.

[NOISE] so we can do it here too.

So we've got lambda, and we've got values.

I'm actually just basically copying what happened up there in formatter,

format_string.format (**values).

All right.

It's literally the exact same code I just write,

I just wrote lambda instead of def formatter(values) return.

So I saved what, 30 characters?

But if I'm only ever using this once or maybe I'm assigning my map

to something else somehow so that it can be called multiple times with multiple

values then you know, I save myself a decent amount of typing.

Let's make sure that still passes.

[SOUND] It does, yay!

And then, I guess the last thing, before we do question.

Actually, we'll go ahead and do questions.

I'll leave list comprehensions for another time.

But before we do questions, I've got one other thing that's important.

So if you want help, if you're like,

Python's really cool, but some of the stuff is confusing.

There are two awesome groups here in Portland.

One of them is the PyLadies.

Yeah, PyLadies.

They meet like 8,000 times a week.

It, seriously their, their meetings are crazy.

But they're an awesome group of women beginner all the way up to expert.

Great group if you need help and are of the womanly persuasion.

And then every Monday night,

there's a thing that they call the Python Flying Circus.

This happens over at the Code Guild headquarters, which I can never

remember the street they're on, I think it's Water, or Paper, or some other noun.

But if you join the PDX Python group,

which is our general Python thing, you'll get tons of meetups.

But they meet up every single Monday night and it's pretty awesome.

You show up, if you've got questions they've got mentors.

If you want to mentor people, they've got questions.

awesome, awesome group to hang out with.

All right, so now I'll go back to my questions slide, just so it looks cool.

Anybody have questions about functional programming in Python?

Yes. >> [INAUDIBLE] How do I make my lambdas on

two lines?

>> How do you make lambdas on two lines or more?

But that's cheating.

>> [INAUDIBLE] >> All right.

So I'll show you a couple of fun things with lambdas.

Cuz I like lambdas.

I think lambdas are really cool.

But I don't like a couple of the rules about lambdas.

One of which is they're temporary, they're anonymous.

The other which is they can't be on multiple lines.

And the third of which is they don't give me any help.

So let's solve those in not that order.

So multiple lines.

map, sorry, list map.

[NOISE] There we go

I'll eventually get

enough parenthesis.

You make it a container.

It's a hack but it works.

If you find that you're constantly writing lambdas that are three, four,

five lines long, just write a function.

Don't, don't mess with lambdas like that.

It's just, it's really not worth it.

Cuz at some point you're gonna forget that open parenthesis and

then, you're just lost.

So let's talk about breaking lambdas,

cuz lambdas, that lambda doesn't really exist, right?

I mean it's, it's there but it only exists so long as map is running.

But if I've written a really cool lambda and

I wanna have it around for a long time, I can just name it.

[NOISE] So now I can do.

[NOISE]

Yeah.

So now doubler exists.

It's not a real function and

it's not really a lambda, it's just a thing that's there.

Cuz if I do like type doubler.

I mean it's a function, it is,

because lambda's are functions, but yeah, it's not really a function anymore.

Yes? >> So then like,

what's the advantage then, you don't have to type return, is that?

>> So the advantage to lambdas is, yeah, you don't have to type return.

And if it's something you're just doing once, it's,

seems kinda silly to go write a two line function if you don't have to.

If I'm only ever gonna do with once,

why am I wasting memory holding on to a function?

Why am I wasting lines of code by writing the function?

>> So in the case of like [INAUDIBLE] would that make sense

[INAUDIBLE] inside that function to like, scope it or whatever?

>> The naming like this, right at the doubler equals?

>> Like if you want to use the same lambda more than once [INAUDIBLE].

>> So the question is, does the naming only make sense if

you need to use it more than once in a function?

Yeah, pretty much.

It's, I, I, I know I'm gonna need to do this a couple of times I don't

wanna write it over again.

And for some reason I'm opposed to nested functions, so I named my lambda.

So then, the other thing with breaking lambdas.

If I do help on the doubler.

I, of course don't get anything because it's just a lambda but meta programming.

So doubler.doc equals doubles numbers.

And now I can do, help(doubler) and I get hey, it doubles numbers.

But it's still a lambda.

It still doesn't really know what's going on, but it's a lambda and it's there.

You're not supposed to do these things to lambdas, don't,

don't do these things to lambdas.

But lambdas like all functions in Python they can do star args, they can do

star star kwargs they can they are functions for all intents and purposes.

They just can't have returns in them or new lines in them.

Like one of these.

That's just me not counting parentheses correctly.

And then Python going, hey you missed a parenthesis.

Yeah, it's, I do that a lot.

I love having syntax highlighting in browsers [LAUGH] or editors.

Cuz, yeah.

All right.

Anybody else?

Any other questions or problems with functional programming?

Yeah, Portia.

>> This is more of a high level question.

>> Okay.

>> What problem is functional programming solving like,

what convenience is it bringing to the program?

>> Okay. So

what convenience, what problem does functional programming address?

So functional programming isn't like a panacea, right,

just like object oriented programming isn't.

Object oriented programming will not be applicable in

every single scenario that you find yourself in.

And functional programming won't either, but you can often do

things a lot faster and cleaner using a functional approach than you can in

writing a class or, well a class, yeah writing, you know, creating objects.

Or writing a function that maybe does all this work in one function.

And then you have to remember that is does all that stuff and,

what if something changes?

What if I no longer wanna do that step, I have to go edit this thing.

Functional programming, that mentality where you're writing things very small and

reusable, you get to the point where, if you're always writing like that,

editing your approaches to code becomes a lot simpler.

I just take out one function call.

Or I go change this one function, and I don't have to worry about

what happens elsewhere, because, you know, I'm paying attention to this one thing.

So it's,

the benefit it gives is that things are in smaller more digestible packages.

And, yeah, that's pretty much it, smaller packages.

>> So I guess it prevents the programmer from making a function and

having the function do like five or six things.

>> Can prevent somebody from [LAUGH] yeah, if if you have the the functional

programing mindset you're, you're used to always creating these small little,

I mean they almost seem pointless these little functions, cuz they're so tiny.

The ones that we wrote tonight are,

are very short, you'll ending up writing ones that are five, ten lines long.

But they do one thing, one major thing, right?

So it gets to where you stop trying to put everything into classes that

you create for, just, I need a thing that does a thing, right, so you build a class.

That works, but that's often way more overhead mentally and in your program.

And it stops you from writing functions that do 50 lines or a 100 lines of stuff.

Because you always break things up nice and small.

[NOISE] I mean, I'm gonna pick on Chris.

He's always done object-oriented stuff and when I first started learning

functional programming I'd be like, hey try and do this thing!

And he'd start writing a class.

Which worked [LAUGH] and it does it.

But it's like that's not the approach.

>> What. >> [LAUGH] Yes, that's why you're here.

All right, anybody else?

We're good?

All right, I will put the answers up in a branch, I'll try to

make sure they all have lambda options and stuff like that as well.

But, they, some of them may not.

And then, that's it.

That's our code.

[APPLAUSE]