Is Python call-by-value or call-by-reference?

Python uses a mechanism that is often referred to as "call-by-object-reference" or "call-by-sharing." This can be a bit different from the traditional understanding of call-by-value and call-by-reference. Let's break down how it works and provide examples to illustrate the concept:

In Python, when you pass an argument to a function, a reference to the object is passed, not the actual object itself. This means that the function can access and modify the contents of the object that the reference points to. However, Python's behavior is not exactly the same as traditional call-by-reference:

Immutable Objects (Call-by-Value)

When you pass immutable objects like numbers, strings, and tuples to a function, the function receives a copy of the reference to the object. If you modify the object within the function, a new object is created, and the original object remains unchanged outside the function.

def modify_value(x): x += 10 # A new object is created print("Inside function:", x) num = 5 modify_value(num) print("Outside function:", num)

Mutable Objects (Call-by-Reference)

When you pass mutable objects like lists and dictionaries to a function, the function receives a reference to the same object. Any modifications made to the object within the function are reflected outside the function as well.

def modify_list(lst): lst.append(4) # Modifying the same list object print("Inside function:", lst) numbers = [1, 2, 3] modify_list(numbers) print("Outside function:", numbers)

This behavior is consistent with Python's principle of simplicity and "we are all consenting adults here," allowing programmers to work effectively while understanding the underlying mechanisms.


Python's argument-passing mechanism is neither strictly call-by-value nor call-by-reference. It's more accurate to describe it as "call-by-object-reference." Immutable objects are treated more like call-by-value, as they cannot be modified in-place, while mutable objects behave more like call-by-reference, as changes made within a function affect the original object.