我如何摆脱“循环”思想流派？

这是一个相当概念性的问题，但是我希望我能对此得到一些好的建议。我做的很多编程工作都是使用（NumPy）数组。我经常必须匹配大小不同的两个或多个数组中的项，而我要去的第一件事是一个for循环，甚至更糟的是嵌套的for循环。我想尽可能避免for循环，因为它们很慢（至少在Python中如此）。

我知道NumPy的很多功能都需要我研究一些预定义的命令，但是当您必须迭代某些内容时，您（作为经验丰富的程序员）是否会想到一个一般的思考过程？

所以我经常有这样的事情，这很糟糕，我想避免它：

small_array = np.array(["one", "two"])
big_array = np.array(["one", "two", "three", "one"])

for i in range(len(small_array)):
    for p in range(len(big_array)):
        if small_array[i] == big_array[p]:
            print "This item is matched: ", small_array[i]

我知道有多种方法可以实现这一目标，但是我对通用的思维方法（如果存在）感兴趣。

当学习有效使用NumPy时，这是一个常见的概念难题。通常，Python中的数据处理最好用迭代器来表示，以保持较低的内存使用量，最大程度地提高与I / O系统并行的机会，并提供算法的重用和组合。

但是NumPy将所有事情都彻底搞清楚了：最好的方法是将算法表示为全数组操作序列，以最小化在慢速Python解释器中花费的时间，并最大化在快速编译的NumPy例程中花费的时间。

这是我采用的一般方法：

1. 保留该函数的原始版本（您确信该函数是正确的），以便可以针对改进的版本对它的正确性和速度进行测试。

2. 由内而外地工作：即从最里面的循环开始，看是否可以向量化；然后，完成此操作后，移出一个级别并继续。

3. 花大量时间阅读NumPy文档。那里有很多功能和操作，而且它们的名称并不总是很漂亮，因此有必要了解它们。尤其是，如果您发现自己在想：“如果只有某项功能如此某某地完成”，那么花十分钟寻找它就值得了。通常在某个地方。

练习无可替代，因此，我将举例说明一些问题。每个问题的目标是重写函数，使其完全矢量化：也就是说，它由整个数组上的一系列NumPy操作组成，没有本地Python循环（没有for或while语句，没有迭代器或理解）。

问题1

def sumproducts(x, y):
    """Return the sum of x[i] * y[j] for all pairs of indices i, j.

    >>> sumproducts(np.arange(3000), np.arange(3000))
    20236502250000

    """
    result = 0
    for i in range(len(x)):
        for j in range(len(y)):
            result += x[i] * y[j]
    return result

问题2

def countlower(x, y):
    """Return the number of pairs i, j such that x[i] < y[j].

    >>> countlower(np.arange(0, 200, 2), np.arange(40, 140))
    4500

    """
    result = 0
    for i in range(len(x)):
        for j in range(len(y)):
            if x[i] < y[j]:
                result += 1
    return result

问题3

def cleanup(x, missing=-1, value=0):
    """Return an array that's the same as x, except that where x ==
    missing, it has value instead.

    >>> cleanup(np.arange(-3, 3), value=10)
    ... # doctest: +NORMALIZE_WHITESPACE
    array([-3, -2, 10, 0, 1, 2])

    """
    result = []
    for i in range(len(x)):
        if x[i] == missing:
            result.append(value)
        else:
            result.append(x[i])
    return np.array(result)

扰流板如下。如果您在研究我的解决方案之前一意孤行，将会获得最好的结果！

答案1

np.sum（x）* np.sum（y）

答案2

np.sum（np.searchsorted（np.sort（x），y​​））

答案3

np.where（x ==缺失，值，x）

为了使事情更快，您必须仔细阅读数据结构并使用适当的数据结构。

对于小数组和大数组的非平凡大小（假设small = 100元素和big = 10.000元素），一种方法是对小数组进行排序，然后遍历大数组并使用二进制搜索来找到匹配的元素在小阵列中。

这将使最大时间复杂度为O（N log N）（对于小的小型数组和非常大的大型数组，它更接近O（N）），其中嵌套循环解为O（N ^ 2）

然而。哪种数据结构最有效，很大程度上取决于实际问题。

您可以使用字典来显着优化性能

这是另一个示例：

locations = {}
for i in range(len(airports)):
    locations[airports["abb"][i][1:-1]] = (airports["height"][i], airports["width"][i])

for i in range(len(uniqueData)):
    h, w = locations[uniqueData["dept_apt"][i]]
    uniqueData["dept_apt_height"][i] = h
    uniqueData["dept_apt_width"][i] = w