Question

假设我有一个numpy数组a，并按照以下方式创建b：

a = np.arange(3)
b = a

如果我现在更改b，例如像这样

b[0] = 100

并打印a，b，他们的id和.flags

print a
print a.flags    
print b
print b.flags
print id(a)
print id(b)

我获得了

[100   1   2]

  C_CONTIGUOUS : True
  F_CONTIGUOUS : True
  OWNDATA : True
  WRITEABLE : True
  ALIGNED : True
  UPDATEIFCOPY : False

[100   1   2]

  C_CONTIGUOUS : True
  F_CONTIGUOUS : True
  OWNDATA : True
  WRITEABLE : True
  ALIGNED : True
  UPDATEIFCOPY : False

139767698376944
139767698376944

因此，a和b看起来相同，id与预期相同。

当我现在使用copy()

执行相同操作时

c = np.arange(3)
d = c.copy()

d[0] = 20

print c
print c.flags
print id(c)

print d
print d.flags
print id(d)

我得到了

[0 1 2]

  C_CONTIGUOUS : True
  F_CONTIGUOUS : True
  OWNDATA : True
  WRITEABLE : True
  ALIGNED : True
  UPDATEIFCOPY : False

139767698377344

[20  1  2]

  C_CONTIGUOUS : True
  F_CONTIGUOUS : True
  OWNDATA : True
  WRITEABLE : True
  ALIGNED : True
  UPDATEIFCOPY : False

139767698376864

在这种情况下c和d不同，id也是如此;也如预期的那样。

然而，令我困惑的是我从.flags获得的输出：在所有情况下，OWNDATA都设置为True。当我阅读documentation时，我发现：

OWNDATA（O）该数组拥有它使用或借用的内存另一个对象。

我现在的主要问题是：

查找指向相同id的所有变量的最简单方法（在上面的示例中为a和b），即检查具有相同id的另一个变量存在？我认为OWNDATA对此有帮助，但显然不是。

相关问题：

OWNDATA实际使用的是什么，在这种情况下OWNDATA设置为False？

Answer 1

作业b=a不会在原始数组a上创建视图，而只是创建对它的引用。换句话说，b只是a的另一个名称。变量a和b都指向拥有其数据的相同数组，以便设置OWNDATA标志。修改b将修改a。

作业b=a.copy()创建原始数组的副本。也就是说，a和b指的是单独的数组，它们都拥有自己的数据，以便设置OWNDATA标志。修改b不会修改a。

但是，如果您进行作业b=a[:]，则会创建原始数组的视图，而b将不会拥有其数据。修改b将修改a。

您正在寻找shares_memory功能。它完成它在框中所说的内容：检查数组a和b是否具有共享内存，从而相互影响。

Answer 2

有两个问题 - 如何识别要比较的变量，以及如何比较它们。

先拿第二个。

我的版本（1.8.2）没有np.shares_memory功能。它确实有一个np.may_share_memory。

https://github.com/numpy/numpy/pull/6166是添加shares_memory的拉取请求;这是'去年八月的日期。因此，您必须拥有全新的numpy才能使用它。请注意，确定性测试可能很难，并且可能会出现“TOO HARD”错误消息。我想，例如，有一些切片共享内存，但很难通过简单地比较缓冲起始点来识别。

https://github.com/numpy/numpy/blob/97c35365beda55c6dead8c50df785eb857f843f0/numpy/core/tests/test_mem_overlap.py是这些memory_overlap函数的单元测试。如果你想看看两个已知数组之间所有可能的重叠条件是多么艰巨的任务，请阅读它。

我喜欢看数组的.__array_interface__。该字典中的一个项目是“data”，它是指向数据缓冲区的指针。相同的指针意味着共享数据。但是视图可能会从某个地方开始。如果shares_memeory查看此指针，我不会感到惊讶。

相同id表示2个变量引用同一个对象，但不同的数组对象可以共享数据缓冲区。

所有这些测试都需要查看具体的参考资料;所以你仍然需要获得某种引用列表。看看locals()？，globals()。那些未命名的引用，例如数组列表，或者某些用户定义的字典？

Ipython运行示例：

一些变量和参考：

In [1]: a=np.arange(10)
In [2]: b=a           # reference
In [3]: c=a[:]        # view
In [4]: d=a.copy()    # copy
In [5]: e=a[2:]       # another view
In [6]: ll=[a, a[:], a[3:], a[[1,2,3]]]  # list

比较id：

In [7]: id(a)
Out[7]: 142453472
In [9]: id(b)
Out[9]: 142453472

除了id之外，其他人都不会共享ll[0]。

In [10]: np.may_share_memory(a,b)
Out[10]: True
In [11]: np.may_share_memory(a,c)
Out[11]: True
In [12]: np.may_share_memory(a,d)
Out[12]: False
In [13]: np.may_share_memory(a,e)
Out[13]: True
In [14]: np.may_share_memory(a,ll[3])
Out[14]: False

这就是我所期待的;视图共享内存，副本不共享。

In [15]: a.__array_interface__
Out[15]: 
{'version': 3,
 'data': (143173312, False),
 'typestr': '<i4',
 'descr': [('', '<i4')],
 'shape': (10,),
 'strides': None}
In [16]: a.__array_interface__['data']
Out[16]: (143173312, False)
In [17]: b.__array_interface__['data']
Out[17]: (143173312, False)
In [18]: c.__array_interface__['data']
Out[18]: (143173312, False)
In [19]: d.__array_interface__['data']
Out[19]: (151258096, False)            # copy - diff buffer
In [20]: e.__array_interface__['data'] 
Out[20]: (143173320, False)            # differs by 8 bytes
In [21]: ll[1].__array_interface__['data']
Out[21]: (143173312, False)            # same point

就在这个短暂的会话中，我在locals()中有76个项目。但我可以搜索匹配id与：

In [26]: [(k,v) for k,v in locals().items() if id(v)==id(a)]
Out[26]: 
[('a', array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])),
 ('b', array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]))]

其他测试相同。

我可以用同样的方式搜索ll：

In [28]: [n for n,l in enumerate(ll) if id(l)==id(a)]
Out[28]: [0]

我可以通过测试项目是列表还是字典，并在其中进行搜索来为locals()搜索添加图层。

因此，即使我们采用测试方法，搜索所有可能的引用也并非易事。

我认为最好的方法是了解自己对变量的使用，以便您可以清楚地识别引用，视图和副本。在选定的情况下，您可以执行may_share_memory之类的测试或比较数据库。但是没有一个廉价的，明确的测试。如果有疑问的话，制作副本要比写一些东西的风险要便宜。在numpy使用的这些年里，我从来没有觉得有必要对这个问题作出明确的回答。

我发现OWNDATA标志非常有用。考虑以上变量

In [35]: a.flags['OWNDATA']
Out[35]: True
In [36]: b.flags['OWNDATA']   # ref
Out[36]: True
In [37]: c.flags['OWNDATA']   # view
Out[37]: False
In [38]: d.flags['OWNDATA']   # copy
Out[38]: True
In [39]: e.flags['OWNDATA']   # view
Out[39]: False

虽然我可以在这些简单的情况下预测OWNDATA值，但它的值并没有说明共享内存或共享ID。 False表明它是从另一个数组创建的，因此可能共享内存。但那只是'可能'。

我经常通过重塑一个范围来创建一个示例数组。

In [40]: np.arange(3).flags['OWNDATA']
Out[40]: True
In [41]: np.arange(4).reshape(2,2).flags['OWNDATA']
Out[41]: False

显然没有其他对数据的引用，但重新整形的数组并不“拥有”自己的数据。

会发生同样的情况

temp = np.arange(4); temp = temp.reshape(2,2)

我必须做

temp = np.arange(4); temp.shape = (2,2)

保持OWNDATA为真。 False OWNDATA在创建新数组对象后立即起作用，但如果重新定义或删除原始引用则不会更改。它很容易变得过时。

如何查找具有相同ID的所有变量？

2 个答案: