随机获取Python中重复值数组的3个最小值_Python_Arrays

随机获取Python中重复值数组的3个最小值

python arrays

随机获取Python中重复值数组的3个最小值,python,arrays,Python,Arrays,我有一个数组my_array，由于特殊原因，我想忽略它的值-5和-10（是的，在下面的示例中没有-10，但在其他数组中我必须管理是），然后获取数组的三个最小值的索引，并将它们附加到名为lista_Indexes\u CandidateTos的新列表中这是我的密码 my_array = [4, -5, 10, 4, 4, 4, 0, 4, 4] a = np.array(my_array) indices = a.argsort() indices = indices[a[indices] !

我有一个数组

my_array

，由于特殊原因，我想忽略它的值-5和-10（是的，在下面的示例中没有

-10

，但在其他数组中我必须管理是），然后获取数组的三个最小值的索引，并将它们附加到名为

lista_Indexes\u CandidateTos

的新列表中

这是我的密码

my_array = [4, -5, 10, 4, 4, 4, 0, 4, 4]
a = np.array(my_array) 
indices = a.argsort()
indices = indices[a[indices] != -5]
indices = indices[a[indices] != -10]
lista_indices_candidatos = []
for i in indices[:3]:
    lista_indices_candidatos.append(i)
print lista_indices_candidatos

这将从数组

[4、-5、10、4、4、4、4、0、4、4]

中获取3个最小值的索引

[6、0、3]

问题是，如果有重复的值，这将得到前三个最小值（第一个

（索引0）第二个

（索引3），忽略数组的其余

如何更改代码以完全随机地获取三个最小值，而不始终获取前三个值？

myArray=[4，-5,10,4,4,4,0,4,4]

myUniqueArray=列表（集合（myArray））

myUniqueArray.sort（）

返回[myArray.index（myUniqueArray[0]）、myArray.index（myUniqueArray[1]）、myArray.index（myUniqueArray[2]）]

.index不会为您提供一个随机索引，因为它对于给定的输入列表集始终是相同的值，但您可以使用该部分。

myArray=[4，-5,10,4,4,4,4,0,4,4]

myUniqueArray=列表（集合（myArray））

myUniqueArray.sort（）

返回[myArray.index（myUniqueArray[0]）、myArray.index（myUniqueArray[1]）、myArray.index（myUniqueArray[2]）]

.index不会为您提供随机索引，因为对于给定的一组输入列表，它的值始终相同，但您可以使用该部分。

这一部分如何：

import random

def eachIndexSorted(a):  # ... without -5 and -10
  for value in sorted(set(a) - { -5, -10 }):
    indexes = [ i for i in range(len(a)) if a[i] == value ]
    random.shuffle(indexes)
    for i in indexes:
      yield i

def firstN(iterator, n):
  for i in range(n):
    yield iterator.next()

print list(firstN(eachIndexSorted(my_array), 3))

如果您有非常大的数据，那么对整个数据集进行排序可能成本太高；迭代查找下一个最小值可能是更好的方法。（如果这方面对您来说不清楚且重要，请询问更多详细信息。）

这方面如何：

import random

def eachIndexSorted(a):  # ... without -5 and -10
  for value in sorted(set(a) - { -5, -10 }):
    indexes = [ i for i in range(len(a)) if a[i] == value ]
    random.shuffle(indexes)
    for i in indexes:
      yield i

def firstN(iterator, n):
  for i in range(n):
    yield iterator.next()

print list(firstN(eachIndexSorted(my_array), 3))

如果您有非常大的数据，那么对整个集合进行排序可能成本太高；以迭代方式查找每个下一个最小值可能是一个更好的方法。（如果这方面对您来说不清楚和重要，请询问更多细节。）

我没有引入随机性，因为它没有真正看到这样做的意义

如果需要前三个最小正值：

sorted([x for x in my_array if x >= 0])[:3]

sorted([(x,idx) for idx,x in enumerate(my_array) if x >= 0], key=lambda t: t[0])[:3]

[i for x,i in sorted([(x,idx) for idx,x in enumerate(my_array) if x >= 0], key=lambda t: t[0])[:3]]

如果需要前三个最低正值及其初始索引：

sorted([x for x in my_array if x >= 0])[:3]

sorted([(x,idx) for idx,x in enumerate(my_array) if x >= 0], key=lambda t: t[0])[:3]

[i for x,i in sorted([(x,idx) for idx,x in enumerate(my_array) if x >= 0], key=lambda t: t[0])[:3]]

如果只需要前3个最小正值初始索引：

sorted([x for x in my_array if x >= 0])[:3]

sorted([(x,idx) for idx,x in enumerate(my_array) if x >= 0], key=lambda t: t[0])[:3]

[i for x,i in sorted([(x,idx) for idx,x in enumerate(my_array) if x >= 0], key=lambda t: t[0])[:3]]

我没有引入随机性，因为它没有真正看到这样做的意义

如果需要前三个最小正值：

sorted([x for x in my_array if x >= 0])[:3]

sorted([(x,idx) for idx,x in enumerate(my_array) if x >= 0], key=lambda t: t[0])[:3]

[i for x,i in sorted([(x,idx) for idx,x in enumerate(my_array) if x >= 0], key=lambda t: t[0])[:3]]

如果需要前三个最低正值及其初始索引：

sorted([x for x in my_array if x >= 0])[:3]

sorted([(x,idx) for idx,x in enumerate(my_array) if x >= 0], key=lambda t: t[0])[:3]

[i for x,i in sorted([(x,idx) for idx,x in enumerate(my_array) if x >= 0], key=lambda t: t[0])[:3]]

如果只需要前3个最小正值初始索引：

sorted([x for x in my_array if x >= 0])[:3]

sorted([(x,idx) for idx,x in enumerate(my_array) if x >= 0], key=lambda t: t[0])[:3]

[i for x,i in sorted([(x,idx) for idx,x in enumerate(my_array) if x >= 0], key=lambda t: t[0])[:3]]

我的假设是，你想为我的_数组中的值获得3个随机索引，不包括[-10，-5]，这3个随机索引必须在剩余集合的3个最低值的索引列表中选择，对吗

那么这个呢：

from random import sample
my_array = [4, -5, 10, 4, 4, 4, 0, 4, 4]
sample([i for i, x in enumerate(my_array) if x in sorted(set(my_array) - {-10, -5})[:3]], 3)

将有限的一组值分解为：

from random import sample

my_array = [4, -5, 10, 4, 4, 4, 0, 4, 4]
filtered_list = sorted(set(my_array) - {-10, -5})[:3]

# Print 3 sample indices from my_array
print sample([i for i, x in enumerate(my_array) if x in filtered_list], 3)

我的假设是，你想为我的_数组中的值获得3个随机索引，不包括[-10，-5]，这3个随机索引必须在剩余集合的3个最低值的索引列表中选择，对吗

那么这个呢：

from random import sample
my_array = [4, -5, 10, 4, 4, 4, 0, 4, 4]
sample([i for i, x in enumerate(my_array) if x in sorted(set(my_array) - {-10, -5})[:3]], 3)

将有限的一组值分解为：

from random import sample

my_array = [4, -5, 10, 4, 4, 4, 0, 4, 4]
filtered_list = sorted(set(my_array) - {-10, -5})[:3]

# Print 3 sample indices from my_array
print sample([i for i, x in enumerate(my_array) if x in filtered_list], 3)

好的，我也不确定你想要达到什么目的。我喜欢Nasha答案的简单性，但我认为你希望结果集中始终有0的索引。按照我的理解，你想要最低三个值的索引，并且只有当其中一个值被多次列出时，你才想从中随机选取

以下是我的“尝试解决方案”：

import random

my_array = [4, -5, 10, 4, 4, 4, 0, 4, 4]
my_dict = {}
lista_indices_candidatos = []

for index, item in enumerate(my_array):
    try:
        my_dict[item] = my_dict[item] + [index]
    except:
        my_dict[item] = [index]

for i in [x for x in sorted(my_array) if x != -10 and x != -5][:3]:
    lista_indices_candidatos.append(random.choice(my_dict[i]))

print lista_indices_candidatos

在这个解决方案中，我用

my_array

中的所有值作为键构建了一个字典。字典的值是这些数字在

my_array

中的索引列表。然后，我使用列表理解和切片来获得三个最低值，以便在

for

循环中迭代。在那里，我可以随机选择一个索引从

my\u dict

中随机选择给定值的索引

我打赌有更好的方法来实现你想要实现的目标。也许你可以让我们知道你想做什么，这样我们就可以改进我们的答案

在阅读了你的评论之后，我发现你实际上并不想要一个完全随机的选择，而是一个没有重复的随机选择。所以这里有一个更新版本

import random

my_array = [4, -5, 10, 4, 4, 4, 0, 4, 4]
my_dict = {}
lista_indices_candidatos = []

for index, item in enumerate(my_array):
    try:
        my_dict[item] = my_dict[item] + [index]
    except:
        my_dict[item] = [index]

for l in my_dict:
    random.shuffle(my_dict[l])

for i in [x for x in sorted(my_array) if x != -10 and x != -5][:3]:
    lista_indices_candidatos.append(my_dict[i].pop())

print lista_indices_candidatos