I have a few things to ask. 1. you created a function added a code block that execute a certain operation but where is the output going? 2. Since you haven't returned the output how can you say that your var i.e. num will be incremented just by passing it into a function without getting a return?
Thanks, that was a very good explanation. Is it true to say then that if a mutable object is passed as a parameter then it is call by reference whereas if an immutable object is passed as a parameter then it is call by value?
I suspect, that it is about primitive data types like int (which are immutable) and objects (which can be immutable as well, though, if you tell them to be). Please correct me, if I'm wrong, I'm quite new to coding.
BASIC - In Python, variables inside functions are considered local if and only if they appear in the left side of an assignment statement. so immutable objects are acts like it its were passed by values # TODO: acts as a pass by value (IMMUTABLE OBJECTS) but it's passed by reference only def increment(a): print('inside function init id(a)', id(a)) # id(a) is same as id(num) so everything is passed by reference only a += 1 # assignment causes assigning the new value to a ( so a become local to function scope ) print('inside function val of a', a) print('inside function id(a)', id(a)) # id(a) is not same as id(num) cause of assignment involved return a num = 1 print('outside function id(num)', id(num)) increment(num) print('outside function val of num', num) But incase of Mutable objects # TODO: acts as a pass by reference (MUTABLE OBJECTS) def extend(a): print('inside function init id(a)', id(a)) # id(a) is same as id(li) a.append(5) # since no assignment involved any changes to the a( reference of li) also affects the value of the variable outside the function. print('inside function val of a', a) print('inside function id(a)', id(a)) # id(a) is same as id(li) return a li = [1, 2, 3, 4] print('outside function id(li)', id(li)) extend(li) print('outside function val of li', li)
another important thing += and = are different, list_ += [1] will modify the same object but list_ = list_ + 1 will create new object . This is only true for mutables, for strings/tuples/int which are immutable both will create new objects
Still i am confused, i am writing a simulator where i am passing objects of various class to various other classes, and then use those objects to assign certain values to variables in that class, it's working but according to you it should not!
So by the logic you explained, shouldn't a in the first example also return 2 instead of 1? Since a is the same object and you're just incrementing it by 1, or is that interpreted as a different assignment?
In Python, a variable name is just a reference to any object. Here, 1 and 2 are two different Int objects. Hence change in local scoped a in function makes it point to a different object. The global scoped a still refers to original object, I.e. 1
It will always create a new object when you increment it using a+=1; You can just check this : a=1 id(a) a+=1 id(a) Both id's will be different, which means it will create a new object all together
As list are mutable objects and integers & strings are immutable. So when you change the inc value of variable inside a function it actually makes a new container for it. But in case of list when you append something it does on same container. So calling that variable/list outside the function will give different result. In short python uses call-by-reference but if you pass immutable arguments like integers, strings or tuples to a function , the passing acts like call-by-value.
i think there is no difference. you pass num to the function, so a is referencing to same "1"now. But the moment you increment it, a starts to reference "2" object, because everything is object. dont you think so?
As list are mutable objects and integers & strings are immutable. So when you change the inc value of variable inside a function it actually makes a new container for it. But in case of list when you append something it does on same container. So calling that variable/list outside the function will give different result. In short python uses call-by-reference but if you pass immutable arguments like integers, strings or tuples to a function , the passing acts like call-by-value.
i believe this is more related to mutable and immutable types in python. Immutable are call by value and mutable are call by ref. plz correct me if my understanding is not correct
look up mutable and immutbale objects. Immutable objects such as single numbers are always call by value in python. Mutable objects like lists are where pass by object reference comes to play
Concept of call by value and call by reference is generic and the concept works same for all types of data. Please ask if you have any special case or example where you are getting unexpected output.
As list are mutable objects and integers & strings are immutable. So when you change the inc value of variable inside a function it actually makes a new container for it. But in case of list when you append something it does on same container. So calling that variable/list outside the function will give different result. In short python uses call-by-reference but if you pass immutable arguments like integers, strings or tuples to a function , the passing acts like call-by-value.
![How variables work in Python | Explained with Animations [See description/first comment]](http://i.ytimg.com/vi/0Om2gYU6clE/mqdefault.jpg)
I was exploring for this the whole Internet, for the simple and precise explanation. luckily found you and you made it all clear. Thank you dude.
very nice explanation...couldn't find out better explanation than this on RUclips..
This deserves more views.
Yes Bro
I have a few things to ask.
1. you created a function added a code block that execute a certain operation but where is the output going?
2. Since you haven't returned the output how can you say that your var i.e. num will be incremented just by passing it into a function without getting a return?
crystal clear , pretty cool..!
Thanks, that was a very good explanation.
Is it true to say then that if a mutable object is passed as a parameter then it is call by reference whereas if an immutable object is passed as a parameter then it is call by value?
this is exactly what I also deduced from the video but needs an affirmation on it. Let me know if you get any answers :)
I suspect, that it is about primitive data types like int (which are immutable) and objects (which can be immutable as well, though, if you tell them to be).
Please correct me, if I'm wrong, I'm quite new to coding.
Thanks buddy!
Never have thought above it even though using the function calls passing the lists on a daily basis.
Thank you so much I was struggling in this concept and you helped to clear it...🙌
BASIC - In Python, variables inside functions are considered local if and only if they appear in the left side of an assignment statement. so immutable objects are acts like it its were passed by values
# TODO: acts as a pass by value (IMMUTABLE OBJECTS) but it's passed by reference only
def increment(a):
print('inside function init id(a)', id(a)) # id(a) is same as id(num) so everything is passed by reference only
a += 1 # assignment causes assigning the new value to a ( so a become local to function scope )
print('inside function val of a', a)
print('inside function id(a)', id(a)) # id(a) is not same as id(num) cause of assignment involved
return a
num = 1
print('outside function id(num)', id(num))
increment(num)
print('outside function val of num', num)
But incase of Mutable objects
# TODO: acts as a pass by reference (MUTABLE OBJECTS)
def extend(a):
print('inside function init id(a)', id(a)) # id(a) is same as id(li)
a.append(5) # since no assignment involved any changes to the a( reference of li) also affects the value of the variable outside the function.
print('inside function val of a', a)
print('inside function id(a)', id(a)) # id(a) is same as id(li)
return a
li = [1, 2, 3, 4]
print('outside function id(li)', id(li))
extend(li)
print('outside function val of li', li)
another important thing += and = are different, list_ += [1] will modify the same object but list_ = list_ + 1 will create new object . This is only true for mutables, for strings/tuples/int which are immutable both will create new objects
Still i am confused, i am writing a simulator where i am passing objects of various class to various other classes, and then use those objects to assign certain values to variables in that class, it's working but according to you it should not!
God level explanation very well explained thank you it was helpful.
and if in case you seriously intended to empty the list you should:
def clean_it(mylist):
mylist.clear()
Thank you. A very nice explanation, better than many videos.
So basically it's the way the assignment operator works as opposed to member functions (like append) that can mutate the object.
Unique information is provided by you, thanks
Great video! Simple and clear!
I got ur point but can you describe me the 1st example where you use the num variable ....it was not incremented??
Clean and professional explanation. I loved it. May I know which software you are using to execute the python statements??
Jupyter Notebook
Very well explained.
Crystal Clear bro....you got one more subscriber
what editor do you use?
Good Explanation
How we got my list as 1,2,3,4,5,5?
So by the logic you explained, shouldn't a in the first example also return 2 instead of 1? Since a is the same object and you're just incrementing it by 1, or is that interpreted as a different assignment?
In Python, a variable name is just a reference to any object. Here, 1 and 2 are two different Int objects. Hence change in local scoped a in function makes it point to a different object. The global scoped a still refers to original object, I.e. 1
It will always create a new object when you increment it using a+=1; You can just check this :
a=1
id(a)
a+=1
id(a)
Both id's will be different, which means it will create a new object all together
As list are mutable objects and integers & strings are immutable. So when you change the inc value of variable inside a function it actually makes a new container for it. But in case of list when you append something it does on same container. So calling that variable/list outside the function will give different result. In short python uses call-by-reference but if you pass immutable arguments like integers, strings or tuples to a function , the passing acts like call-by-value.
@@kushagra2255 Nice!
Key word here is assignment, use of assignment creates a new object.
😎 coolest vid.
integer passed in the first example is also an object right? so whats the difference between the integer object and list object? its not clear.
i think there is no difference. you pass num to the function, so a is referencing to same "1"now. But the moment you increment it, a starts to reference "2" object, because everything is object. dont you think so?
As list are mutable objects and integers & strings are immutable. So when you change the inc value of variable inside a function it actually makes a new container for it. But in case of list when you append something it does on same container. So calling that variable/list outside the function will give different result. In short python uses call-by-reference but if you pass immutable arguments like integers, strings or tuples to a function , the passing acts like call-by-value.
So objects are passed by reference, no multiple instances of obj created?
can you demonstrate call by reference without using list, just use simple variable other than list. Is it possible?
nice explanation bro
i believe this is more related to mutable and immutable types in python. Immutable are call by value and mutable are call by ref. plz correct me if my understanding is not correct
No relation of function calls with an object being mutable or immutable. :)
due seriously perfect explanation....liked it ....thanks
One question , in Call by value u used single number whereas in call by reference you used list. That part is not clear to me
look up mutable and immutbale objects. Immutable objects such as single numbers are always call by value in python. Mutable objects like lists are where pass by object reference comes to play
thank you..But what about with those primitive types???
Concept of call by value and call by reference is generic and the concept works same for all types of data. Please ask if you have any special case or example where you are getting unexpected output.
say you pass x = 1, to f(y), now if you increment y, y+=1, y points to new object 2, and x is still pointing to 1
@@onePunch95 Please Clear this
Good explanation. Very much appreciated.
in python some argument are passed by value and other by references depending their type ? true or false
No. Please watch the video carefully.
Fantastic
So you are saying that python supports both call by value and reference?
Don't think that way. Python actually supports something called call by object. Understand what that means as explained in the video.
As list are mutable objects and integers & strings are immutable. So when you change the inc value of variable inside a function it actually makes a new container for it. But in case of list when you append something it does on same container. So calling that variable/list outside the function will give different result. In short python uses call-by-reference but if you pass immutable arguments like integers, strings or tuples to a function , the passing acts like call-by-value.
really liked the way you explained it .Thanks !
Keep rocking bro..fantastic explanation...
But i tried the same thing under python version 3 and it doesnt go the same
Python supports call by object
Dope explanation brother! 🔥
Very helpful, thank you.
Nice work...
thank you
Very clear explanation! Thank you :)
precise
def add_more(l):
l.clear( ) # this won't change the id
l = [ ] # this change the id of l
return
mylist = [1,2,3]
add_more(mylist)
Thanks sir ❤️
thanks
after 6:06 i am even more Confused, Incomplete Video