实现函数的最佳方法是什么，该函数采用任意数量的1D数组，并返回包含匹配值索引的元组（如果有）。
这是我想做的一些伪代码：
a = np.array([1, 0, 4, 3, 2])
b = np.array([1, 2, 3, 4, 5])
c = np.array([4, 2])
(ind_a, ind_b, ind_c) = return_equals(a, b, c)
# ind_a = [2, 4]
# ind_b = [1, 3]
# ind_c = [0, 1]
(ind_a, ind_b, ind_c) = return_equals(a, b, c, sorted_by=a)
# ind_a = [2, 4]
# ind_b = [3, 1]
# ind_c = [0, 1]
def return_equals(*args, sorted_by=None):
...
您可以将numpy.intersect1d与reduce一起使用：
def return_equals(*arrays):
matched = reduce(np.intersect1d, arrays)
return np.array([np.where(np.in1d(array, matched))[0] for array in arrays])
reduce可能会很慢，因为我们在此处创建中间的numpy数组（对于大量输入可能非常慢），如果我们使用Python的set及其.intersection()方法，我们可以防止这种情况：
matched = np.array(list(set(arrays[0]).intersection(*arrays[1:])))
相关的GitHub票：设置操作的N阵列版本，尤其是Intersect1d
此解决方案基本上将所有输入1D数组连接到一个大1D数组中，目的是在vectorized manner中执行所需的操作。它使用循环的唯一位置是在开始获得输入阵列长度的开始，这在运行时的成本上必须很小。
这是函数实现 -
import numpy as np
def return_equals(*argv):
# Concatenate input arrays into one big array for vectorized processing
A = np.concatenate((argv[:]))
# lengths of input arrays
narr = len(argv)
lens = np.zeros((1,narr),int).ravel()
for i in range(narr):
lens[i] = len(argv[i])
N = A.size
# Start indices of each group of identical elements from different input arrays
# in a sorted version of the huge concatenated input array
start_idx = np.where(np.append([True],np.diff(np.sort(A))!=0))[0]
# Runlengths of islands of identical elements
runlens = np.diff(np.append(start_idx,N))
# Starting and all indices of the positions in concatenate array that has
# islands of identical elements which are present across all input arrays
good_start_idx = start_idx[runlens==narr]
good_all_idx = good_start_idx[:,None] + np.arange(narr)
# Get offsetted indices and sort them to get the desired output
idx = np.argsort(A)[good_all_idx] - np.append([0],lens[:-1].cumsum())
return np.sort(idx.T,1)
in python：
def return_equal(*args):
rtr=[]
for i, arr in enumerate(args):
rtr.append([j for j, e in enumerate(arr) if
all(e in a for a in args[0:i]) and
all(e in a for a in args[i+1:])])
return rtr
>>> return_equal(a,b,c)
[[2, 4], [1, 3], [0, 1]]
开始，我会尝试：
def return_equals(*args):
x=[]
c=args[-1]
for a in args:
x.append(np.nonzero(np.in1d(a,c))[0])
return x
如果我添加d=np.array([1,0,4,3,0])（它只有1个匹配；如果没有匹配项怎么办？）
然后
return_equals(a,b,d,c)
生产：
[array([2, 4], dtype=int32),
array([1, 3], dtype=int32),
array([2], dtype=int32),
array([0, 1], dtype=int32)]
由于输入和返回数组的长度都可能有所不同，因此您实际上无法将问题矢量化。也就是说，一次在所有输入中执行操作需要一些特殊的体操。而且，如果与典型长度相比，阵列的数量很少，我就不必担心速度。迭代几次并不昂贵。它迭代超过100个值。
当然，您可以将关键字参数传递给in1d。
尚不清楚您尝试使用sorted_by参数做什么。在将它们传递给此功能之前，您可以很容易地适用于阵列吗？
列表此迭代的理解版本：
[np.nonzero(np.in1d(x,c))[0] for x in [a,b,d,c]]
我可以想象将阵列连接到一个更长的一个，应用in1d，然后将其分成子阵列。有一个np.split，但是它要求您告诉它每个子列表中要放置多少个元素。这意味着，以某种方式确定每个参数有多少匹配。在不循环的情况下这样做可能很棘手。
这些碎片（仍然需要包装为功能）是：
args=[a,b,d,c]
lens=[len(x) for x in args]
abc=np.concatenate(args)
C=np.cumsum(lens)
I=np.nonzero(np.in1d(abc,c))[0]
S=np.split(I,(2,4,5))
[S[0],S[1]-C[0],S[2]-C[1],S[3]-C[2]]
I
# array([ 2, 4, 6, 8, 12, 15, 16], dtype=int32)
C
# array([ 5, 10, 15, 17], dtype=int32)
(2,4,5)是C的连续值之间的I元素数量，即a，b，...