id(object)
This is an integer (or long integer) which is guaranteed to be unique and constant for this object during its lifetime.
Can you explain this output? Why does j's id change?
>>> i = 10
>>> id(i)
6337824
>>> j = 10
>>> id(j)
6337824
>>> j = j+1
>>> id(j)
6337800
>>> id(i)
6337824
Is it like i and j are object references to the same object initially, but when j changes, they start referring to different objects?
Because integers are immutable, each integer value is a distinct object with a unique id. The integer 10 has a different id from 11. Doing j = j+1 doesn't change the value of an existing integer object, rather it changes j to point to the object for 11.
Check out what happens when we independently create a new variable k and assign it the value 11:
>>> j = 10
>>> id(j)
8402204
>>> j = j+1
>>> id(j)
8402192
>>> k = 11
>>> id(k)
8402192
Note that it is not always the case that every integer has one and only one corresponding object. This only happens for small integers that Python decides to cache. It does not happen for large integers:
>>> x = 123456789
>>> id(x)
8404568
>>> y = 123456789
>>> id(y)
8404604
See PyLong_FromLong in the Python/C API Reference Manual:
The current implementation keeps an array of integer objects for all integers between -5 and 256, when you create an int in that range you actually just get back a reference to the existing object.
This is why 2**8 is 2**8 == True, and 2**9 is 2**9 == False.
Values between -5 and 256 are preallocated.
The same id for different variables is a product of how Python creates variables.
id is a hash of the the location of an object in memory. Python variables are references to an object, not new objects. If several variables reference the same object, they have the same id.
In CPython, id is generally derived from the Py_Object's pointer value, that is its location in memory.
j's id changes because the object named by j changes. First you initialize j to 10, so when you call id(j) you get the id of 10. Then you set j to 11, so after that when you call id(j) you get the id of 11.
The thing is that, each object(value) has a unique id in Python, e.g objects 'hello' and 'hi' have their own ids or 10 and 11 have 2 other different ids. The other thing is that each variable is just a label for a specific objecect(value. Now, when we say j=10, the id of the object 10 is assigned to the variable j. Then when you change the value of j (e.g j=j+1), j will refer to another object. In other words j will become label of another object. So the id for j varies when it's value changes.
There is also Python's caching approach which help it to be more efficient.
For example when you write j=10 and x=10 rather creating 2 separate objects it creates just one object 10 with 2 labels j and x.
These are primitive types, so I'm guessing each value gets its own ID. Try creating a true object and I think you'll see the functionality you expect.
If you need an id for a primitive, you could create an object with just one member of that type.
