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 “Beginner” 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 = "Beginner" def test(string): string = "w3wiki" print ( "Inside Function:" , string) # Driver's code test(string) print ( "Outside Function:" , string) |
Inside Function: w3wiki Outside Function: Beginner
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) |
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) |
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) |
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) |
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) |
['Nothing', 'how', 'are', 'you', 'doing']