在满足条件之前过滤掉所有元素，保留之后的所有元素

Question

我想知道是否有以下问题的简单解决方案。 这里的问题是，在初始条件为真之后，我想保留此列表中出现的每个元素。 这里的条件是我想在值大于 18 的条件为真之前删除所有内容，但之后保留所有内容。 例子

输入：

p = [4,9,10,4,20,13,29,3,39]

预期 output：

p = [20,13,29,3,39]

我知道您可以通过以下方式过滤整个列表

[x for x in p if x>18] 

但是一旦找到第一个大于 18 的值，我想停止此操作，然后将值的 rest 包括在内，无论它们是否满足条件。 这似乎是一个简单的问题，但我还没有找到解决方案。

Answer 1

您可以使用itertools.dropwhile ：

from itertools import dropwhile

p = [4,9,10,4,20,13,29,3,39]

p = dropwhile(lambda x: x <= 18, p)
print(*p) # 20 13 29 3 39

在我看来，这可以说是最容易阅读的版本。 这也对应于其他函数式编程语言中的常见模式，例如 Haskell 中的dropWhile (<=18) p和 Scala 中的p.dropWhile(_ <= 18) 。

---

或者，使用海象运算符（仅在 python 3.8+ 中可用）：

exceeded = False
p = [x for x in p if (exceeded := exceeded or x > 18)]
print(p) # [20, 13, 29, 3, 39]

但我的猜测是有些人不喜欢这种风格。 在这种情况下，可以做一个明确for循环（ilkkachu 的建议）：

for i, x in enumerate(p):
    if x > 18:
        output = p[i:]
        break
else:
    output = [] # alternatively just put output = [] before for

Answer 2

您可以在生成器表达式和next中使用enumerate和列表切片：

out = next((p[i:] for i, item in enumerate(p) if item > 18), [])

Output：

[20, 13, 29, 3, 39]

---

在运行时方面，它取决于数据结构。

下图显示了此处不同长度p的答案之间的运行时差异。

如果原始数据是一个列表，那么使用@Kelly Bundy提出的惰性迭代器显然是赢家：

但是如果初始数据是一个ndarray object，那么@richardec和@0x263A （对于大数组）提出的向量化操作会更快。 特别是，无论数组大小如何，numpy 都优于列表方法。 但是对于非常大的 arrays，pandas 开始比 numpy 表现更好（我不知道为什么，我（我相信其他人）会感激它，如果有人能解释它。

用于生成第一个 plot 的代码：

import perfplot
import numpy as np
import pandas as pd
import random
from itertools import dropwhile

def it_dropwhile(p):
    return list(dropwhile(lambda x: x <= 18, p))

def walrus(p):
    exceeded = False
    return [x for x in p if (exceeded := exceeded or x > 18)]

def explicit_loop(p):
    for i, x in enumerate(p):
        if x > 18:
            output = p[i:]
            break
    else:
        output = []
    return output

def genexpr_next(p):
    return next((p[i:] for i, item in enumerate(p) if item > 18), [])

def np_argmax(p):
    return p[(np.array(p) > 18).argmax():]

def pd_idxmax(p):
    s = pd.Series(p)
    return s[s.gt(18).idxmax():]

def list_index(p):
    for x in p:
        if x > 18:
            return p[p.index(x):]
    return []

def lazy_iter(p):
    it = iter(p)
    for x in it:
        if x > 18:
            return [x, *it]
    return []

perfplot.show(
    setup=lambda n: random.choices(range(0, 15), k=10*n) + random.choices(range(-20,30), k=10*n),
    kernels=[it_dropwhile, walrus, explicit_loop, genexpr_next, np_argmax, pd_idxmax, list_index, lazy_iter],
    labels=['it_dropwhile','walrus','explicit_loop','genexpr_next','np_argmax','pd_idxmax', 'list_index', 'lazy_iter'],
    n_range=[2 ** k for k in range(18)],
    equality_check=np.allclose,
    xlabel='~n/20'
)

用于生成第二个 plot 的代码（请注意，我必须修改list_index因为 numpy 没有index方法）：

def list_index(p):
    for x in p:
        if x > 18:
            return p[np.where(p==x)[0][0]:]
    return []

perfplot.show(
    setup=lambda n: np.hstack([np.random.randint(0,15,10*n), np.random.randint(-20,30,10*n)]),
    kernels=[it_dropwhile, walrus, explicit_loop, genexpr_next, np_argmax, pd_idxmax, list_index, lazy_iter],
    labels=['it_dropwhile','walrus','explicit_loop','genexpr_next','np_argmax','pd_idxmax', 'list_index', 'lazy_iter'],
    n_range=[2 ** k for k in range(18)],
    equality_check=np.allclose,
    xlabel='~n/20'
)

Answer 3

这里有很好的解决方案； 只是想演示如何使用 numpy 进行操作：

>>> import numpy as np
>>> p[(np.array(p) > 18).argmax():]
[20, 13, 29, 3, 39]

---

由于这里有很多不错的答案，我决定运行一些简单的基准测试。 第一个使用长度为 9 的 OP 的样本数组（ [4,9,10,4,20,13,29,3,39] ）。第二个使用随机生成的长度为 20000 的数组，其中前半部分介于0 和 15，后半部分介于 -20 和 30 之间（这样分割就不会出现在中间）。

使用 OP 的数据（长度为 9 的数组）：

%timeit enke()
650 ns ± 15.9 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)

%timeit j1lee1()
546 ns ± 4.22 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)

%timeit j1lee2()
551 ns ± 19 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)

%timeit j2lee3()
536 ns ± 12.9 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)

%timeit richardec()
2.08 µs ± 16 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)

使用长度为 20,000（20,000）的数组：

%timeit enke()
1.5 ms ± 34.5 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)

%timeit j1lee1()
1.95 ms ± 43 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)

%timeit j1lee2()
2.1 ms ± 53.7 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)

%timeit j2lee3()
2.33 ms ± 96.2 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)

%timeit richardec()
13.3 µs ± 461 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)

生成第二个数组的代码：

p = np.hstack([np.random.randint(0,15,10000),np.random.randint(-20,30,10000)])

因此，对于小型机箱，numpy 是一个小部件，不需要。 但是大的情况下，numpy 几乎快 100 倍，并且是 go 的方式: :)

Answer 4

我注意到 OP 在答案下提到p实际上是 Pandas DataFrame。 这是使用 Pandas 过滤所有元素的方法，直到大于 18 的数字的第一个实例：

import pandas as pd
df = pd.DataFrame([4,9,10,4,20,13,29,3,39])
df = df[df[0].gt(18).idxmax():]
print(df)

输出：

    0
4  20
5  13
6  29
7   3
8  39

注意：我对您的 DataFrame 的实际结构视而不见，所以我只是使用了给出的内容。

Answer 5

以我的经验，至少对于整数列表，使用enumerate只是为了找到一个索引并丢弃所有其他索引是如此浪费，以至于首先只找到元素然后使用list.index来查找它的索引会更快。 根据一些测试，我预计它比@enke 的 benchmark中的explicit_loop解决方案（使用enumerate ）快 1.44 倍。

def start_over_18(p):
    for x in p:
        if x > 18:
            return p[p.index(x):]
    return []

另一种解决方案，使用迭代器，所以我根本不用担心索引。 似乎比explicit_loop解决方案快两倍：

def start_over_18(p):
    it = iter(p)
    for x in it:
        if x > 18:
            return [x, *it]
    return []