Arrays 如何在numpy对象数组中查找最小/最大对象的索引？

在对象的numpy数组中（其中每个对象都有一个可以通过get_y（）方法检索的数值属性y），如何获得具有最大（或最小）y属性的对象的索引（无显式循环；以节省时间）？如果myarray是python列表，我可以使用以下内容，但ndarray似乎不支持索引。另外，numpy argmin似乎不允许提供密钥。

---

minindex=myarray.index（min（myarray，key=lambda x:x.get_y（））

比较数字数据类型、对象数据类型和列表的一些计时。得出你自己的结论：

In [117]: x = np.arange(1000)                                                   
In [118]: xo=x.astype(object)                                                   

In [119]: np.sum(x)                                                             
Out[119]: 499500
In [120]: np.sum(xo)                                                            
Out[120]: 499500

In [121]: timeit np.sum(x)                                                      
10.8 µs ± 242 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)

In [122]: timeit np.sum(xo)                                                     
39.2 µs ± 673 ns per loop (mean ± std. dev. of 7 runs, 10000 loops each)

In [123]: sum(x)                                                                
Out[123]: 499500
In [124]: timeit sum(x)                                                         
214 µs ± 6.58 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)

In [125]: timeit sum(xo)                                                        
25.3 µs ± 4.54 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)

In [126]: timeit sum(x.tolist())                                                
29.1 µs ± 26.7 ns per loop (mean ± std. dev. of 7 runs, 10000 loops each)

In [127]: timeit sum(xo.tolist())                                               
14.4 µs ± 120 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)

In [129]: %%timeit  temp=x.tolist() 
     ...: sum(temp)                                                                      
6.27 µs ± 18.8 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)

---

一些计时，比较数字数据类型、对象数据类型和列表。得出你自己的结论：

In [117]: x = np.arange(1000)                                                   
In [118]: xo=x.astype(object)                                                   

In [119]: np.sum(x)                                                             
Out[119]: 499500
In [120]: np.sum(xo)                                                            
Out[120]: 499500

In [121]: timeit np.sum(x)                                                      
10.8 µs ± 242 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)

In [122]: timeit np.sum(xo)                                                     
39.2 µs ± 673 ns per loop (mean ± std. dev. of 7 runs, 10000 loops each)

In [123]: sum(x)                                                                
Out[123]: 499500
In [124]: timeit sum(x)                                                         
214 µs ± 6.58 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)

In [125]: timeit sum(xo)                                                        
25.3 µs ± 4.54 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)

In [126]: timeit sum(x.tolist())                                                
29.1 µs ± 26.7 ns per loop (mean ± std. dev. of 7 runs, 10000 loops each)

In [127]: timeit sum(xo.tolist())                                               
14.4 µs ± 120 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)

In [129]: %%timeit  temp=x.tolist() 
     ...: sum(temp)                                                                      
6.27 µs ± 18.8 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)

---

为什么它是数组而不是列表？您已经知道如何使用列表。列表上的迭代速度更快。快速numpy计算需要数字数据类型，而不是对象。谢谢，但类似numpy.argmin（）的东西，如果（假设）有一个可用于这种情况，是否会比列表迭代速度更快？我有点困惑。请帮忙，这不是numpy的工作原理；操作并不仅仅因为在另一个对象中而神奇地更快。numpy之所以更快，是因为数组可以有固定的表示形式，因此它们可以顺序存储在内存中，从而一次加载到缓存中，这与列表不同，列表中的每个对象只是指向内存中浮动的其他对象的指针，必须查找该对象。numpy中的对象数据类型与此等效，与python列表相同。所以在这里使用numpy没有任何好处。@alkasm:非常感谢，但我认为当数组的对象是同质的（相同的类型和大小）时，在内存中对对象数据类型的处理是类似的，因为每个对象的大小通过用户指定的显式数据类型或隐式地作为对象中组件大小的总和来确定，因此允许固定大小的连续分配。我需要更仔细地学习。你能为我推荐一些阅读材料（来源）吗。再次感谢。为什么它是数组而不是列表？您已经知道如何使用列表。列表上的迭代速度更快。快速numpy计算需要数字数据类型，而不是对象。谢谢，但类似numpy.argmin（）的东西，如果（假设）有一个可用于这种情况，是否会比列表迭代速度更快？我有点困惑。请帮忙，这不是numpy的工作原理；操作并不仅仅因为在另一个对象中而神奇地更快。numpy之所以更快，是因为数组可以有固定的表示形式，因此它们可以顺序存储在内存中，从而一次加载到缓存中，这与列表不同，列表中的每个对象只是指向内存中浮动的其他对象的指针，必须查找该对象。numpy中的对象数据类型与此等效，与python列表相同。所以在这里使用numpy没有任何好处。@alkasm:非常感谢，但我认为当数组的对象是同质的（相同的类型和大小）时，在内存中对对象数据类型的处理是类似的，因为每个对象的大小通过用户指定的显式数据类型或隐式地作为对象中组件大小的总和来确定，因此允许固定大小的连续分配。我需要更仔细地学习。你能为我推荐一些阅读材料（来源）吗。再次感谢。