Question

我想使用例如np.searchsorted，但是，我不想创建一个包含值的显式数组。相反，我想定义一个函数，该函数给出在数组的所需位置处的期望值，例如p(i) = i，其中i表示数组中的位置。

就我而言，生成有关该函数的值的数组既不高效也不优雅。有什么办法可以做到这一点？

Answer 1

那又怎么样呢？

import collections

class GeneratorSequence(collections.Sequence):
    def __init__(self, func, size):
        self._func = func
        self._len = size

    def __len__(self):
        return self._len

    def __getitem__(self, i):
        if 0 <= i < self._len:
            return self._func(i)
        else:
            raise IndexError

    def __iter__(self):
        for i in range(self._len):
            yield self[i]

这将适用于np.searchsorted()，例如：

import numpy as np

gen_seq = GeneratorSequence(lambda x: x ** 2, 100)
np.searchsorted(gen_seq, 9)
# 3

您还可以编写自己的二进制搜索功能，在这种情况下，您实际上并不需要NumPy，这实际上是有益的：

def bin_search(seq, item):
    first = 0
    last = len(seq) - 1
    found = False
    while first <= last and not found:
        midpoint = (first + last) // 2
        if seq[midpoint] == item:
            first = midpoint
            found = True
        else:
            if item < seq[midpoint]:
                last = midpoint - 1
            else:
                first = midpoint + 1
    return first

给出相同的结果：

all(bin_search(gen_seq, i) == np.searchsorted(gen_seq, i) for i in range(100))
# True

顺便说一句，这也是 WAY 的更快方式：

gen_seq = GeneratorSequence(lambda x: x ** 2, 1000000)

%timeit np.searchsorted(gen_seq, 10000)
# 1 loop, best of 3: 1.23 s per loop
%timeit bin_search(gen_seq, 10000)
# 100000 loops, best of 3: 16.1 µs per loop

Answer 2

受@ norok2评论的启发，我认为您可以使用类似这样的内容：

def f(i):
    return i*2 # Just an example

class MySeq(Sequence):
    def __init__(self, f, maxi):
        self.maxi = maxi
        self.f = f
    def __getitem__(self, x):
        if x < 0 or x > self.maxi:
             raise IndexError()
        return self.f(x)
    def __len__(self):
        return self.maxi + 1

在这种情况下，f是您的函数，而maxi是最大索引。当然，这仅在函数f返回排序顺序的值时有效。
此时，您可以在MySeq内使用np.searchsorted类型的对象。

没有显式数组的二进制搜索

2 个答案: