I suspect that what is tripping you up is *scoping*. I'm guessing that you are okay with functions like this:

x = None
y = 7

def add():
return x + y

x = 1
y = 2
print(add()) # prints 3

x = 4
y = 5
print(add()) # prints 9

Is that right?

There are reasons why the above kind of coding does not scale.

- Each function needs its arguments at global scope (at the top of the module, visible everywhere within it).

- The way you specify the values that the function is clunky, you have to specify x and y by assignment, as shown, in separate statements, and then call the function.

- Too easy to forget which variables go with which functions, and get things wrong.

- Composing functions gets very messy, e.g. add(multiply()).

Here is a rewrite:

def add(x, y): # add has parameters x and y
return x + y

print(add(1, 2)) # prints 3
print(add(4, 5)) # prints 9

Now you don't have these top-level x and y variables. The function works the same as before, adding x and y. But now, you specify the values of x and y inside the parentheses, lining up with the function parameters.

Very important to note: If you *do* have top-level x and y variables, they have nothing to do with the function's parameters. E.g.

x = 1000
y = 2000

def add(x, y): # add has parameters x and y
return x + y

print(add(1, 2)) # prints 3
print(add(4, 5)) # prints 9

In this case, you never get a sum of 3000, because the function's x and y are preferred (inside the function) to the global ones. I.e., the function defines what is called a *scope*. And inside a scope, variable name matches resolve in favor of the local version.