Python Functions Call by Reference (Duplicate)

In many programming languages, parameters can be passed by value or by reference using specific reserved words. However, in Python, when a parameter is passed to a function, it never modifies the value of the original variable in the calling function.

Example 1: Call by Value

k = 2

def foo(n):
    n *= n
    return n

j = foo(k)
print(j)  # 4
print(k)  # 2

Here, the value of k remains unchanged after calling the foo function because Python passes arguments by value.

Example 2: Call by Global

To modify the variable in the calling function, the global keyword can be used.

n = 0

def foo():
    global n
    n *= n
    return n

In this case, the global keyword allows n to be modified within the foo function, and its value will be updated in the calling function.

Pass by Object Reference in Python

Python, however, does not strictly follow call by value or call by reference. Instead, it employs a concept called pass by object reference.

In Python, variables refer to objects, not the objects themselves. As such, when a variable is passed to a function, it passes a reference to the object, not the object itself.

For example:

def append_one(li):
    li.append(1)

x = [0]
append_one(x)
print(x)  # [0, 1]

In this code, the append_one function appends 1 to the list x. Since the list is passed by object reference, any changes made to the list within the function will be reflected in the calling function.

Pass by Reference vs Pass by Object Reference

• Pass by reference: The original variable's box is passed to the called function, allowing any changes to the variable's contents to be reflected in the calling function.
• Pass by object reference: A reference to the original object's box is passed to the called function. Changes to the object are reflected in both the calling and called functions, but changes to the variable itself (the box) are not.

In conclusion, Python follows pass by object reference, where variables refer to objects rather than the objects themselves. This allows functions to modify objects passed to them, but changes to the variable references themselves are not propagated back to the calling function.