Python 避免np.where赋值给numpy数组
我希望以下内容(或类似内容)能够正常工作(不使用Python 避免np.where赋值给numpy数组,python,numpy,Python,Numpy,我希望以下内容(或类似内容)能够正常工作(不使用np.where) 也就是说,我希望k是ind值上的一个额外的布尔掩码,该值为true 我知道我可以使用np.where(ind)[0][k],但这比逻辑索引更昂贵 有没有一种引用a[ind]的方法可以引用a的基本内存?这适用于小数组(索引器!)。优化可能更加棘手 import numpy as np A = np.arange(0,10) k = np.array([0,1,0]) ind = np.logical_and(A>4, A%
np.where
)
也就是说,我希望k
是ind
值上的一个额外的布尔掩码,该值为true
我知道我可以使用np.where(ind)[0][k]
,但这比逻辑索引更昂贵
有没有一种引用
a[ind]
的方法可以引用a
的基本内存?这适用于小数组(索引器!)。优化可能更加棘手
import numpy as np
A = np.arange(0,10)
k = np.array([0,1,0])
ind = np.logical_and(A>4, A%2)
A[ind.nonzero()[0][k.nonzero()]] = np.pi
从经常引用的numpy索引页面: 。。。。单个布尔索引数组实际上与x[obj.nonzero()]相同。。。。但是,当obj.shape==x.shape时,速度更快
np.其中(cond)
是np.非零(cond)
但是让我们做一些简单的计时
In [239]: x = np.arange(10000)
In [240]: y = (x%2).astype(bool)
In [241]: x[y].shape
Out[241]: (5000,)
In [242]: idx = np.nonzero(y)
In [243]: x[idx].shape
Out[243]: (5000,)
In [244]: timeit x[y].shape
89.9 µs ± 726 ns per loop (mean ± std. dev. of 7 runs, 10000 loops each)
In [245]: timeit x[idx].shape
13.3 µs ± 107 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)
In [246]: timeit x[np.nonzero(y)].shape
34.2 µs ± 893 ns per loop (mean ± std. dev. of 7 runs, 10000 loops each)
因此,数组索引比布尔索引更快,即使我们使用显式where
A[ind][k]=
不起作用,因为A[ind]
是副本,而不是视图
In [251]: A = np.arange(100,110)
In [252]: ind = np.logical_and(A>104, A%2)
In [253]: ind
Out[253]:
array([False, False, False, False, False, True, False, True, False,
True])
In [254]: k = np.array([0,1,0], dtype=bool)
In [255]: A[ind]
Out[255]: array([105, 107, 109])
In [256]: A[ind][k]
Out[256]: array([107])
In [257]: A[ind][k] = 12
In [258]: A
Out[258]: array([100, 101, 102, 103, 104, 105, 106, 107, 108, 109])
但是使用k
从np中选择索引。其中(ind)
起作用:
In [262]: A[np.where(ind)[0][k]]=12
In [263]: A
Out[263]: array([100, 101, 102, 103, 104, 105, 106, 12, 108, 109])
获取而非集合的计时:
In [264]: timeit A[np.where(ind)[0][k]]
1.94 µs ± 75.7 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)
In [265]: timeit A[ind][k]
1.34 µs ± 13.3 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)
所以,是的,在这种情况下,双重掩蔽的速度要快一点,但如果它不起作用,那也没关系。不要为小时间的改进而烦恼
一种布尔索引方法
在这个小例子中,它与
A[np]基本相同。其中(ind)[0][k]]=12
问题不在于A[ind]
,而在于[k]
部分。如果没有它,它可以工作(除了它分配3
而不是np.pi
,因为它是一个整数数组。您没有解释,您打算用A[ind][k]实现什么
。这对我来说并不明显。k应该是ind
中真值的附加布尔掩码吗?是的,k
是ind
中真值的附加布尔掩码。我运行了一个快速测试,奇怪的是,其中的速度似乎快了一点。min(重复('a[mask]=0',globals=globals(),number=100000))->0.33872522017918527
min(重复('a[np.where(mask)]=0',globals=globals(),number=100000))->0.25470716995187104
@kazemakase做了,速度较慢。有时我觉得我的计算机只是在开玩笑……我想OP知道这种解决方案——他们只是担心它可能会慢。好的,明白了。如果有其他人想要一个适用于小数组的解决方案,我会把它留在这里。我已经相应地编辑了。@PaulPanzer我发现它很有帮助!我想其他人也会从这个答案中受益。这种类型的双布尔掩蔽在我的应用程序中不是人工的。A
表示一个大集合中每个点的质量,A
的条目在每次迭代中都会更新。ind
是满足简单测试条件和仅针对这些点,测试了一个更昂贵的条件,该条件在k
中返回。我提出了一种“纯布尔”索引方法,它似乎与where
版本的时间相同。+1 upvote。我喜欢你指给我们的地方。我肯定会重复几次:)
In [264]: timeit A[np.where(ind)[0][k]]
1.94 µs ± 75.7 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)
In [265]: timeit A[ind][k]
1.34 µs ± 13.3 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)
In [345]: ind1=ind.copy()
In [346]: ind1[ind] = k
In [348]: A[ind1]=3
In [349]: A
Out[349]: array([100, 101, 102, 103, 104, 105, 106, 3, 108, 109])