相关疑难解决方法(0)

如何从一组列表中获取笛卡尔积(每种可能的值组合)？

输入:

somelists = [
   [1, 2, 3],
   ['a', 'b'],
   [4, 5]
]

期望的输出:

[(1, 'a', 4), (1, 'a', 5), (1, 'b', 4), (1, 'b', 5), (2, 'a', 4), (2, 'a', 5) ...]

我有两个numpy数组,定义网格的x和y轴.例如:

x = numpy.array([1,2,3])
y = numpy.array([4,5])

我想生成这些数组的笛卡尔积来生成:

array([[1,4],[2,4],[3,4],[1,5],[2,5],[3,5]])

在某种程度上,由于我需要在循环中多次执行此操作,因此效率不高.我假设将它们转换为Python列表并使用itertools.product并返回到numpy数组并不是最有效的形式.

我有以下DataFrame,其中一列是一个对象(列表类型单元格):

df=pd.DataFrame({'A':[1,2],'B':[[1,2],[1,2]]})
df
Out[458]: 
   A       B
0  1  [1, 2]
1  2  [1, 2]

我的预期输出是:

   A  B
0  1  1
1  1  2
3  2  1
4  2  2

我该怎么做才能做到这一点？

相关问题

pandas:当单元格内容是列表时,为列表中的每个元素创建一行

好的问题和答案,但只处理一列列表(在我的回答中,自我修复功能将适用于多列,也接受的答案是使用最耗时apply,不推荐,检查更多信息我应该什么时候想要在我的代码中使用pandas apply()？)

我想为numpy 实现itertools.combinations.根据这个讨论,我有一个适用于一维输入的功能:

def combs(a, r):
    """
    Return successive r-length combinations of elements in the array a.
    Should produce the same output as array(list(combinations(a, r))), but 
    faster.
    """
    a = asarray(a)
    dt = dtype([('', a.dtype)]*r)
    b = fromiter(combinations(a, r), dt)
    return b.view(a.dtype).reshape(-1, r)

并且输出有意义:

In [1]: list(combinations([1,2,3], 2))
Out[1]: [(1, 2), (1, 3), (2, 3)]

In [2]: array(list(combinations([1,2,3], 2)))
Out[2]: 
array([[1, 2],
       [1, 3],
       [2, 3]])

In [3]: combs([1,2,3], 2)
Out[3]: 
array([[1, 2],
       [1, 3],
       [2, 3]]) …

假设我有三个任意1D数组,例如:

x_p = np.array((1.0, 2.0, 3.0, 4.0, 5.0))
y_p = np.array((2.0, 3.0, 4.0))
z_p = np.array((8.0, 9.0))

这三个数组表示3D网格中的采样间隔,我想为所有交叉点构建三维向量的一维数组,类似于

points = np.array([[1.0, 2.0, 8.0],
                   [1.0, 2.0, 9.0],
                   [1.0, 3.0, 8.0],
                   ...
                   [5.0, 4.0, 9.0]])

订单实际上并不重要.生成它们的明显方法:

npoints = len(x_p) * len(y_p) * len(z_p)
points = np.zeros((npoints, 3))
i = 0
for x in x_p:
    for y in y_p:
        for z in z_p:
            points[i, :] = (x, y, z)
            i += 1

所以问题是......有更快的方法吗？我看了但没找到(可能只是找不到合适的Google关键字).

我目前正在使用这个:

npoints = len(x_p) * len(y_p) * len(z_p)
points = …

我使用itertools.product生成长度为13的4个元素的所有可能变体.4和13可以是任意的,但实际上,我得到4 ^ 13个结果,这是很多.我需要将结果作为Numpy数组,目前执行以下操作:

  c = it.product([1,-1,np.complex(0,1), np.complex(0,-1)], repeat=length)
  sendbuf = np.array(list(c))

有一些简单的分析代码介于两者之间,看起来第一行几乎是瞬时的,而转换为列表然后Numpy数组需要大约3个小时.有没有办法让这更快？这可能是我忽视的非常明显的事情.

谢谢!

我认为这是一个常见的组合问题,但我似乎无法找到它的名称或任何有关它的材料.我在Python和numpy中这样做,但如果有一个快速矩阵方法,我可以翻译.

基本上,给定n个项目,我需要生成所有方法将它们放入m个箱子中.举个例子,将4个项目合并为3个区域会产生类似的结果[(4, 0, 0), (3, 1, 0), (3, 0, 1), (2, 2, 0), (2, 1, 1), ...].这是一个固定总额的产品.

使用itertools实现这一点非常简单.

import itertools

def fixed_total_product(bins, num_items):
""" Return iterator of all item binning possibilities. """
return itertools.ifilter(lambda combo: sum(combo) == num_items,
                         itertools.product(xrange(num_items + 1), repeat=bins))

不幸的是,我认为在循环中进行后续计算将是低效的.使用它作为2D numpy数组稍后会更快,但我无法找到一种有效的方法来构建一个数组.我可以遍历ifilter结果,构建一个可能性列表,并使用它来构建数组,但这似乎是一个巨大的浪费.

我猜这样做的最好方法是建立一切"笨拙的方式",但我不知道该怎么做.stackoverflow上有一个快速的产品实现:使用numpy构建两个数组的所有组合的数组.我猜你可以修改它只是输出正确总和的产品.数组的大小应该是((m-1)+ n)选择n,因为有m-1个bin边界.

有任何想法吗？基准非常感谢,但不是必需的.

我有一个Pandas数据框,它有两个关键列,我想确保表中存在这些键的笛卡尔积(因为我必须制作一个包含所有组合的2D图).我无法想出一个相当简短和惯用的方法来做到这一点.

例如,我从这张表开始,给出水果和蔬菜的组合,以及它们如何一起品尝:

   combo   fruit      veg
0  tasty   apple   carrot
1  yucky  banana   carrot
2  tasty  banana  lettuce
3  yucky   lemon  lettuce

我想最终得到所有可能组合的表:

    fruit      veg    combo
0   apple   carrot    tasty
1   apple  lettuce  UNKNOWN
2  banana   carrot    yucky
3  banana  lettuce    tasty
4   lemon   carrot  UNKNOWN
5   lemon  lettuce    yucky

这是我发现的最佳方式:

import pandas as pd

# Initial data
df=pd.DataFrame(dict(fruit=['apple','banana','banana','lemon'],
                     veg=['carrot','carrot','lettuce','lettuce'],
                     combo=['tasty','yucky','tasty','yucky']))

# Solution starts here
veg=df.groupby('veg').size().reset_index()
fruit=df.groupby('fruit').size().reset_index()
fruit[0] = veg[0] = 0    #use this dummy column for the join to work! …

在Python中使用numpy生成所有组合的数组有几个优雅的例子.例如答案:使用numpy构建两个数组的所有组合的数组.

现在假设存在一个额外的约束,即所有数字的总和不能超过给定的常数K.使用生成器itertools.product,例如K=3我们想要三个变量的组合,范围为0-1,0-3和0-2,我们可以这样做:

from itertools import product
K = 3
maxRange = np.array([1,3,2])
states = np.array([i for i in product(*(range(i+1) for i in maxRange)) if sum(i)<=K])

返回

array([[0, 0, 0],
       [0, 0, 1],
       [0, 0, 2],
       [0, 1, 0],
       [0, 1, 1],
       [0, 1, 2],
       [0, 2, 0],
       [0, 2, 1],
       [0, 3, 0],
       [1, 0, 0],
       [1, 0, 1],
       [1, 0, 2],
       [1, 1, 0],
       [1, 1, 1],
       [1, 2, 0]])

原则上,来自 …

我知道itertools.product迭代关键字的几个维度列表.例如,如果我有这个:

categories = [
    [ 'A', 'B', 'C', 'D'],
    [ 'E', 'F', 'G', 'H'],
    [ 'I', 'J', 'K', 'L']
]

我使用itertools.product()它,我有类似的东西:

>>> [ x for x in itertools.product(*categories) ]
('A', 'E', 'I'),
('A', 'E', 'J'),
('A', 'E', 'K'),
('A', 'E', 'L'),
('A', 'F', 'I'),
('A', 'F', 'J'),
# and so on...

是否有一种与numpy数组做同样事情的等效,直接的方法？