Python 如何从两个列表中创建列表

我正在努力完成以下任务，但迄今为止失败了。我有两个已排序的数字列表。说

A = [5.8, 6.5, 7.6, 14.5, 18.1, 25.7, 26.4, 30.7, 30.9, 33.6, 38.6, 38.8, 39.2]

B = [9.0, 13.5, 22.5, 32.3 40.6, 43.2, 47.9, 54.2, 60.3, 63.0]

我想列一张清单。每个列表都包含一个不同于B的值以及a中该B值与列表中紧靠它之前的值之间的所有值。第一个列表只包含小于B中第一个值的所有内容

所以在这种情况下，列表列表应该开始

[[5.8, 6.5, 7.6, 9.0], [13.5], [14.5, 18.1, 22.5], [25.7, 26.4, 30.7. 30.9, 32.3]....]

如果numpy代码更简单/更快，我会很高兴

我试过：

[[*a, b] for b, a in itertools.groupby(A, lambda x: next(filter(lambda y: y >= x, B)))]

但它漏掉了所有的单身者名单，我不确定它在任何情况下都有多快。

你可以这样做

将numpy导入为np
A=[5.8,6.5,7.6,14.5,18.1,25.7,26.4,30.7,30.9,33.6,38.6,38.8,39.2]
B=[9.0,13.5,22.5,32.3,40.6,43.2,47.9,54.2,60.3,63.0]
A=np.数组（A）
B=np.hstack（（[-np.inf]，B））
结果=[np.r_uu[np.extract（（A>B[i]）&（A

将numpy导入为np
A=[5.8,6.5,7.6,14.5,18.1,25.7,26.4,30.7,30.9,33.6,38.6,38.8,39.2]
B=[9.0,13.5,22.5,32.3,40.6,43.2,47.9,54.2,60.3,63.0]
A=np.数组（A）
B=np.hstack（（[-np.inf]，B））
result=[np.r_[np.extract（（A>B[i]）&（Ai）我会使用这样的两个指针

i = 0
j= 0
ans = [] #contains the lists of lists
while j<len(B):
    to_append = []
    while i<len(A) and A[i]<=B[j]:
         to_append.append(A[i])
         i=i+1
    to_append.append(B[j])
    ans.append(to_append)
    j=j+1


i=0
j=0
ans=[]#包含列表列表
而j我会使用这样的两个指针

i = 0
j= 0
ans = [] #contains the lists of lists
while j<len(B):
    to_append = []
    while i<len(A) and A[i]<=B[j]:
         to_append.append(A[i])
         i=i+1
    to_append.append(B[j])
    ans.append(to_append)
    j=j+1


i=0
j=0
ans=[]#包含列表列表
虽然j作为一种纯粹基于Numpy的方法（没有那么重要），您可以将列表转换为数组并执行以下操作：

In [43]: ind = (b[:,None] > a).sum(1)

In [44]: np.split(np.insert(a, ind, b), ind + np.arange(1, ind.size +1))
Out[44]: 
[array([5.8, 6.5, 7.6, 9. ]),
 array([13.5]),
 array([14.5, 18.1, 22.5]),
 array([25.7, 26.4, 30.7, 30.9, 32.3]),
 array([33.6, 38.6, 38.8, 39.2, 40.6]),
 array([43.2]),
 array([47.9]),
 array([54.2]),
 array([60.3]),
 array([63.]),
 array([], dtype=float64)]

作为一种纯粹基于Numpy的方法（没有那么重要），您可以将列表转换为数组并执行以下操作：

In [43]: ind = (b[:,None] > a).sum(1)

In [44]: np.split(np.insert(a, ind, b), ind + np.arange(1, ind.size +1))
Out[44]: 
[array([5.8, 6.5, 7.6, 9. ]),
 array([13.5]),
 array([14.5, 18.1, 22.5]),
 array([25.7, 26.4, 30.7, 30.9, 32.3]),
 array([33.6, 38.6, 38.8, 39.2, 40.6]),
 array([43.2]),
 array([47.9]),
 array([54.2]),
 array([60.3]),
 array([63.]),
 array([], dtype=float64)]

使用np.searchsorted在O（N*logN）时间内解决问题。
首先，从A中的B中找到元素的位置。接下来，使用这些位置拆分数组A。最后创建所需属性的列表

pos = np.searchsorted(A,B)
chunks = np.split(A, pos)
res = [np.hstack(ab) for ab in zip(chunks,B)]

这将生成所需的ndarray列表，您可以使用ndarray.tolist（）方法将其转换回列表：

使用np.searchsorted在O（N*logN）时间内解决问题。
首先，从A中的B中找到元素的位置。接下来，使用这些位置拆分数组A。最后创建所需属性的列表

pos = np.searchsorted(A,B)
chunks = np.split(A, pos)
res = [np.hstack(ab) for ab in zip(chunks,B)]

这将生成所需的ndarray列表，您可以使用ndarray.tolist（）方法将其转换回列表：

您可以对O（n+m）解决方案使用
heapq.merge
：

from itertools import chain, repeat
from heapq import merge

[*map(list, map(chain, map(iter, repeat(merge(A,B).__next__), B), zip(B)))]
# [[5.8, 6.5, 7.6, 9.0], [13.5], [14.5, 18.1, 22.5], [25.7, 26.4, 30.7, 30.9, 32.3], [33.6, 38.6, 38.8, 39.2, 40.6], [43.2], [47.9], [54.2], [60.3], [63.0]]

这使用
merge
按顺序合并A和B。接下来，iter的两个参数形式用于在B的元素处拆分。不幸的是，这会吃掉拆分点，因此我们使用itertools.chain重新连接它们。
对于O（n+m）解决方案，您可以使用
heapq.merge
：

from itertools import chain, repeat
from heapq import merge

[*map(list, map(chain, map(iter, repeat(merge(A,B).__next__), B), zip(B)))]
# [[5.8, 6.5, 7.6, 9.0], [13.5], [14.5, 18.1, 22.5], [25.7, 26.4, 30.7, 30.9, 32.3], [33.6, 38.6, 38.8, 39.2, 40.6], [43.2], [47.9], [54.2], [60.3], [63.0]]

这将使用
merge
按顺序合并A和B。接下来，iter的两个参数形式用于在B的元素处拆分。不幸的是，这会吃掉拆分点，因此我们使用itertools.chain重新连接它们。
到目前为止您尝试了什么？由于生成的列表长度不同，这不适合
numpy
。只需使用列出操作。在这个阶段不要担心速度。首先，我只是在
b
上迭代，从
a
收集相关值。不要尝试任何花哨的事情。这看起来不容易“矢量化”事实上，所有的列表都是锯齿状的，所以这是另一个问题。如果你真的想让它在NUMPY中工作，考虑写一个C扩展。到目前为止你尝试了什么？因为结果列表的长度不同，这与<代码> NoMPy < /代码>不太合适。只需使用列表操作。不用担心。关于这个阶段的速度。首先，我只是在
b
上迭代，从
a
收集相关值。不要尝试任何花哨的东西。这看起来不容易“矢量化”事实上，所有的列表都是锯齿状的，所以这是另一个问题。如果你真的想让它在NUMPY中工作，考虑写一个C扩展。这会产生很多空数组。[数组（[]，dType = FLUAT64），数组（[5.8，6.5，7.6 ]），数组（[]，dType = FLUAT64）答案应该像[[5.8,6.5,7.6,9.0]，[13.5]，[14.5,18.1,22.5]，[25.7,26.4,30.7.30.9,32.3]…]你的答案有两行
结果
行。第一行给出：[array（[-inf]），array（[-inf]），array（[5.8,6.5,7.6,9]），array（[13.5]），array（[13.5]）），etcIt工作得很好，也许你没有复制它吧！是的！谢谢你。这会创建很多空数组。[数组（[]，dtype=float64），数组（[5.8,6.5,7.6]），数组（[]，dtype=float64），等等。不应该有空列表。答案应该像[[5.8,6.5,7.6,9.0]，[13.5]，[14.5,18.1,22.5]，[25.7,26.4,30.30.9,32.3]…]您的答案有两行
result
行。第一行给出：[array（[-inf]）、array（[-inf]）、array（[5.8,6.5,7.6,9.]）、array（[13.5]），etcIt工作得很好，也许你没有复制它吧！是的！谢谢你。至少在这个例子中，这个列表方法比
numpy
方法快得多。在b
中使用
代替
j
迭代，这将运行得更快。我还尝试用
中的迭代器替换
I
迭代>国际热核实验堆（A）
或生成器，但到目前为止还没有成功。这只是普通的逻辑。我相信我们也可以将其矢量化。我会尝试一下，并在今天晚些时候添加一个编辑。这非常好而且干净。至少在这个示例中，此列表方法比
numpy
方法快得多。使用
代替
j
迭代。我还尝试用
iter（A）
上的迭代器或生成器替换
I
迭代，但迄今为止没有成功。这只是普通的逻辑。我相信我们也可以将其矢量化。我今天晚些时候会尝试并添加一个编辑。这非常好而且干净。这非常好。这非常好。