在不更改密钥类型的情况下使用itertools.groupby？

Question

我试图通过阵列的两个维度组织大块numpy ndarray（最多16个维度的〜1mil条目的集合）组成两个子组。

目前，我使用itertool的groupby功能，但它会在我的字典里的值是itertools._grouper对象，在我的ndarray似乎被转换为grouper对象，无论我做什么。

虽然我可以自定义groupby函数来解决这个问题，但是在我的Python编程能力中，这似乎是一个基本问题，Python是一种非常新的语言，不确定如何防止这种情况发生，或者转换grouper对象回到带有正确字段的ndarray中。我需要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'])) 

谢谢！

Answer 1

我想你可能可以使用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] 

为了让你在你的问题，你可以不喜欢discribe嵌套的字典：

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 

Answer 2

看起来你几乎就在那里。 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])} 

或与2d数组（在第1列，然后在最后一列）。

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.]]] 

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

在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']