相关疑难解决方法(0)

我试图在6参数函数的参数空间上运行以研究它的数值行为,然后再尝试做任何复杂的事情,所以我正在寻找一种有效的方法来做到这一点.

给定6-dim numpy数组作为输入,我的函数采用浮点值.我最初尝试做的是:

首先,我创建了一个函数,它接受2个数组并生成一个数组,其中包含来自两个数组的所有值组合

from numpy import *
def comb(a,b):
    c = []
    for i in a:
        for j in b:
            c.append(r_[i,j])
    return c

然后我习惯reduce()将它应用于相同数组的m个副本:

def combs(a,m):
    return reduce(comb,[a]*m)

然后我评估我的功能如下:

values = combs(np.arange(0,1,0.1),6)
for val in values:
    print F(val)

这有效,但它太慢了.我知道参数的空间很大,但这不应该太慢.在这个例子中我只抽取了10 ⁶(一百万)个点,并且创建数组花了超过15秒values.

你知道用numpy做这个更有效的方法吗？

F如果有必要,我可以修改函数获取它的参数的方式.

我想要一个2d numpy数组(x,y)的列表,其中每个x在{-5,-4.5,-4,-3.5,...,3.5,4,4.5,5}中,并且对于y是相同的.

我可以

x = np.arange(-5, 5.1, 0.5)
y = np.arange(-5, 5.1, 0.5)

然后迭代所有可能的对,但我确信有一个更好的方式......

我希望回来看起来像:

[[-5, -5],
 [-5, -4.5],
 [-5, -4],
 ...
 [5, 5]]

但顺序并不重要.

这篇文章的内容最初是作为Pandas Merging 101的一部分,但由于完全公开 这个主题所需的内容的性质和大小,它已被转移到自己的QnA.

给出两个简单的DataFrame;

left = pd.DataFrame({'col1' : ['A', 'B', 'C'], 'col2' : [1, 2, 3]})
right = pd.DataFrame({'col1' : ['X', 'Y', 'Z'], 'col2' : [20, 30, 50]})

left

  col1  col2
0    A     1
1    B     2
2    C     3

right

  col1  col2
0    X    20
1    Y    30
2    Z    50

可以计算这些帧的叉积,看起来像:

A       1      X      20
A       1      Y      30
A       1      Z      50
B       2      X      20
B       2      Y      30
B       2      Z      50 …

我有以下熊猫数据框：

df = pd.DataFrame([
    ['A', 2017, 1],
    ['A', 2019, 1],
    ['B', 2017, 1],
    ['B', 2018, 1],
    ['C', 2016, 1],
    ['C', 2019, 1],
], columns=['ID', 'year', 'number'])

并且正在寻找最有效的方法来填充缺失的年份，该列的默认值为 0 number

预期的输出是：

  ID  year  number
0  A  2017       1
1  A  2018       0
2  A  2019       1
3  B  2017       1
4  B  2018       1
5  C  2016       1
6  C  2017       0
7  C  2018       0
8  C  2019       1

我拥有的数据框相对较大，因此我正在寻找一种有效的解决方案。

编辑：

这是我到目前为止的代码：

min_max_dict = df[['ID', 'year']].groupby('ID').agg([min, max]).to_dict('index')

new_ix = [[], …

我有 3 个 Pandas 数据框

df_a = pd.DataFrame(data={
  'id': [1, 5, 3, 2],
  'ts': [3, 5, 11, 14],
  'other_cols': ['...'] * 4
})

df_b = pd.DataFrame(data={
  'id': [2, 1, 3],
  'ts': [7, 8, 15],
  'other_cols': ['...'] * 3
})

df_c = pd.DataFrame(data={
  'id': [154, 237, 726, 814, 528, 237, 248, 514],
  'ts': [1, 2, 4, 6, 9, 10, 12, 13],
  'other_cols': ['...'] * 8
})

这是我需要解决的问题。

• 对于每个idindf_a找到相应的idindf_b及其时间戳。让我们假设ts_a和ts_b。 …

如果我有两个清单

l1 = [ 'A', 'B' ]

l2 = [ 1, 2 ]

获得pandas数据框的最优雅方式是什么,如下所示:

+-----+-----+-----+
|     | l1  | l2  |
+-----+-----+-----+
|  0  | A   | 1   |
+-----+-----+-----+
|  1  | A   | 2   |
+-----+-----+-----+
|  2  | B   | 1   |
+-----+-----+-----+
|  3  | B   | 2   |
+-----+-----+-----+

注意,第一列是索引.

我是python的新手,我正在努力形成多个列表的组合.所以,我有三个(可能更多)看起来像这样:

uk_rock_stars=[1,2,3,4,5,6,7,8,9]
uk_pop_stars=[10,11,12,13,1,4,6,22,81]
us_stars=[22,34,44,7,33,99,22,77,99]
.
.

所有相同长度的列表.现在,我想生成它们的组合列表,其中N是上面列表的总数.我正在寻找一个看起来像这样的结果:

comb=[(1,10,22),(1,10,34),(1,10,44)...etc (all combinations)....]

这样,每个组合,比如说(1,10,22)与原始列表的数量相同(在这种情况下为3)

这个问题基于这个较老的问题:

给定一个数组:

In [122]: arr = np.array([[1, 3, 7], [4, 9, 8]]); arr
Out[122]: 
array([[1, 3, 7],
       [4, 9, 8]])

Run Code Online (Sandbox Code Playgroud)

鉴于其指数:

In [127]: np.indices(arr.shape)
Out[127]: 
array([[[0, 0, 0],
        [1, 1, 1]],

       [[0, 1, 2],
        [0, 1, 2]]])

Run Code Online (Sandbox Code Playgroud)

我怎样才能将它们整齐地叠在一起形成一个新的2D阵列？这就是我想要的:

array([[0, 0, 1],
       [0, 1, 3],
       [0, 2, 7],
       [1, 0, 4],
       [1, 1, 9],
       [1, 2, 8]])

Run Code Online (Sandbox Code Playgroud)

Divakar的这个解决方案是我目前用于2D阵列的解决方案:

def indices_merged_arr(arr):
    m,n = arr.shape
    I,J = np.ogrid[:m,:n]
    out = np.empty((m,n,3), dtype=arr.dtype)
    out[...,0] = I
    out[...,1] = …

我有3个numpy阵列,需要在它们之间形成笛卡尔积.阵列的尺寸不固定,因此它们可以采用不同的值,一个例子可以是A =(10000,50),B =(40,50),C =(10000,50).

然后,我执行一些处理(如a + bc)以下是我用于产品的功能.

def cartesian_2d(arrays, out=None):

    arrays = [np.asarray(x) for x in arrays]
    dtype = arrays[0].dtype

    n = np.prod([x.shape[0] for x in arrays])
    if out is None:
        out = np.empty([n, len(arrays), arrays[0].shape[1]], dtype=dtype)

    m = n // arrays[0].shape[0]
    out[:, 0] = np.repeat(arrays[0], m, axis=0)
    if arrays[1:]:
        cartesian_2d(arrays[1:], out=out[0:m, 1:, :])
        for j in range(1, arrays[0].shape[0]):
            out[j * m:(j + 1) * m, 1:] = out[0:m, 1:]
    return out

a = [[ 0, -0.02], [1, -0.15]]
b …

我的代码使用如下列表的笛卡尔积：

import itertools

cartesian_product = itertools.product(list('ABCDEF'), repeat=n)

n可以是 0 到 4 之间的任意值。

numba目前不支持itertools.product. 到目前为止我还无法想出一个可行的替代方案。欢迎任何建议！