让我的嵌套循环更简单（运行时间更长）

Question

我是python嵌套循环的学习者。

下面我已经编写了我的代码。我想让我的代码更简单，因为当我运行代码时需要很长时间才能产生结果。

我有一个包含 1000 个值的列表：

Brake_index_values = [ 44990678,  44990679,  44990680,  44990681,  44990682,  44990683,
             44997076,  44990684,  44997077,  44990685,
            ...
             44960673,   8195083,   8979525, 100107546,  11089058,  43040161,
             43059162, 100100533,  10180192,  10036189]

我将第 1 个元素存储在另一个列表中

original_top_brake_index = [Brake_index_values[0]]

我创建了一个名为 temp 的临时列表和一个用于循环迭代的 numpy 数组：

temp =[]
arr = np.arange(0,1000,1)

循环操作：

for i in range(1, len(Brake_index_values)):
    if top_15_brake <= 15:
        a1 = Brake_index_values[i]
        #a2 = Brake_index_values[j]
        a3 = arr[:i]
        for j in a3:
            a2 = range(Brake_index_values[j] - 30000, Brake_index_values[j] + 30000)
            if a1 in a2:
                pass
            else:
                temp.append(a1)
        if len(temp)== len(a3):
            original_top_brake_index.append(a1)
            top_15_brake += 1
            del temp[:]
        else:
            del temp[:]
            continue

我正在比较Brake_index_values[0]元素前后30000范围内可用的Brake_index_values[1]元素，即`range(Brake_index_values[0]-30000, Brake_index_values[0]+30000)。

如果Brake_index_values[1] 在该范围之间可用，我应该忽略该元素并转到下一个元素Brake_index_values[2] 并遵循与之前Brake_index_values[0] 和Brake_index_values[1] 相同的过程

如果可用，则将值存储在original_top_brake_index 彻底追加操作中。

换句话说：

（让我们取 3 个值 a、b 和 c。我正在检查值 b 是否在 (a-30000 到 a+30000) 之间的范围内。可能性 1：如果 b 介于 (a-30000 到 a+) 之间30000) ，忽略那个元素（这里我存储在一个临时列表中）。然后用 c （下一个元素）继续相同的过程 可能性 2：如果 b 不在 b/w 中，则将 b 放在另一个名为 original_top_brake_index 的列表中 （这另一个列表是我需要的实际结果）

我得到的结果：

它正在工作，但是完成操作需要很长时间，有时它会显示 MemoryError。

我只是希望我的代码通过简单的操作更简单高效地工作。

Answer 1

试试这个代码（使用 numpy）：

import numpy as np
original_top_brake_index = [Brake_index_values[0]]
top_15_brake = 0
Brake_index_values = np.array(Brake_index_values)
for i, a1 in enumerate(Brake_index_values[0:]):
    if top_15_brake > 15:
        break
    m = (Brake_index_values[:i] - a1)
    if np.logical_or(m > 30000, m < - 30000).all():
        original_top_brake_index.append(a1)
        top_15_brake += 1

注意：您可能可以使其更高效，但这应该会显着减少操作数量（并且不会对原始代码的逻辑有太大改变）

Answer 2

我们可以使用bisect 模块通过查找大于或小于当前值的最小元素来缩短我们实际必须查找的元素。我们将使用来自here的食谱

我们来看这个例子：

from bisect import bisect_left, bisect_right

def find_lt(a, x):
    'Find rightmost value less than x'
    i = bisect_left(a, x)
    if i:
        return a[i-1]
    return

def find_gt(a, x):
    'Find leftmost value greater than x'
    i = bisect_right(a, x)
    if i != len(a):
        return a[i]
    return

vals = [44990678,  44990679,  44990680,  44990681,  44990682, 589548954, 493459734, 3948305434, 34939349534]

vals.sort()  # we have to sort the values for bisect to work
passed = []
originals = []

for val in vals:
    passed.append(val)
    l = find_lt(passed, val)
    m = find_gt(passed, val)
    cond1 = (l and l + 30000 >= val)
    cond2 = (m and m - 30000 <= val)
    if not l and not m:
        originals.append(val)
        continue
    elif cond1 or cond2:
        continue
    else:
        originals.append(val)

这给了我们：

print(originals)

[44990678, 493459734, 589548954, 3948305434, 34939349534]

可能还有另一种更数学的方法来做到这一点，但这至少应该简化您的代码。