将函数应用于元组数组

Question

我有一个要应用于数组元组的函数，我想知道是否存在一种干净的方法。

通常，我可以使用np.vectorize将函数应用于数组中的每个项目，但是，在这种情况下，“每个项目”是一个元组，因此numpy将数组解释为3d数组，并将函数应用于元组中的每个项目。

因此，我可以假设传入数组是以下之一：

1. 元组
2. 一维元组数组
3. 元组的二维数组

我可能可以编写一些循环逻辑，但是numpy似乎最有可能更有效地执行此操作，并且我不想重蹈覆辙。

这是一个例子。 我试图将tuple_converter函数应用于数组中的每个元组。

array_of_tuples1 = np.array([
        [(1,2,3),(2,3,4),(5,6,7)],
        [(7,2,3),(2,6,4),(5,6,6)],
        [(8,2,3),(2,5,4),(7,6,7)],
    ])

array_of_tuples2 = np.array([
        (1,2,3),(2,3,4),(5,6,7),
    ])

plain_tuple = (1,2,3)



# Convert each set of tuples
def tuple_converter(tup):
    return tup[0]**2 + tup[1] + tup[2]

# Vectorizing applies the formula to each integer rather than each tuple
tuple_converter_vectorized = np.vectorize(tuple_converter)

print(tuple_converter_vectorized(array_of_tuples1))
print(tuple_converter_vectorized(array_of_tuples2))
print(tuple_converter_vectorized(plain_tuple))

array_of_tuples1所需输出：

[[ 6 11 38]
 [54 14 37]
 [69 13 62]]

array_of_tuples2所需输出：

[ 6 11 38]

plain_tuple所需输出：

6

但是上面的代码会产生此错误（因为它试图将函数应用于整数而不是元组。）

<ipython-input-209-fdf78c6f4b13> in tuple_converter(tup)
     10 
     11 def tuple_converter(tup):
---> 12     return tup[0]**2 + tup[1] + tup[2]
     13 
     14 

IndexError: invalid index to scalar variable.

Answer 1

array_of_tuples1和array_of_tuples2实际上不是元组数组，而只是3维和2维整数数组：

In [1]: array_of_tuples1 = np.array([
   ...:         [(1,2,3),(2,3,4),(5,6,7)],
   ...:         [(7,2,3),(2,6,4),(5,6,6)],
   ...:         [(8,2,3),(2,5,4),(7,6,7)],
   ...:     ])

In [2]: array_of_tuples1
Out[2]: 
array([[[1, 2, 3],
        [2, 3, 4],
        [5, 6, 7]],

       [[7, 2, 3],
        [2, 6, 4],
        [5, 6, 6]],

       [[8, 2, 3],
        [2, 5, 4],
        [7, 6, 7]]])

因此，与其对向量进行矢量化处理，不如对函数进行矢量化处理，因为它基本上将遍历数组的各个元素（整数），而应将其应用于适当的轴 （“元组”的轴），而不用关心函数的类型。序列：

In [6]: np.apply_along_axis(tuple_converter, 2, array_of_tuples1)
Out[6]: 
array([[ 6, 11, 38],
       [54, 14, 37],
       [69, 13, 62]])

In [9]: np.apply_along_axis(tuple_converter, 1, array_of_tuples2)
Out[9]: array([ 6, 11, 38])

Answer 2

上面的另一个答案当然是正确的，并且可能是您要寻找的东西。 但是我注意到您在您的问题中添加了“干净”一词，因此我也想添加此答案。

如果我们可以假设所有元组都是3元素元组（或者它们具有一定数量的元素），那么您可以做一个小技巧，使同一段代码可以在任何单个元组上工作，即1d元组数组，或1d / 2d情况下没有if / else的2d元组数组。 我认为避免切换总是比较干净的（尽管我认为这可能会引起争议）。

import numpy as np

def map_to_tuples(x):
    x = np.array(x)
    flattened = x.flatten().reshape(-1, 3)
    return np.array([tup[0]**2 + tup[1] + tup[2] for tup in flattened]).reshape(x.shape[:-1])

根据需要分别输出以下内容供您输入：

[[ 6 11 38]
 [54 14 37]
 [69 13 62]]

[ 6 11 38]

6

Answer 3

如果您认真对待tuples位，则可以定义结构化dtype。

In [535]: dt=np.dtype('int,int,int')

In [536]: x1 = np.array([
        [(1,2,3),(2,3,4),(5,6,7)],
        [(7,2,3),(2,6,4),(5,6,6)],
        [(8,2,3),(2,5,4),(7,6,7)],
    ], dtype=dt)

In [537]: x1
Out[537]: 
array([[(1, 2, 3), (2, 3, 4), (5, 6, 7)],
       [(7, 2, 3), (2, 6, 4), (5, 6, 6)],
       [(8, 2, 3), (2, 5, 4), (7, 6, 7)]], 
      dtype=[('f0', '<i4'), ('f1', '<i4'), ('f2', '<i4')])

注意，显示使用元组。 x1是dt类型的3x3数组。 元素或记录显示为元组。 如果元组元素不同-浮点数，整数，字符串等，此功能将更为有用。

现在定义一个可以处理此类数组字段的函数：

In [538]: def foo(tup):
    return tup['f0']**2 + tup['f1'] + tup['f2']

它巧妙地适用于x1 。

In [539]: foo(x1)
Out[539]: 
array([[ 6, 11, 38],
       [54, 14, 37],
       [69, 13, 62]])

它也适用于相同dtype的1d数组。

In [540]: x2=np.array([(1,2,3),(2,3,4),(5,6,7) ],dtype=dt)

In [541]: foo(x2)
Out[541]: array([ 6, 11, 38])

和匹配类型的0d数组：

In [542]: foo(np.array(plain_tuple,dtype=dt))
Out[542]: 6

但是foo(plain_tuple)不起作用，因为该函数被编写为用于命名字段，而不是索引字段。

如果需要，可以修改该函数以将输入转换为正确的dtype：

In [545]: def foo1(tup):
    temp = np.asarray(tup, dtype=dt)
   .....:     return temp['f0']**2 + temp['f1'] + temp['f2']

In [548]: plain_tuple
Out[548]: (1, 2, 3)

In [549]: foo1(plain_tuple) 
Out[549]: 6

In [554]: foo1([(1,2,3),(2,3,4),(5,6,7)])  # list of tuples
Out[554]: array([ 6, 11, 38])