Namedtuple in Numpy

Question

我非常喜欢namedtuple集合的功能。具体而言，我喜欢它对于二维空间中的点是多么有用。

In : from collections import namedtuple 

In : Point = namedtuple('Point', ['x', 'y']) 

In : p = Point(1,2) 

In : p.x 
Out: 1 

In : p.y 
Out: 2 

我认为这比列举的第一个和第二个条目清晰得多。我想知道是否有办法让Point成为一个数组。例如

In: p1 = Point(1,2) 
In: p2 = Point(3,4) 
In: (p1+p2).x 
Out: 4 

和numpy类似的很好的功能。换句话说，我认为我希望Point成为numpy的子类？我可以这样做吗？如何？

Answer 1

像point_type这样的结构化数组没有定义涉及多个字段的数学运算。

随着样品从https://stackoverflow.com/a/33455682/901925

In [470]: point_type = [('x', float), ('y', float)] 
In [471]: points = np.array([(1,2), (3,4), (5,6)], dtype=point_type) 
In [472]: points 
Out[472]: 
array([(1.0, 2.0), (3.0, 4.0), (5.0, 6.0)], 
     dtype=[('x', '<f8'), ('y', '<f8')]) 
In [473]: points[0]+points[1] 
... 
TypeError: unsupported operand type(s) for +: 'numpy.void' and 'numpy.void' 

相反，我可以创建一个二维数组，然后将其视为point_type - 设置DataBuffer布局将是相同的：

In [479]: points = np.array([(1,2), (3,4), (5,6)],float) 
In [480]: points 
Out[480]: 
array([[ 1., 2.], 
     [ 3., 4.], 
     [ 5., 6.]]) 
In [481]: points.view(point_type) 
Out[481]: 
array([[(1.0, 2.0)], 
     [(3.0, 4.0)], 
     [(5.0, 6.0)]], 
     dtype=[('x', '<f8'), ('y', '<f8')]) 
In [482]: points.view(point_type).view(np.recarray).x 
Out[482]: 
array([[ 1.], 
     [ 3.], 
     [ 5.]]) 

我可以做数学横跨行，并继续以点的形式查看结果：

In [483]: (points[0]+points[1]).view(point_type).view(np.recarray) 
Out[483]: 
rec.array([(4.0, 6.0)], 
     dtype=[('x', '<f8'), ('y', '<f8')]) 
In [484]: _.x 
Out[484]: array([ 4.]) 
In [485]: points.sum(0).view(point_type) 
Out[485]: 
array([(9.0, 12.0)], 
     dtype=[('x', '<f8'), ('y', '<f8')]) 

我也可以与point_type开始，并认为它是2D的数学，然后视图它回

pdt1=np.dtype((float, (2,))) 
In [502]: points 
Out[502]: 
array([(1.0, 2.0), (3.0, 4.0), (5.0, 6.0)], 
     dtype=[('x', '<f8'), ('y', '<f8')]) 
In [503]: points.view(pdt1) 
Out[503]: 
array([[ 1., 2.], 
     [ 3., 4.], 
     [ 5., 6.]]) 
In [504]: points.view(pdt1).sum(0).view(point_type) 
Out[504]: 
array([(9.0, 12.0)], 
     dtype=[('x', '<f8'), ('y', '<f8')]) 

因此，有可能查看和在阵列上作为2d和作为recarray操作。要是漂亮或有用，它可能需要在用户定义的类中进行埋设。

另一种选择从recarray类中挑选想法的选项。在它的核心，它只是一个结构化数组，其中包含专门的__getattribute__（和setattribute）方法。该方法首先检索正常的数组方法和属性（例如x.shape，x.sum）。然后它会尝试在定义的字段名中对attr进行罚款。

def __getattribute__(self, attr): 
    try: 
     return object.__getattribute__(self, attr) 
    except AttributeError: # attr must be a fieldname 
     pass 
    fielddict = ndarray.__getattribute__(self, 'dtype').fields 
    try: 
     res = fielddict[attr][:2] 
    except (TypeError, KeyError): 
     raise AttributeError("record array has no attribute %s" % attr) 
    return self.getfield(*res) 
    ... 

points.view(np.recarray).x变得points.getfield(*points.dtype.fields['x'])。

一种替代方法将是从namedtuple（/usr/lib/python3.4/collections/__init__.py）借用，并定义x和y性质，这将索引2D阵列的[:,0]和[:,1]列。 将这些属性添加到np.matrix的子类可能是最容易的，让该类确保大多数数学结果是2d。

Answer 2

恐怕不是完全可能的，因为numpy类和namedtuple类不能一起子类化，但你可以做的是在它们之间进行转换。

>>> Point = namedtuple('Point', ['x', 'y']) 
>>> p1 = Point(1,2) 
>>> p2 = Point(3,4) 
>>> np.array(p1) 
array([1, 2]) 
>>> np.array(p1) + np.array(p2) 
array([4, 6]) 
>>> Point(*(np.array(p1) + np.array(p2))).x 
4 

Answer 3

可以使用得到几分相似的功能numpy的的structured arrays：

In [36]: import numpy as np 
    ...: point_type = [('x', float), ('y', float)] 
    ...: points = np.array([(1,2), (3,4), (5,6)], dtype=point_type) 

In [37]: points[2] 
Out[37]: (5.0, 6.0) 

In [38]: points['x'] 
Out[38]: array([ 1., 3., 5.]) 

使用属性附加伤害接入（例如，使用points.x），以使可用的所有字段甚至有可能由结构数组转换成recarray：

In [39]: pts = points.view(np.recarray) 

In [40]: pts['x'] 
Out[40]: array([ 1., 3., 5.]) 

In [41]: pts.x 
Out[41]: array([ 1., 3., 5.]) 

In [42]: pts[2] 
Out[42]: (5.0, 6.0) 

请注意，重新排列显然有一些性能问题，并可能有点烦人的使用。您可能还想查看pandas库，该库还允许按属性访问字段，并且不存在重新数组的问题。