Distinguishing Between Pass by Value and Pass by Reference

The fundamental difference between pass by value and pass by reference lies in how memory is managed when arguments are supplied to a function.

Pass by value involves creating a distinct copy of the argument's data. When the function is invoked, a separate memory block is allocated for the paramter. Consequently, any modifications applied to the parameter inside the function scope are isolated; they affect only this local copy. The original variable in the caller's scope remains untouched, and the temporary copy is discarded once the function execution completes.

Pass by reference operates differently by passing the memory address (reference) of the original argument directly. No separate data copy is created. Instead, the parameter acts as an alias for the original data. Therefore, any changes made within the function manipulate the actual memory location of the original object. This method is often more efficient for large data structures since it avoids the overhead of copying entire objects, and changes persist even after the function returns.

How Python Handles Parameter Passing

Python utilizes a strategy often described as "Call by Object Reference." The behavior depends heavily on whether the passed object is mutable or immutable.

1. Immutable Objects Exhibit Value-Passing Behavior

When an immutable object (such as an integer, string, or tuple) is passed, the function cannot modify the original object in place. Attempting to alter the parameter effectively reassigns the local variable to point to a new memory address, leaving the external object unchanged.

def modify_number(val):
    print(f"Internal ID before change: {id(val)}")
    val += 500
    print(f"Internal ID after change: {id(val)}")

original_int = 10
print(f"External ID: {id(original_int)}")
modify_number(original_int)
print(f"Result outside function: {original_int}")

In the example above, the function modify_number attempts to update the value. Since integers are immutable, the addition operation creates a new integer object in a different memory location. The id() checks confirm that the reference changes inside the function, while the external original_int retains its original value and memory address.

2. Mutable Objects Exhibit Reference-Passing Behavior

Conversely, when a mutable object (like a list, dictionary, or set) is passed, the function receives a reference to the original object. In-place operations performed on the paramter directly affect the caller's object because they share the same memory address.

def modify_list(items):
    print(f"Internal ID: {id(items)}")
    items.insert(0, 'start')
    items.append('end')

my_data = [1, 2, 3]
print(f"External ID: {id(my_data)}")
modify_list(my_data)
print(f"Result outside function: {my_data}")

In this scenario, modify_list manipulates the list object directly. The id() values remain identical both inside and outside the function, proving that the same object is being manipulatde. As a result, the modifications (inserting and appending items) are reflected in the my_data list after the function call finishes.