0

我试图通过数组的两个维度将一个大的 numpy ndarray（最多 16 个维度的约 1 百万个条目的集合）组织成两个子组。

目前，我正在使用 itertool 的groupby函数，但它在我的字典中创建的值是itertools._grouper对象，无论我做什么，我ndarray似乎都被转换为对象。grouper

虽然我可以制作一个自定义groupby函数来解决这个问题，但这似乎是我在 Python 中编码能力的一个基本问题，我对这种语言非常陌生，不确定如何防止这种情况或将grouper对象转换回ndarraywith正确的字段。我需要，ndarray因为它的字段需要维护以供以后操作。

我将如何修复以下代码以将返回的groupby结果完全转换回ndarray或阻止转换？

array = np.sort(array, order=['Front','Back','SecStruc'])
front_dict = dict((k,v) for k,v in groupby(array, lambda array : array['Front']))
for key in front_dict:
    front_dict[key] = dict((k,list(v)) for k,v in groupby(front_dict[key], 
    lambda array : front_dict[key]['Back']))

谢谢！

4

2 回答 2

2

我想你也许可以用numpy.split这个。您可以通过执行以下操作将数组拆分为子数组：

import numpy as np

def findsplit(a):
    diff = a[1:] != a[:-1]
    edges = np.where(diff)[0]
    return edges + 1

array = np.array([0,0,0,1,1,1,1,2,2,3,4,4,4])
s = np.split(array, findsplit(array))
for a in s:
    print a
# [0 0 0]
# [1 1 1 1]
# [2 2]
# [3]
# [4 4 4]

要获得您在问题中描述的嵌套字典，您可以执行以下操作：

byFront = np.split(array, findsplit(array['Front']))
front_dict = {}
for sameFront in byFront:
    back_dict = {}
    byBack = np.split(sameFront, findsplit(sameFront['Back']))
    for sameBack in byBack:
        back_dict[sameBack['Back'][0]] = sameBack
    front_dict[sameFront['Front'][0]] = back_dict
于 2013-11-05T07:51:03.997 回答
0

看起来你快到了。 list(v)是一个可以轻松转换为数组的列表。

x=np.array([0,0,0,1,1,1,1,2,2,3,4,4,4])
{k:np.array(list(v)) for k,v in groupby(x)}

{0: array([0, 0, 0]),
 1: array([1, 1, 1, 1]),
 2: array([2, 2]),
 3: array([3]),
 4: array([4, 4, 4])}

或者使用二维数组（在第一列分组，然后在最后一列分组）。

x=np.array([[0,1,2],[1,2,3],[1,2,4],[1,0,4],[2,3,1]])
d={k:list(v) for k,v in groupby(x,lambda s:s[0])}
print d
# {0: [array([0, 1, 2])],
#  1: [array([1, 2, 3]), array([1, 2, 4]), array([1, 0, 4])],
#  2: [array([2, 3, 1])]}
for i in d.keys():
    d[i]={k:np.array(list(v)) for k,v in groupby(list(d[i]),lambda s:s[2])}
print d
# {0: {2: array([[0, 1, 2]])},
#  1: {3: array([[1, 2, 3]]), 4: array([[1, 2, 4], [1, 0, 4])},
#  2: {1: array([[2, 3, 1]])}}
print d[1][4]
#  [[1 2 4]
#   [1 0 4]]

list(v)在任一阶段我是否使用或-都没有多大关系np.array(list(v))（前提是您有兴趣在第一个维度上进行迭代）。

使用改编自 numpy 文档的结构化数组

x = np.array([(1.5,2.5,(1.0,2.0)),(1.5,2.5,(2.0,4.0)),(3.,4.,(4.,5.)),(1.,3.,(2.,6.))],
        dtype=[('x','f4'),('y',np.float32),('value','f4',(2,2))])
d={k:list(v) for k,v in groupby(x,lambda s:s['x'])}
for i in d.keys():
    d[i]={k:list(v) for k,v in groupby(list(d[i]),lambda s:s['y'])}
pprint(d)
for dd in d[1.5][2.5]:
    print dd
print d[1.5][2.5][0].dtype
# [('x', '<f4'), ('y', '<f4'), ('value', '<f4', (2, 2))]
dd = np.array(d[1.5][2.5],dtype=x.dtype)
print dd
print dd.dtype
print dd[0]
# (1.5, 2.5, [[1.0, 2.0], [1.0, 2.0]])
print dd['value']
# [[[ 1.  2.] [ 1.  2.]]
#  [[ 2.  4.] [ 2.  4.]]]

“最里面”元素的结构化数组字符被保留。np.array(...,dtype=x.dtype)如果我想将这些数组的列表变成一个数组（例如dd） ，我只需要使用。

其中d[1.5][2.5][0]['value']，1.5和2.5是字典键，0是列表索引，value是结构数组字段名称。

但是groupby真的需要这种用法吗？我可以通过正常的 numpy 索引获得最后一个“值”。x并且不必对“行”进行排序。对于非常大的阵列，速度和内存使用可能是重要的考虑因素。

I=(x['x']==1.5)&(x['y']==2.5)
print x[I]['value']
于 2013-11-05T06:16:25.710 回答