Welcome back.

Now that you now to define and call a function,

we have to expand our discussion a little bit to talk about something called scope.

Scope refers to the visibility of parts of our program.

Not all parts of a program can be seen by other parts of our program.

This is really important to remember when you're thinking about functions.

The code you write inside of a function is only accessible inside that function.

That means if you assign a variable inside a function, you can't use that variable

in another part of your program and expect it to reference the same value.

This can be a little hard to grasp without seeing it.

Let's jump into some code.

Okay, take a look at my workspace here.

You see we have a variable assignment num=10.

Then you see a function set_num.

Inside the set_num function there's another variable assignment.

Num=5 after the function definition the program calls set_num.

What do you think will be printed when this program is run?

Pause the video here.

Open up the attached workspace, and run the file in the workspace terminal,

see what's printed, and then come join me again.

All right, how did it go?

Were you a little surprised by the value that was printed?

Let's break this down.

The variable assignment num = 10 takes place inside

what is known as the global context, or the global scope.

It's global because it's not inside any other function,

it's at the highest level in the program.

Any other part of this program can see, access, and

use this variable including the code inside the set_num function.

So when the set_num function is called and

Python encounters the num = 5 variable assignment, it doesn't reassign num, it

creates a new num that only exist inside the local context of the set_num function.

That means that outside of set_num, even if we've already called it, num will

always reference 10 until this reference has changed in the global context.

Inside the set_num function however, num will have a value of five.

Additionally, if we create a variable inside set_num,

we can't access it outside of that function.

I'll create a new variable inside the function called letter, and

it'll reference the letter a.

Let's see what happens when I try to print the letter variable outside of set_num.

I'm gonna save, run this down in my terminal.

Okay, we're getting an error here.

A name error that says name 'letter' is not defined.

Well, that's because there is no letter variable inside the global scope.

Letter only exists inside the set_num function and

can only be accessed inside of it.

If we move our print statement inside the function and try again,

we'll probably get a different result.

Now I'm gonna save and try it again.

Cool, it printed the letter a.

So now that you know a little bit about global and local scope,

you might be wondering how you actually get values and variables out of functions.

A variable's created inside a function, in the local scope,

can't be seen in the global scope, then what's the point.

Stay tuned to find out.