Fdzfgy

Two python objects have the same id but "is" operation returns false as shown below:

a = np.arange(12).reshape(2, -1)

c = a.reshape(12, 1)

print("id(c.data)", id(c.data))

print("id(a.data)", id(a.data))



print(c.data is a.data)

print(id(c.data) == id(a.data))

Here is the actual output:

id(c.data) 241233112

id(a.data) 241233112

False

True

My question is... why "c.data is a.data" returns false even though they point to the same ID, thus pointing to the same object? I thought that they point to the same object if they have same ID or am I wrong? Thank you!

a.data and c.data both produce a transient object, with no reference to it. As such, both are immediately garbage-collected. The same id can be used for both.

In your first if statement, the objects have to co-exist while is checks if they are identical, which they are not.

In the second if statement, each object is released as soon as id returns its id.

If you save references to both objects, keeping them alive, you can see they are not the same object.

r0 = a.data

r1 = c.data

assert r0 is not r1

In [62]: a = np.arange(12).reshape(2,-1) 

    ...: c = a.reshape(12,1)                                                    

.data returns a memoryview object. id just gives the id of that object; it's not the value of the object, or any indication of where a databuffer is located.

In [63]: a.data                                                                 

Out[63]: <memory at 0x7f672d1101f8>

In [64]: c.data                                                                 

Out[64]: <memory at 0x7f672d1103a8>

In [65]: type(a.data)                                                           

Out[65]: memoryview

https://docs.python.org/3/library/stdtypes.html#memoryview

If you want to verify that a and c share a data buffer, I find the __array_interface__ to be a better tool.

In [66]: a.__array_interface__['data']                                          

Out[66]: (50988640, False)

In [67]: c.__array_interface__['data']                                          

Out[67]: (50988640, False)

It even shows the offset produced by slicing - here 24 bytes, 3*8

In [68]: c[3:].__array_interface__['data']                                      

Out[68]: (50988664, False)

I haven't seen much use of a.data. It can be used as the buffer object when creating a new array with ndarray:

In [70]: d = np.ndarray((2,6), dtype=a.dtype, buffer=a.data)                    

In [71]: d                                                                      

Out[71]: 

array([[ 0,  1,  2,  3,  4,  5],

       [ 6,  7,  8,  9, 10, 11]])

In [72]: d.__array_interface__['data']                                          

Out[72]: (50988640, False)

But normally we create new arrays with shared memory with slicing or np.array (copy=False).