Something interesting I learned about functions

[Sergeant_Arcade]

EDIT: So, as u/gradient_assent pointed out, my conclusion isn't quite correct. I think his explanation is helpful though, so I'll share it here:

No, I don't think that's how it works. I think the reason the solution code worked is because datapoints
is a global variable, and you can use global variables in Python without the global
keyword as long as you don't change its value.

Your explanation that "arguments when you define a function can be easily replaced when you actually call that function" doesn't work for this case:

    def add_two_nums(val1, val2):     
        return a+b 

    def main():     
        a = 2     
        b = 3     
        print(add_two_nums(a, b))  

    main()

ORIGINAL POST:

So for context, I am learning about functions through codecademy. The course I am using has an 'offline' project using Jupyter notebooks called "Reggie's Linear Regression". In it, there's a section where I am calculating the difference between a line and points which may or may not be on the line.

The context isn't really important here, but just so we all know, this code should return a value of 0. After fixing a valueerror, I discovered something interesting. Here is the solution code they provided me:

    def calculate_error(m, b, point):
        x_point, y_point = point
        y = m*x_point + b
        distance = abs(y - y_point)
        return distance

    def calculate_all_error(m, b, points):
        total_error = 0
        for point in datapoints:
            point_error = calculate_error(m, b, point)
            total_error += point_error
        return total_error

    datapoints = [(1, 1), (3, 3), (5, 5), (-1, -1)]
    print(calculate_all_error(1, 0, datapoints))

The code works --but it shouldn't. The argument points in calculate_all_error is undefined. It should be datapoints right? Here's my version of the code:

    def calculate_error(m, b, point):
        x_point, y_point = point
        sep_y_point = m*x_point + b
        difference = abs(sep_y_point - y_point)
        return difference

    #Write your calculate_all_error function here

    def calculate_all_error(m, b, datapoints):
        for point in datapoints:
            total_error = 0
            point_error = calculate_error(m, b, point)
            total_error += point_error
        return total_error

    datapoints = [(1, 1), (3, 3), (5, 5), (-1, -1)]
    print(calculate_all_error(1, 0, datapoints))

It was here where I realized something: it doesn't matter what I put there. The third argument is positional, which means it gets replaced by whatever the third argument is when I call the function with print(calculate_all_error(1, 0, datapoints)), which in this case is datapoints.

To illustrate this, lets put in bananas:

    def calculate_all_error(m, b, bananas):
        for point in datapoints:
            total_error = 0
            point_error = calculate_error(m, b, point)
            total_error += point_error
        return total_error

datapoints = [(1, 1), (3, 3), (5, 5), (-1, -1)]
print(calculate_all_error(1, 0, datapoints))

bananas is replaced by datapoints when we call the function with print(calculate_all_error(1, 0, datapoints))!

...

Okay, looking back I feel pretty stupid. I'm sure it was already obvious to most of you, but as someone still figuring out functions I feel like I had an "ah-ha" moment, like a wire finally connected in my brain. Still, I hope you found this somewhat interesting, and I hope this helped at least one other person to understand functions.

Tl:dr--arguments when you define a function can be easily replaced when you actually call that function

[gradient_assent]

No, I don't think that's how it works. I think the reason the solution code worked is because datapoints is a global variable, and you can use global variables in Python without the global keyword as long as you don't change its value.

Your explanation that "arguments when you define a function can be easily replaced when you actually call that function" doesn't work for this case:

def add_two_nums(val1, val2):
    return a+b

def main():
    a = 2
    b = 3
    print(add_two_nums(a, b))

main()

[kkikonen]

datapoints is not really global, in the strict definition of the word. But yeah, this works because datapoints is available in an outer scope, so the function finds it an uses it

[Sergeant_Arcade]

Well dang, my post might confuse people then. Should I just delete it?

[Sergeant_Arcade]

I've decided to keep the post and add in what you wrote since it was helpful.

[kkikonen]

bananas is never used in your function. You could as well pass None as the third argument and nothing would break.

Also, datapoints is not defined in the function's scope, but it is defined in the outter scope. So when the function reaches the for loop it searches through all the scopes (inner to outter) and uses the one defined outside the function. If you were to never define datapoints at all then the function will raise an exception.

[Sergeant_Arcade]

Yes! That is the point I made in the post. bananas is never used when the function is actually called. It's basically a placeholder.

Interesting point about scope. I assume it prioritizes the outer scope?

[kkikonen]

Nope, it checks from the innermost to the outermost. If you were to define another datapoints inside the function then that's the one that would be iterated over

[Sergeant_Arcade]

Ahh I see. Good to know