Python中按值分割浮点列表

我有一个数千个浮动的列表，我希望能够按最小值和最大值进行切片

例如，使用：

flist = [1.9842, 9.8713, 5.4325, 7.6855, 2.3493, 3.3333]

（我的实际列表长度为400000个浮点，但上面是一个工作示例）

我想要像这样的东西

def listclamp(minn, maxn, nlist):

以致

print listclamp(3, 8, flist)

应该给我

[3.3333, 5.4325, 7.6855]

我还需要做10000到30000次，所以速度很重要

（到目前为止，我还没有尝试过的示例代码，因为这对我来说是新的python领域）

对列表进行排序（如果反复使用同一个列表，只需对其排序一次），然后使用二进制搜索查找上下限的位置。 想想看，有一个包可以对分。

对列表进行排序（如果反复使用同一个列表，只需对其进行一次排序），然后使用二进制搜索查找上下限的位置。

---

想想看，有一个包可以-平分。

这将返回您想要的排序列表：

flist = [1.9842, 9.8713, 5.4325, 7.6855, 2.3493, 3.3333]

def listclamp(minn, maxn, nlist): 
    return sorted(filter(lambda x: xminn <= x <= maxn, nlist))

print listclamp(3, 8, flist) 

flist=[1.9842,9.8713,5.4325,7.6855,2.3493,3.3333]
def列表夹（minn、maxn、nlist）：
返回已排序（筛选器（lambda x:xminn这将返回您想要的已排序列表：

flist = [1.9842, 9.8713, 5.4325, 7.6855, 2.3493, 3.3333]

def listclamp(minn, maxn, nlist): 
    return sorted(filter(lambda x: xminn <= x <= maxn, nlist))

print listclamp(3, 8, flist) 

flist=[1.9842,9.8713,5.4325,7.6855,2.3493,3.3333]
def列表夹（minn、maxn、nlist）：
返回排序（filter）（lambda x:xminn显然要做的事情是先排序再筛选，或者先筛选再排序

如果您每次都有相同的列表，那么首先排序显然是一个胜利，因为这样您只需要排序一次而不是每次。这也意味着您可以使用二进制搜索进行筛选，而不是线性行走（如中所述-尽管这可能不会有回报，除非您的列表比此列表长得多）

如果您每次都有不同的列表，那么首先过滤可能是一个胜利，因为排序可能是最慢的部分，并且您正在以这种方式对较小的列表进行排序

但让我们停止猜测，开始测试

使用数千个浮动列表，其中大约一半在范围内：

In [1591]: flist = [random.random()*10 for _ in range(5000)]
In [1592]: %timeit sorted(x for x in flist if 3 <= x < 8)
100 loops, best of 3: 3.12 ms per loop
In [1593]: %timeit [x for x in sorted(flist) if 3 <= x < 8]
100 loops, best of 3: 4 ms per loop
In [1594]: %timeit l=sorted(flist); l[bisect.bisect_left(l, 3):bisect.bisect_right(l, 8)]
100 loops, best of 3: 3.36 ms per loop

所以，如果你一遍又一遍地使用同一个列表，显然要对它进行一次排序

否则，您可以在真实数据上进行测试……但我们所说的是将耗时毫秒的数据减少22%。即使您这样做了数千次，也可以节省不到一秒钟的时间。仅仅是键入不同实现的成本就大大降低了对它们的理解、概括、调试和性能测试它们不仅仅是这样


但事实上，如果您正在执行数以百万计的操作，这些操作分布在数十万个值上，而且速度很重要，那么您首先不应该使用列表，而应该使用数组。NumPy可以只存储原始的
浮点值，而无需将其装箱为Python对象。此外，还可以节省内存（以及改进缓存局部性），这意味着，
np.sort
中的内部循环比
sorted
中的内部循环快，因为它不必进行最终涉及拆箱两个数字的Python函数调用，它只需直接进行比较

假设您首先将值存储在一个数组中，它是如何叠加的

In [1607]: flist = np.random.random(5000) * 10
In [1608]: %timeit a = np.sort(flist); a = a[3 <= a]; a = a[a < 8]
1000 loops, best of 3: 742 µs per loop
In [1611]: %timeit c = b[3 <= b]; d = c[c < 8]
10000 loops, best of 3: 29.8 µs per loop

[1607]中的
：flist=np.random.random（5000）*10
在[1608]中：%timeit a=np.sort（flist）；a=a[3最明显的做法是先排序，然后过滤，或者过滤，然后排序

如果您每次都有相同的列表，那么首先排序显然是一个胜利，因为这样您只需要排序一次而不是每次。这也意味着您可以使用二进制搜索进行筛选，而不是线性行走（如中所述-尽管这可能不会有回报，除非您的列表比此列表长得多）

如果您每次都有不同的列表，那么首先过滤可能是一个胜利，因为排序可能是最慢的部分，并且您正在以这种方式对较小的列表进行排序

但让我们停止猜测，开始测试

使用数千个浮动列表，其中大约一半在范围内：

In [1591]: flist = [random.random()*10 for _ in range(5000)]
In [1592]: %timeit sorted(x for x in flist if 3 <= x < 8)
100 loops, best of 3: 3.12 ms per loop
In [1593]: %timeit [x for x in sorted(flist) if 3 <= x < 8]
100 loops, best of 3: 4 ms per loop
In [1594]: %timeit l=sorted(flist); l[bisect.bisect_left(l, 3):bisect.bisect_right(l, 8)]
100 loops, best of 3: 3.36 ms per loop

所以，如果你一遍又一遍地使用同一个列表，显然要对它进行一次排序

否则，您可以在真实数据上进行测试……但我们所说的是将耗时毫秒的数据减少22%。即使您这样做了数千次，也可以节省不到一秒钟的时间。仅仅是键入不同实现的成本就大大降低了对它们的理解、概括、调试和性能测试它们不仅仅是这样


但事实上，如果您正在执行数以百万计的操作，这些操作分布在数十万个值上，而且速度很重要，那么您首先不应该使用列表，而应该使用数组。NumPy可以只存储原始的
浮点值，而无需将其装箱为Python对象。此外，还可以节省内存（以及改进缓存局部性），这意味着，
np.sort
中的内部循环比
sorted
中的内部循环快，因为它不必进行最终涉及拆箱两个数字的Python函数调用，它只需直接进行比较

假设您首先将值存储在一个数组中，它是如何叠加的

In [1607]: flist = np.random.random(5000) * 10
In [1608]: %timeit a = np.sort(flist); a = a[3 <= a]; a = a[a < 8]
1000 loops, best of 3: 742 µs per loop
In [1611]: %timeit c = b[3 <= b]; d = c[c < 8]
10000 loops, best of 3: 29.8 µs per loop

[1607]中的
：flist=np.random.random（5000）*10
在[1608]中：%timeit a=np.sort（flist）；a=a[3过滤项目，然后对其进行排序，反之亦然。虽然先过滤会更好，因为它会减少
NlogN
中的
N
。您是否有任何代码来显示您尝试过的内容？我尝试的第一种方法需要不到1微秒的时间，因此进行数千次过滤仍然需要很短的时间。那么速度真的很重要吗？你的列表中有“几千个浮动”吗，或者仅仅是他给出的例子？你还有“几千次”的切片吗？您的数据范围是什么？您的值是在整个范围内均匀分布的，还是数据是以簇的形式分布的？最后，您有多少个有效数字？过滤项目，然后对其进行排序，或者反之亦然。尽管f