View Discussion
Improve Article
Save Article
View Discussion
Improve Article
Save Article
Functions can be invoked in two ways: Call by Value or Call by Reference. These two ways are generally differentiated by the type of values passed to them as parameters.
The parameters passed to function are called actual parameters whereas the parameters received by function are called formal parameters.
Call By Value: In this parameter passing method, values of actual parameters are copied to function’s formal parameters and the two types of parameters are stored in different memory locations. So any changes made inside functions are not reflected in actual parameters of the caller.
Call by Reference: Both the actual and formal parameters refer to the same locations, so any changes made inside the function are actually reflected in actual parameters of the caller.
While calling a function, we pass values of variables to it. Such functions are known as “Call By Values”. | While calling a function, instead of passing the values of variables, we pass address of variables[location of variables] to the function known as “Call By References. |
In this method, the value of each variable in calling function is copied into corresponding dummy variables of the called function. | In this method, the address of actual variables in the calling function are copied into the dummy variables of the called function. |
With this method, the changes made to the dummy variables in the called function have no effect on the values of actual variables in the calling function. | With this method, using addresses we would have an access to the actual variables and hence we would be able to manipulate them. |
// C program to illustrate // call by value #include // Function Prototype void swapx[int x, int y]; // Main function int main[] { int a = 10, b = 20; // Pass by Values swapx[a, b]; printf["a=%d b=%d\n", a, b]; return 0; } // Swap functions that swaps // two values void swapx[int x, int y] { int t; t = x; x = y; y = t; printf["x=%d y=%d\n", x, y]; } Output: x=20 y=10 a=10 b=20 | // C program to illustrate // Call by Reference #include // Function Prototype void swapx[int*, int*]; // Main function int main[] { int a = 10, b = 20; // Pass reference swapx[&a, &b]; printf["a=%d b=%d\n", a, b]; return 0; } // Function to swap two variables // by references void swapx[int* x, int* y] { int t; t = *x; *x = *y; *y = t; printf["x=%d y=%d\n", *x, *y]; } Output: x=20 y=10 a=20 b=10 |
Thus actual values of a and b remain unchanged even after exchanging the values of x and y. | Thus actual values of a and b get changed after exchanging values of x and y. |
In call-by-values, we cannot alter the values of actual variables through function calls. | In call by reference we can alter the values of variables through function calls. |
Values of variables are passed by the Simple technique. | Pointer variables are necessary to define to store the address values of variables. |
Note: In C, we use pointers to achieve call by reference. In C++, we can either use pointers or references for pass by reference. In Java, primitive types are passed as values and non-primitive types are always references.
Python utilizes a system, which is known as “Call by Object Reference” or “Call by assignment”. In the event that you pass arguments like whole numbers, strings or tuples to a function, the passing is like call-by-value because you can not change the value of the immutable objects being passed to the function. Whereas passing mutable objects can be considered as call by reference because when their values are changed inside the function, then it will also be reflected outside the
function.
Example 1:
Python3
string
=
"Geeks"
def
test[string]:
string
=
"GeeksforGeeks"
print
[
"Inside Function:"
, string]
test[string]
print
[
"Outside Function:"
, string]
Output
Inside Function: GeeksforGeeks Outside Function: Geeks
Example 2
Python3
def
add_more[
list
]:
list
.append[
50
]
print
[
"Inside Function"
,
list
]
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
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"
print
[
id
[a]]
print
[
id
[b]]
print
[a
is
b]
Output
110001234557894 110001234557894 True
Now, let’s try and understand this better with another
example.
Example 2:
Python3
a
=
[
10
,
20
,
30
]
b
=
[
10
,
20
,
30
]
print
[
id
[a]]
print
[
id
[b]]
print
[a
is
b]
Output
541190289536222 541190288737777 False
The output of the above two examples are different
because the list is mutable and the string is immutable. An immutable variable cannot be changed once created. If we wish to change an immutable variable, such as a string, we must create a new instance and bind the variable to the new instance. Whereas, mutable variable can be changed in place.
Example 3:
Python3
def
foo[a]:
a
=
"new value"
print
[
"Inside Function:"
, a]
string
=
"old value"
foo[string]
print
[
"Outside Function:"
, string]
Output:
Inside Function: new value Outside Function: old value
In the above example, a string which is an immutable type of object is passed as argument to the function foo. Within the scope of the given function foo, a= “new value” has been bounded to the same object that string has
been bound outside. Within the scope of the function foo, we modify “old value”` to “new value”. Once we leave the scope of function foo , a=”new value” is no longer in the name space, and the value that string refers to was never changed.
Example 4: Now, let us look at how mutable variable is passed into the function.
Python3
def
foo[a]:
a[
0
]
=
"Nothing"
bar
=
[
'Hi'
,
'how'
,
'are'
,
'you'
,
'doing'
]
foo[bar]
print
[bar]
Output:
['Nothing, 'how', 'are', 'you', 'doing']
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.