Question

我有一个数字列表，None是这样的：

l = [2., None, 3., 1., None, 2., None, 5.]

我想获得最小数量及其索引，而None s应该被忽略。对于给定的示例，结果将是：

(1., 3)

当然，编写一个能够满足我想要的功能是很简单的，但我更喜欢一些有效的内置或至少是高级方法。我对Python 3的解决方案特别感兴趣，其中min - 函数不接受None作为参数。

Answer 1

min((v,i) for i,v in enumerate(l) if v is not None)
(1.0, 3) # (value, index)

Answer 2

我可能有两部分：

m = min(x for x in l if x is not None)
s = (m, l.index(m)) # this will grab the first index

如果您想使列表成为单通道+一个班轮解决方案：

midx, mval = min(enumerate(x if x is not None else float('inf') for x in l), key=lambda i: i[1])

enumerate()段产生如下迭代：

0 2.0
1 inf
2 3.0
3 1.0
4 inf
5 2.0
6 inf
7 5.0

然后调用min()并使用enumerate()返回lambda来检查i[1]索引中的值（例如2.0, inf, ..., 5.0）。因此，使用原始列表中的生成器仅返回一个迭代，返回最终元组，以“过滤并替换”NoneType索引。

Answer 3

您可以定义转化功能，并将其与min：

一起使用

lst = [2., None, 3., 1., None, 2., None, 5.]

def converter(x):
    return x[1] if x[1] is not None else float('inf')

res = min(enumerate(lst), key=converter)[::-1]

(1.0, 3)

如果您对使用第三方库感到满意，请使用NumPy中的等效文件：

arr = np.array(lst).astype(float)
arr[np.isnan(arr)] = np.inf

res = arr.min(), arr.argmin()

或者，更有效率，您可以使用np.nanargmin：

arg = np.nanargmin(arr)
minval = arr[arg]

res = minval, arg

Answer 4

l = [2., None, 3., 1., None, 2., None, 5.]

idx = l.index(min(x for x in l if x is not None))

print(l[idx], idx) # get value, and idx

输出

1.0 3

Answer 5

这是一种方法。

<强>演示：

(1.0, 3)

<强>输出：

 private void fastlevel_CheckedChanged(object sender, EventArgs e)
    int turn=0;
        if (fastlevel.Checked)
        {   
            //Click X;Y
            Thread.Sleep(1000);
            mouse_event(MOUSEEVENTF_LEFTDOWN, 0, 0, 0, 0);
            mouse_event(MOUSEEVENTF_LEFTUP, 0, 0, 0, 0);
            //MessageBox.Show("OK");
            if(turn==0)
            {
                turn++;
                //if  bitmap was found
                MessageBox.Show("FIRST TURN");
            {
            else
            {
                 MessageBox.Show("SECOND TURN");
                turn++;
            }
        }

Answer 6

value = min(l, key=lambda x: float('inf') if x is None else x) index = l.index(value)

如果这是一个问题，可能包括检查值不是inf（即l中没有数字的情况）

此方法通过简单地更改min比较值的方式，避免在内部构建新数组。

Answer 7

您可以避免像这样使用key：

>>> import operator as op
>>> import itertools as it
>>> min(it.filterfalse(op.methodcaller('__contains__', None), zip(l, it.count())))
(1.0, 3)

Answer 8

最复杂的是在列表中替换，我认为：

        import numpy as np

        l = [2., None, 3., 1., None, 2., None, 5.]

        #### function to replace in a list 
        def replaced(sequence, old, new):
            return (new if x == old else x for x in sequence)

        l=list(replaced(l,None,np.nan))

        #### numpy specific function
        position = np.nanargmin(l)
        value = l[position]

        print(position, value)

Answer 9

虽然我更喜欢接受的答案。您可以使用 NoneType 的演示代码：

lst = [2., None, 3., 1., None, 2., None, 5.]


    
def converter(x):
    NoneType = type(None)
    return x[1] if not isinstance(x[1], NoneType) else float('inf')
       
      
res = min(enumerate(lst), key=converter)[::-1]

print(res)

给予

(1.0, 3)

Answer 10

为什么结果应该是（1.，3），之后是1,2，

l = [2., None, 3., 1., None, 2., None, 5.]

bar = map(float, [e for e in l if isinstance(e, float)])
print (min(float(i) for i in bar))

使用Nones

10 个答案: