What are is and id appearing in Python?

(ob1 is ob2) is equivalent to (id(ob1) == id(ob2))

First, the id function can get the memory address of the object. If the memory addresses of the two objects are the same, then the two objects must be one object. is equivalent to is. Python source code as evidence.

static PyObject *
 cmp_outcome(int op, register PyObject *v, register PyObject *w)
{
 int res = 0;
 switch (op) {
 case PyCmp_IS:
  res = (v == w);
 break;
 case PyCmp_IS_NOT:
res = (v != w);
 break;

​But please see how this situation occurs in the code below?

In [1]: def bar(self, x):
...:     return self.x + y
...: 

In [2]: class Foo(object):
...:     x = 9
...:     def __init__(self ,x):
...:         self.x = x
...:     bar = bar
...:     

In [3]: foo = Foo(5)

In [4]: foo.bar is Foo.bar
Out[4]: False

In [5]: id(foo.bar) == id(Foo.bar)
Out[5]: True

Two objects are judged to be False using is, but are True when judged using id. This is inconsistent with the facts we know. How to explain this phenomenon? The best solution to this situation is to call the dis module to see what the two comparison statements do.

In [7]: dis.dis("id(foo.bar) == id(Foo.bar)")
          0 BUILD_MAP       10340
          3 BUILD_TUPLE     28527
          6 <46>           
          7 DELETE_GLOBAL   29281 (29281)
         10 STORE_SLICE+1  
         11 SLICE+2        
         12 DELETE_SUBSCR  
         13 DELETE_SUBSCR  
         14 SLICE+2        
         15 BUILD_MAP       10340
         18 PRINT_EXPR     
         19 JUMP_IF_FALSE_OR_POP 11887
         22 DELETE_GLOBAL   29281 (29281)
         25 STORE_SLICE+1  

In [8]: dis.dis("foo.bar is Foo.bar")
          0 BUILD_TUPLE     28527
          3 <46>           
          4 DELETE_GLOBAL   29281 (29281)
          7 SLICE+2        
          8 BUILD_MAP        8307
         11 PRINT_EXPR     
         12 JUMP_IF_FALSE_OR_POP 11887
         15 DELETE_GLOBAL   29281 (29281)

The real situation is that when the . operator is executed, a proxy object is actually generated. When foo.bar is Foo.bar, two objects are generated sequentially and placed on the stack for comparison. Because the addresses are different, it must be False, but It is different when id(foo.bar) == id(Foo.bar). First, foo.bar is generated, and then the address of foo.bar is calculated. After calculating the address of foo.bar, there is no object pointing to foo. .bar, so the foo.bar object will be released. Then generate the Foo.bar object. Since foo.bar and Foo.bar occupy the same memory size, the memory address of the original foo.bar happens to be reused, so id(foo.bar) == id(Foo. bar) is True.

The following content is provided by Leo Jay via email. He explains it more clearly.

The idea of ​​using id(expression a) == id(expression b) to determine whether the results of two expressions are the same object is problematic.

This form of foo.bar is called attribute reference [1], which is a type of expression. foo is an instance object, and bar is a method. At this time, the result returned by the expression foo.bar is called method object [2]. According to the documentation:

When an instance attribute is referenced that isn’t a data attribute, 
its class is searched. If the name denotes a valid class attribute 
that is a function object, a method object is created by packing 
(pointers to) the instance object and the function object just found 
together in an abstract object: this is the method object.

foo.bar itself is not a simple name, but the calculation result of an expression, which is a method object. In an expression such as id (foo.bar), the method object is just a temporary intermediate variable. It makes no sense to use a variable as an id.

A more obvious example is,

print id(foo.bar) == id(foo.__init__)

The output result is also True

​Look at the documentation of id[3]:

Return the “identity” of an object. This is an integer (or long 
integer) which is guaranteed to be unique and constant for this object 
during its lifetime. Two objects with non-overlapping lifetimes may 
have the same id() value. 
CPython implementation detail: This is the address of the object in memory.

Only if you can guarantee that the object will not be destroyed can you use id to compare two objects. So, if you have to compare, you have to write like this:

fb = foo.bar 
Fb = Foo.bar 
print id(fb) == id(Fb)

That is, you can get the correct result by binding the results of the two expressions to the names and then comparing whether they are the same object.

The same is true for the is expression [4]. The correct result you get now is entirely due to the current implementation details of CPython. The current implementation of is is to calculate the objects on the left and right sides, and then compare whether the addresses of the two objects are the same. If it is changed someday, calculate the left side first, save the address, release the left side, then calculate the right side, and compare again, the result of your is may be wrong. This issue is also mentioned in the official documentation [5]. I think the correct method is like id, first calculate both the left and right sides, and explicitly bind them to their respective names, and then use is to judge.

[1] http://docs.python.org/2/reference/expressions.html#attribute-references
[2] http://docs.python.org/2/tutorial/classes.html#method-objects
[3] http://docs.python.org/2/library/functions.html#id
[4] http://docs.python.org/2/reference/expressions.html#index-68
[5] http://docs.python.org/2/reference/expressions.html#id26

The above is the detailed content of What are is and id appearing in Python?. For more information, please follow other related articles on the PHP Chinese website!