Pass by reference vs value in Python

In languages like C++ or Java, concepts like pass-by-value and pass-by-reference are commonly used. Python works differently and follows a pass-by-object-reference approach:

• Functions receive references to objects, not separate copies.
• Mutable objects can be modified inside functions.
• Immutable objects create new objects when modified, making them behave similarly to pass-by-value.

Pass by Reference

Python passes object references to functions, so mutable objects can be modified inside the function without creating a copy. This means both the caller and the function share the same object. With mutable types like lists, dicts and sets, any changes made inside the function will reflect outside as well.

Example 1: No Change (Same Reference, No Modification)

['X']

Explanation: lst and my_list both point to the same list. Since .append() modifies the list in place, the change is visible outside the function.👁 Image

Example 2: Reassignment (New Object Inside Function)

['X']

Explanation: Function rebinds list to a new list object. This does not affect my_list. list now refers to a new object inside the function and my_list still refers to the original object, which remains unchanged.

Example 3: In-Place Modification

['X', 'B']

👁 Image

Explanation: Function modifies the list in-place. The change is visible outside. Since list.append("B") changes the contents of the list in place, my_list is also modified.

Example 4: Mutating a List in a Function

Inside function: [1, 2, 3, 4]
Outside function: [1, 2, 3, 4]

Explanation: List is mutated inside the function and the changes persist outside because both lst and a refer to the same object.

Pass by Value

In pass-by-value, a copy of the variable is passed, so changes inside the function don't affect the original. While Python doesn't strictly follow this model, immutable objects like int, str, and tuple behave similarly, as changes create new objects rather than modifying the original.

Example 1: Same Reference, No Change

['X']

👁 Image

Explanation: Although both my_list and list point to the same object, no changes were made. So the object remains exactly the same.

Example 2: Reassignment with Immutable behavior

['X']

👁 Image

Explanation: Inside the function, list is reassigned to a new object. But this does not change my_list outside the function.

Example 3: Immutable Integer

Inside function: 15
Outside function: 5

Explanation: Integers are immutable, so modifying x inside the function creates a new object. The original num remains unchanged.

Pass by Reference vs Pass by Value

Related Articles:

• Is Python call by reference or call by value