[MUSIC]

We've used some predefined functions throughout this course.

And they've proven to be super handy.

You know functions like print and input, we also used len.

Functions are great, they provide a way for

you to group multiple statements together to use later.

They help you avoid duplicating your code.

Now if you ever find yourself writing the same exact code more than once,

it's a symptom that something is likely wrong.

Now we refer to these symptoms as code smell, like hmm,

something about this code smells.

Here, let me help you write some smelly code and

then we'll clean it up with the power of functions.

Getting someone's attention these days is so hard.

In application development, you like have to bounce an icon or make a noise,

[SOUND] to alert them, right?

So one solution that we could do in our textual environment here is to yell in

all upper case.

And I feel like the more exclamation points,

the more likely they're gonna see it.

Let's do that, let's create some text and

then convert it to an upper cased and exclamatory phrase.

So I'm gonna make a new file actually, so let's go here, we'll go to File,

and then New File, and I'm gonna name it notifications.py.

So the first thing that I would love to shout from the rooftop

is some praise for you.

So, I'll assign it to the variable praise and

well say, "You are doing great".

So, we want to uppercase this, right?

And what we'll do is we'll just reassign it, so

we'll say praise = praise.upper.

And that's because strings are immutable and they can't be changed.

So it returns a brand new string,

which we're just going to take our label off the old one and put it on the new one.

Now I think there should be at least as many exclamation marks

as there are characters in the string, to really grab your attention.

So to get the numbers of characters in the string I can use the len function.

The len function expects an object, so we'll pass in our variable.

And then I'm gonna store that in a new variable called number_of_characters.

And I'm gonna call the len function, I'm gonna pass in our string, here we go.

So we wanna create a new value that is a combination of this praise and

the exclamation points.

So let's create a new variable called result.

And we'll make that praise and we'll concatenate the exclamation point.

And we're gonna rely on order of operations here so we'll say,

the exclamation point times the number_of_characters.

And then finally, we'll print that out.

And we'll run python notifications, cuz it's a new file.

There it is, YOU ARE DOING GREAT.

And you're doing great.

That's is some good looking code, and fine smelling too.

You know what, I also like to remind you that you should remember to ask for

help when you need it.

So can we yell that too, please?

I don't see why not, right?

So let's make a new variable, we'll call that advice and

that is, "Don't forget to ask for help".

And then, well I guess I would just copy this code, right?

Copy this code here, and paste it down here.

Guess I would change, I need to change this praise and make that advice.

And I make this advice.

Cuz it's the length of device,

not the length of praise because that's a different variable.

And then we do this, so basically I just copied and pasted that code and

changed this variable name.

That style of coding is called copy pasta, and it's not a good habit to fall into.

And it's really a bad habit, especially if you don't understand what the code

you've copied [LAUGH] is doing, it happens all the time.

So here we go, lets keep going.

You know what, I've got a another piece of advice for

you that I would love you to yell for me.

In coding, there's an acronym that we call dry or D-R-Y, don't repeat yourself.

Let's yell that.

So, I guess that's some more advice, right?

So let's call that advice2, and

we'll say, "Don't Repeat Yourself.

Keep things DRY".

Okay so, I guess I'll copy and pasta this.

We'll put this here and I'll go ahead and do advice2.

Advice2, the length of advice2,

and then we'll do advice2.

And then let's just make sure that this is working.

Okay, It is, but what if I told you that we had like ten more of these to do?

Would you be excited about that?

You know what, actually after seeing this in action, I'd like to make it so

that there are half as many.

This is [LAUGH], this is ridiculous.

That's way too many exclamation points.

So I wanna make only half of those as there are characters, right.

So half of the amount of characters we should do so.

One thing that I can think of doing is if we look we can make it so

that we use the floor division.

That was that the double division where we get an integer.

So we can, if we divide the number of characters by 2 and keep it an integer.

That should be that, and

I'm gonna put parens around here because I want the order of operations to work

correctly.

So let's go ahead, let's run that.

The first one looks great, but the other two don't seem to be.

Rats, I forgot to update those too.

Because my code is duplicated, it means any change that I need to make

I have to change every single place I copied and pasta-ed this code.

Well, that's really smelly right?

So let's clean up the smell, anybody got some Febreze?

[LAUGH] Totally missed product placement opportunity right there.

[LAUGH] I guess functions are definitely an air freshener for

these type of code smells.

So let's create one, shall we?

So the way that you create a function, let's get up here.

The way that you create a function is with the keyword named def,

which is short for define.

And then you give your function a name, let's name it yell.

That seems like exactly what we're doing, right, so we'll say yell.

And then when you're defining a function,

you define what parameters are expected when it's called.

So in this case, we want to accept the text that should be yelled.

Let's go ahead, and we'll call that text.

And then we add a colon, cuz we're gonna start the body of the function.

And you press Enter, and see how it's indented automatically here?

And now, we are in what is called the function body.

This is the code that is run when the yell function is called.

So we basically want to do exactly what we did in our previous code that we were

copying and pasting, right?

So let's just do that one more time, we're gonna copy this code here.

I'm gonna cut it out, when I come in here I'm gonna paste it.

And if you come in front of these lines and

press Tab, you can see that they tab into our body.

So instead of praise, this is now text.

I'm using Shift and the arrow key to do that highlighting.

You get better at those and you forget to say.

So that's how I'm doing that, so text.

That looks good, and

it's really good style to leave at least one space after your function definition.

So that it's clear that it's a function where it ends.

So now, we can go ahead and call that.

So let's do this, we'll get rid of this.

We won't assign it anymore, we'll say yell("You are doing great").

And then we don't need this other code too, let's clean this up.

So we'll say yell("Don't forget to ask for help").

And then finally, let's go call this last one here.

We'll say, yell("Don't Repeat Yourself.

Keep things DRY"), we'll get rid of these.

That looks a lot better, right?

Let's go ahead, let's run it and make sure things are working.

There we go, these lines are even shorter now, great.

So let's review what we've got.

So, we used the def keyword to define a new function named yell.

Yell declares a parameter which is named text.

This is the body of the function.

It's all this code that's indented four spaces by our style definition.

Now, the function body has code that upper cases and concatenates half-ish

the amount of text in the exclamation marks, and then it prints.

We've got a blank line after our function definition,

because we're adhering to good coding style.

It's important, right?

I want you to keep in mind that just defining this function

doesn't run the code.

What it does is it creates a new name of yell that we can call later,

and we can do it multiple times.

So here we're calling the yell method that we just created, and we're passing in

a brand new string that we just created that says "You are doing great".

So that's a brand new string.

And then the values that you push into a function are called arguments.

And since this is the first argument, right, there's only one.

It's the first argument here, and it's called text here.

So basically what this is saying, is text equals you are doing great.

That's what I want you to imagine.

So text equals you are doing great, and

then the rest of the code runs on you are doing great.

It runs through each one of these texts you are doing great, you are doing great.

Prints the result, and then it pops back out to whatever the next line is.

In this case, is another call to the yell function.

And we create a new string that says, don't forget to ask for help.

And imagine again, text equals, don't forget to ask for help.

And then the rest of the function runs, it pops out.

We get to the next one, yell, don't repeat yourself.

So on and so forth, I feel like I'm repeating myself.

Now also if we wanted to change the way that this yell function worked,

we only need to change it in one place.

Like for instance, I think even this too is a little long.

Why don't we do it to a fourth of that?

So if I come up in here,

I can just change this in one place now and all of those functions run.

Functions are pretty handy aren't they?

We've just scratched the surface of how powerful these functions can be.

But, they definitely help you to create nice reusable code.

And try to stay on the lookout for lines of code that are repeated.

Recognize the code smell.

Don't repeat yourself is a great mantra to live by.

It will lead you to write clean, understandable, and maintainable code.

Everyone can agree that repeating what you're saying over and

over is super annoying.

Everyone can agree that repeating what you're saying over and

over is super annoying.

Everyone can agree that repeating what, right.

Keep things DRY everybody.