Function Parameter Passing Mechanism in Python: Behavioral Differences Between Mutable and Immutable Arguments

Problem Description:
In Python, the way function parameters are passed often confuses beginners. When passing immutable objects (such as integers, strings, tuples) and mutable objects (such as lists, dictionaries) as arguments, operations on these parameters inside the function produce different results. Please explain in detail Python's function parameter passing mechanism and illustrate the behavioral differences between mutable and immutable arguments through examples.

Knowledge Explanation:

Step 1: Understanding the Relationship Between Variables and Objects in Python

• In Python, variables are references (labels) to objects, not containers storing data.
• Each object has an identity (id), type (type), and value (value).
• The assignment operation a = 1 essentially makes variable a reference the integer object with value 1.

Step 2: Distinguishing Between Mutable and Immutable Objects

• Immutable objects: Content cannot be modified after creation, e.g., int, float, str, tuple.

a = 1      # integer is immutable
b = "hello" # string is immutable
c = (1, 2)  # tuple is immutable

• Mutable objects: Content can be modified after creation, e.g., list, dict, set.

x = [1, 2]  # list is mutable
y = {'a': 1} # dictionary is mutable

Step 3: The Essence of Parameter Passing is "Passing Object References"

• Python function parameter passing is neither pass-by-value nor pass-by-reference, but rather passing object references.
• When a function is called, the reference of the actual argument is copied to the formal parameter.
• Both references point to the same object.

Step 4: Behavioral Analysis of Immutable Arguments

def modify_immutable(x):
    print(f"Inside function before modification: id(x) = {id(x)}")
    x = x + 10  # Creates a new object, rebinds reference
    print(f"Inside function after modification: id(x) = {id(x)}")
    return x

a = 5
print(f"Before call: id(a) = {id(a)}")
result = modify_immutable(a)
print(f"After call: a = {a}")  # Outputs 5, original variable unchanged
print(f"After call: id(a) = {id(a)}")  # id remains the same

Detailed Execution Process:

1. When the function is called, the reference of actual argument a is copied to formal parameter x; both x and a point to the same integer 5.
2. When executing x = x + 10, since integers are immutable, Python creates a new object 15.
3. Formal parameter x is rebound to the new object 15, but actual argument a still points to the original object 5.
4. The external variable a remains unaffected.

Step 5: Behavioral Analysis of Mutable Arguments

def modify_mutable(lst):
    print(f"Inside function before modification: id(lst) = {id(lst)}")
    lst.append(4)  # In-place modification, no new object created
    print(f"Inside function after modification: id(lst) = {id(lst)}")

my_list = [1, 2, 3]
print(f"Before call: id(my_list) = {id(my_list)}")
modify_mutable(my_list)
print(f"After call: my_list = {my_list}")  # Outputs [1, 2, 3, 4], original list modified
print(f"After call: id(my_list) = {id(my_list)}")  # id remains the same

Detailed Execution Process:

1. When the function is called, the reference of actual argument my_list is copied to formal parameter lst; both point to the same list object.
2. When executing lst.append(4), since lists are mutable, the original object is modified directly.
3. No new object is created; all variables referencing this object observe the change.
4. The content of the object pointed to by the external variable my_list is altered.

Step 6: Special Case Analysis - Rebinding Mutable Arguments

def rebind_mutable(lst):
    print(f"Before rebinding: id(lst) = {id(lst)}")
    lst = [4, 5, 6]  # Rebind to a new object
    print(f"After rebinding: id(lst) = {id(lst)}")

my_list = [1, 2, 3]
print(f"Before call: id(my_list) = {id(my_list)}")
rebind_mutable(my_list)
print(f"After call: my_list = {my_list}")  # Outputs [1, 2, 3], unchanged

Key Differences:

• Using in-place operations (e.g., append, extend) modifies the original object.
• Using assignment operations (=) creates a new object and rebinds the formal parameter, without affecting the actual argument.

Step 7: Practical Application Suggestions

1. To avoid modifying the original mutable object, create a copy inside the function first:

def safe_modify(lst):
    new_lst = lst.copy()  # or list(lst) or lst[:]
    new_lst.append(100)
    return new_lst

2. Clearly document in the function's docstring whether it modifies the passed arguments.

Summary:
Python parameter passing is "passing object references." The behavioral differences depend on the object's mutability:

• Immutable objects: Modifications inside the function create a new object, not affecting the actual argument.
• Mutable objects: In-place modifications inside the function affect the actual argument; rebinding does not affect the actual argument.
  Understanding this mechanism is crucial for writing correct Python programs.