Is Python call by reference or call by value

Python utilizes a system, which is known as “Call by Object Reference” or “Call by assignment”. If you pass arguments like whole numbers, strings, or tuples to a function, the passing is like a call-by-value because you can not change the value of the immutable objects being passed to the function. Passing mutable objects can be considered as call by reference or Python pass by assignment because when their values are changed inside the function, then it will also be reflected outside the function.

What is Call By Reference in Python?

In Python, “call by reference” is a way of handing arguments to functions where the reference to the real object gets passed instead of the object’s actual value. This means that if you make changes to the object within the function, those changes directly affect the original object outside the function. It’s important to highlight that this approach in Python is not the same as the traditional “call-by-reference” used in some other programming languages. Python follows its own model, often called “pass-by-object-reference,” emphasizing the passing of references to objects while maintaining its unique characteristics.

What is Call By Value in Python?

In Python, the common way of passing function arguments is through “call by value.” This means that when you pass a variable to a function, you’re essentially handing over the actual value of the variable itself, not the reference to the object it’s pointing to. Consequently, any changes made to the variable within the function don’t directly affect the original variable outside the function. This approach is consistent with the principles of “call by value” and sets it apart from the “call by reference” mechanisms seen in some other programming languages. In simpler terms, the function deals with a copy of the variable’s value, ensuring that the original variable remains unchanged in the broader context of the program.

Python Call By Reference or Call By Value

Below are some examples by which we can understand better about this:

Example 1: Call by Value in Python

In this example, the Python code demonstrates call by value behavior. Despite passing the string variable “Geeks” to the function, the local modification inside the function does not alter the original variable outside its scope, emphasizing the immutability of strings in Python.

Python3

# Python code to demonstrate
# call by value
string = "Geeks"

def test(string):
    string = "GeeksforGeeks"
    print("Inside Function:", string)

# Driver's code
test(string)
print("Outside Function:", string)

Output

Inside Function: GeeksforGeeks
Outside Function: Geeks

Example 2: Call by Reference in Python

In this example, the Python code illustrates call by reference behavior. The function add_more() modifies the original list mylist by appending an element, showcasing how changes made inside the function persist outside its scope, emphasizing the mutable nature of lists in Python.

Python3

# Python code to demonstrate
# call by reference

def add_more(list):
    list.append(50)
    print("Inside Function", list)

# Driver's code
mylist = [10, 20, 30, 40]

add_more(mylist)
print("Outside Function:", mylist)

Output

Inside Function [10, 20, 30, 40, 50]
Outside Function: [10, 20, 30, 40, 50]

Binding Names to Objects

Example 1: Variable Identity and Object Equality in Python

In Python, each variable to which we assign a value/container is treated as an object. When we are assigning a value to a variable, we are actually binding a name to an object.

Python3

a = "first"
b = "first"

# Returns the actual location
# where the variable is stored
print(id(a))

# Returns the actual location
# where the variable is stored
print(id(b))

# Returns true if both the variables
# are stored in same location
print(a is b)

Output

140081020184240
140081020184240
True

Example 2: List Identity and Object Equality in Python

In this example, the Python code compares the memory addresses (locations) of two list variables, a and b, using the id() function. Despite having identical values, the is keyword evaluates to False, indicating that these lists are distinct objects in memory, highlighting the importance of memory address comparison for object identity in Python.

Python3

a = [10, 20, 30]
b = [10, 20, 30]

# return the location
# where the variable
# is stored
print(id(a))

# return the location
# where the variable
# is stored
print(id(b))

# returns false if the
# location is not same
print(a is b)

Output

140401704219904
140401704222464
False

Example 3: Immutable Objects and Function Parameter Behavior in Python

In this example, the Python code demonstrates the immutability of strings by passing the variable string to the function foo(). Despite attempting to assign a new value inside the function, the original string remains unchanged outside its scope, illustrating that string variables are immutable in Python.

Python3

def foo(a):

    # A new variable is assigned
    # for the new string
    a = "new value"
    print("Inside Function:", a)

# Driver's code
string = "old value"
foo(string)

print("Outside Function:", string)

Output

Inside Function: new value
Outside Function: old value

Example 4: Mutable Objects and In-Place Modification in Python Functions

When we pass a mutable variable into the function foo and modify it to some other name the function foo still points to that object and continue to point to that object during its execution. 

Python3

def foo(a):
    a[0] = "Nothing"

# Driver' code
bar = ['Hi', 'how', 'are', 'you', 'doing']
foo(bar)
print(bar)

Output

['Nothing', 'how', 'are', 'you', 'doing']