Using arguments as variable names: Why does it solve this problem?-CodePudding

I'm going through some material about functions and I'm writing Python code to make some sense of the pseudocode examples.

The goal is printing the variables after I call the function, then check the new values.

def my_sum(x, y, z):
    z = x   y
    return x, y, z


A = 1
B = 2
C = 0

my_sum(A, B, C)
my_sum(B, C, A)
my_sum(C, A, B)
my_sum(A, B, C)
my_sum(B, C, A)

print(A, B, C)

My first instinct was to write this procedural approach, but when I do the calling the program won't give the right answer, because A, B and C aren't saving whatever is happening inside the function. So A is always 1, B is 2 and so forth

It turns out when I assign the calling with the arguments, the variables A, B and C receive the new values and they're now keeping it. Finally it prints 21, 8, 13, which is the answer.

A, B, C = my_sum(A, B, C)
B, C, A = my_sum(B, C, A)
C, A, B = my_sum(C, A, B)
A, B, C = my_sum(A, B, C)
B, C, A = my_sum(B, C, A)

How would you implement it or what are the other ways of writing this algorithm?

The thing is I can't wrap my head around why this works at all! It was just a random guess that happened to solve my problem.

CodePudding user response：

python don't have pass by reference option, only pass by value, so your construction is correct, because you returning NEW values (in tuple form), not changing value of variables, that you are passing in.

CodePudding user response：

In Python, an assignment made to a parameter name never affects the value of the name that the caller uses. They are separate names that initially reference the same object, but once the parameter name is assigned something else (like a sum), it references a different object.

Your second attempt works because the function returns a tuple with the values of the three paramater names and your main program unpacks that tuple back into its own names.

However, since the function doesn't need the original value of the third argument, and it doesn't touch the first two arguments, the caller doesn't really need to pass the third argument, and doesn't need to update its own names for the first two arguments... So the function could be designed to only take two arguments and return the new value:

def my_sum(x, y):
    return x   y

A = 1
B = 2
C = my_sum(A, B)
A = my_sum(B, C)
B = my_sum(C, A)
C = my_sum(A, B)
A = my_sum(B, C)

CodePudding user response：

Lets start with your function definition and one call.

def my_sum(x, y, z):
    z = x   y
    return x, y, z

A = 1
B = 2
C = 0

my_sum(A, B, C)

Without the function, this is functionally the same as:

A = 1
B = 2
C = 0

x = A
y = B
z = C
z = x   y
_ = x, y, z 
# x, y, and z are discarded since you don't do anything with the return value

You shouldn't expect this to change A, B, or C or if you do you have a misconception about how python variables or names work.

Python variables or names are just a dict with a name pointing to a value.

A = 1
B = 2
C = 0
my_sum(A, B, C)

# this is a very condensed version of what python does in the background
dict_of_globals = dict()
dict_of_globals['A'] = 1
dict_of_globals['B'] = 2
dict_of_globals['C'] = 3

my_sum_local_dict = dict()
my_sum_local_dict['x'] = dict_of_globals['A']
my_sum_local_dict['y'] = dict_of_globals['B']
my_sum_local_dict['z'] = dict_of_globals['C']
# and so on..

Since you only ever assign 1 to dict_of_globals['A'], it would be unreasonable to expect it to be anything other than 1.

The reason this works:

A, B, C = my_sum(A, B, C)

is because you are assigning the return value back to A.

A = x # etc..
# or:
dict_of_globals['A'] = my_sum_local_dict['x']