What is the difference between call by value and call by reference in python?

View Discussion

Nội dung chính Show

What is difference in call by value and call by reference in Python?
What is the difference between call by reference and call by address?

Improve Article

Save Article

Read

Discuss

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.

Call By Value	Call By Reference
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.

What is difference in call by value and call by reference in Python?

In the case of Call by Value, when we pass the value of the parameter during the calling of the function, it copies them to the function's actual local argument. In the case of Call by Reference, when we pass the parameter's location reference/address, it copies and assigns them to the function's local argument.

What is the difference between call by reference and call by address?

Call By Address is a way of calling a function in which the address of the actual arguments is copied to the formal parameters. But, call by reference is a method of passing arguments to a function by copying the reference of an argument into the formal parameter.

What is the difference between call by value and call by reference in python?

Python3

Python3

Binding Names to Objects

Python3

Python3

Python3

Python3

What is difference in call by value and call by reference in Python?

What is the difference between call by reference and call by address?

Bài Viết Liên Quan

Quảng Cáo

Có thể bạn quan tâm

Toplist được quan tâm

Quảng cáo

Xem Nhiều

Quảng cáo

Chúng tôi

Điều khoản

Trợ giúp

Mạng xã hội