小编tri*_*ook的帖子

有一个相对简单的代码块,它循环遍历两个数组,相乘并累加:

import numpy as np

a = np.array([1, 2, 4, 6, 7, 8, 9, 11])
b = np.array([0.01, 0.2, 0.03, 0.1, 0.1, 0.6, 0.5, 0.9])
c = []
d = 0
for i, val in enumerate(a):
    d += val
    c.append(d)
    d *= b[i]

有没有办法在没有迭代的情况下做到这一点？我想可以使用cumsum/cumprod,但我无法弄清楚如何.当你逐步分解正在发生的事情时,它看起来像这样:

# 0: 0 + a[0]
# 1: ((0 + a[0]) * b[0]) + a[1]
# 2: ((((0 + a[0]) * b[0]) + a[1]) * b[1]) + a[2]

编辑澄清:我对列表(或数组)感兴趣c.

以下代码在Python 2和Python 3中的行为有所不同,我不确定原因.

class Dataset(object):
    def __getattr__(self, item):
        if not item in dir(self):
            print(item)

a = Dataset()
a.Hello

Python 3中的结果:

> Hello

Python 2中的结果:

__members__
__members__
__methods__
...

无限制地直到达到递归上限."dir"的行为有什么不同？

编辑:有解决方法吗？自.dict是显而易见的选择,但它不包括在我的代码中成为问题的函数.

我编写了一些代码,找到树枝状流网络中给定覆盖范围上游的所有路径.例如,如果我代表以下网络:

     4 -- 5 -- 8
    / 
   2 --- 6 - 9 -- 10
  /           \ 
 1              -- 11
  \
   3 ----7

作为一组父子对:

{(11, 9), (10, 9), (9, 6), (6, 2), (8, 5), (5, 4), (4, 2), (2, 1), (3, 1), (7, 3)}

它将返回节点上游的所有路径,例如:

get_paths(h, 1)  # edited, had 11 instead of 1 in before
[[Reach(2), Reach(6), Reach(9), Reach(11)], [Reach(2), Reach(6), Reach(9), Reach(10)], [Reach(2), Reach(4), Reach(5), Reach(8)], [Reach(3), Reach(7)]]

代码包含在下面.

我的问题是:我将这个应用于一个非常大的(例如,新英格兰)地区的每个范围,任何给定的范围可能有数百万条路径.可能没有办法避免这是一个非常长的操作,但有没有一种pythonic方式来执行此操作,以便每次运行都不会生成全新的路径？

例如,如果我运行get_paths(h,2)并找到2上游的所有路径,我以后可以运行get_paths(h,1)而不回溯2中的所有路径吗？

import collections

# Object representing a stream reach. …

看似简单的问题:我有一个包含两列的数组,第一列表示ID,第二列表示计数.我想用另一个类似的数组来更新它

import numpy as np

a = np.array([[1, 2],
              [2, 2],
              [3, 1],
              [4, 5]])

b = np.array([[2, 2],
              [3, 1],
              [4, 0],
              [5, 3]])

a.update(b)  # ????
>>> np.array([[1, 2],
              [2, 4],
              [3, 2],
              [4, 5],
              [5, 3]])

有没有办法用索引/切片来做到这一点,这样我不必简单地迭代每一行？

我有一个像这样的数组:

a = np.array([0.1, 0.2, 1.0, 1.0, 1.0, 0.9, 0.6, 1.0, 0.0, 1.0])

我想有一个运行计数器的1.0实例是当它遇到0.0重置,这样的结果将是:

[0, 0, 1, 2, 3, 3, 3, 4, 0, 1]

我最初的想法是使用类似b = np.cumsum(a [a == 1.0])的东西,但我不知道如何(1)修改它以重置为零或(2)如何构造它所以输出数组与输入数组的形状相同.有没有想法如何做到这一点没有迭代？

我有很大的一组键/值对（200k +），为此我需要检索非常大（有时是全部）的值。显而易见的方法是使用这样的字典：

 values = {lookup.get(key) for key in key_set}

这在我的代码中变得非常耗时，并且我想知道是否存在一种更快的方法来使用NumPy数组来实现。我一直在尝试使用具有两列和n行的数组，这样对于任何单个键：

value = lookup_array[lookup_array[:,0] == key, 1]

但是我不确定如何在不进行昂贵的迭代的情况下将其扩展到很多键。我看了看：

values = lookup_array[np.in1d(lookup_array[:,0], key_set), 1]

但这似乎也很耗时。

还有其他方法可以快速进行大量非连续值的查找而不进行迭代吗？

是否可以在 @jit(nopython=True) 函数中创建 NPDatetime 对象？据我所知，初始化这些对象需要使用字符串对象，这似乎阻止了 nopython 函数的编译。

我需要创建一个10,000 x 50的数组,其中每行包含1到365之间的递增系列随机数,如下所示:

[[  4  11  14 ..., 355 360 364]
 [  2  13  15 ..., 356 361 361]
 [  4  12  18 ..., 356 361 365]
 ..., 
 [  6   9  17 ..., 356 362 364]
 [  1  10  19 ..., 352 357 360]
 [  1   9  17 ..., 356 358 364]]

我想通过迭代器来解决这个问题的唯一方法:

sample_dates = np.array([np.sort(np.random.choice(365, 50, replace=False)) for _ in range(10000)])

哪个有效,但速度相当慢(运行时间约为0.33秒),而且我将要这样做数千次).有没有更快的方法来实现这一目标？

编辑:据我所知,这个解决方案中最昂贵的部分是迭代和对np.random.choice的10k个别调用,而不是排序

我有一个带有土地覆盖等级和状态的站点表。我有另一个表，其中的值链接到class和state。但是，在第二个表中，某些行仅链接到class：

sites = pd.DataFrame({'id': ['a', 'b', 'c'],
                      'class': [1, 2, 23],
                      'state': ['al', 'ar', 'wy']})

values = pd.DataFrame({'class': [1, 1, 2, 2, 23],
                       'state': ['al', 'ar', 'al', 'ar', None],
                       'val': [10, 11, 12, 13, 16]})

我想按class和state链接表，除了值表中state为 None 的那些行，在这种情况下，它们只能按class链接。

合并具有以下结果：

combined = sites.merge(values, how='left', on=['class', 'state'])

  id  class state   val
0  a      1    al  10.0
1  b      2    ar  13.0
2  c     23 …

我有一个1d阵列,零点分散在各处.想创建一个包含最后一个零位的第二个数组,如下所示:

>>> a = np.array([1, 0, 3, 2, 0, 3, 5, 8, 0, 7, 12])
>>> foo(a)
[0, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3]

是否有内置的NumPy函数或广播技巧来执行此操作而不使用for循环或其他迭代器？