在python中将1x1维数组列表转换为浮点列表

我有一份表格清单：

[array([ 3755.16235032]),
 array([ 3755.16235032]),
 array([ 3755.16235032]),
 array([ 3755.16235032])]

我想要一份表格清单：

[3755.16235032,
 3755.16235032,
 3755.16235032,
 3755.16235032]

---

第一个列表中的每个元素都是sci工具包学习回归器的结果。我想要第二种格式，这样我就可以绘制分类器的预测

使用

np.连接
以避免手动迭代：

my_list = [np.array([ 3755.16235032]),
 np.array([ 3755.16235032]),
 np.array([ 3755.16235032]),
 np.array([ 3755.16235032])]

new_list = np.concatenate(my_list).tolist()

>>> new_list
[3755.16235032, 3755.16235032, 3755.16235032, 3755.16235032]

基准：
根据评论中的广泛讨论，以下是我的基准：

my_list = [np.random.randn(1) for _ in range(100000)]

def concat_method(my_list=my_list):
    return np.concatenate(my_list).tolist()

def hstack_method(my_list=my_list):
    return np.hstack(my_list).tolist()

def flatten_method(my_list=my_list):
    return np.array(my_list).flatten().tolist()

def ravel_method(my_list=my_list):
    return np.array(my_list).ravel().tolist()

import timeit

>>> timeit.timeit(concat_method, number=100) / 100
0.025655772869977226
>>> timeit.timeit(hstack_method, number=100) / 100
0.1172302443100125
>>> timeit.timeit(ravel_method, number=100) / 100
0.041237239889997
>>> timeit.timeit(flatten_method, number=100) / 100
0.0412076849100049

使用
np.连接
以避免手动迭代：

my_list = [np.array([ 3755.16235032]),
 np.array([ 3755.16235032]),
 np.array([ 3755.16235032]),
 np.array([ 3755.16235032])]

new_list = np.concatenate(my_list).tolist()

>>> new_list
[3755.16235032, 3755.16235032, 3755.16235032, 3755.16235032]

基准：
根据评论中的广泛讨论，以下是我的基准：

my_list = [np.random.randn(1) for _ in range(100000)]

def concat_method(my_list=my_list):
    return np.concatenate(my_list).tolist()

def hstack_method(my_list=my_list):
    return np.hstack(my_list).tolist()

def flatten_method(my_list=my_list):
    return np.array(my_list).flatten().tolist()

def ravel_method(my_list=my_list):
    return np.array(my_list).ravel().tolist()

import timeit

>>> timeit.timeit(concat_method, number=100) / 100
0.025655772869977226
>>> timeit.timeit(hstack_method, number=100) / 100
0.1172302443100125
>>> timeit.timeit(ravel_method, number=100) / 100
0.041237239889997
>>> timeit.timeit(flatten_method, number=100) / 100
0.0412076849100049

只是另一种解决方案：给定
x
是您的输入
列表
，您可以使用NumPy中的
ravel（）
作为

xlst = list(np.array(x).ravel())
print (xlst)

或者您可以使用
flatte（）
作为

xlst = list(np.array(x).flatten())
print (xlst)

如果您只想将最终答案作为数组，则不需要将
列表
放在
=
之后。并且，如果您的输入
x
已经是numpy数组类型，请将
np.array（x.ravel（）
替换为
x.ravel（）

或者，正如上面的回答中已经提到的，您也可以使用
np.array（x）.flatten（）.tolist（）
和
np.array（x）.ravel（）.tolist（）来代替使用

本页列出的所有可能答案的时间分析灵感来自以下答案之一中的评论（感谢评论员）（由于格式问题，很容易将其放在这里而不是评论中）：

输出

10 loops, best of 3: 55.2 ms per loop
10 loops, best of 3: 155 ms per loop
100 loops, best of 3: 2.45 ms per loop
100 loops, best of 3: 2.29 ms per loop

只是另一种解决方案：给定
x
是您的输入
列表
，您可以使用NumPy中的
ravel（）
作为

xlst = list(np.array(x).ravel())
print (xlst)

或者您可以使用
flatte（）
作为

xlst = list(np.array(x).flatten())
print (xlst)

如果您只想将最终答案作为数组，则不需要将
列表
放在
=
之后。并且，如果您的输入
x
已经是numpy数组类型，请将
np.array（x.ravel（）
替换为
x.ravel（）

或者，正如上面的回答中已经提到的，您也可以使用
np.array（x）.flatten（）.tolist（）
和
np.array（x）.ravel（）.tolist（）来代替使用

本页列出的所有可能答案的时间分析灵感来自以下答案之一中的评论（感谢评论员）（由于格式问题，很容易将其放在这里而不是评论中）：

输出

10 loops, best of 3: 55.2 ms per loop
10 loops, best of 3: 155 ms per loop
100 loops, best of 3: 2.45 ms per loop
100 loops, best of 3: 2.29 ms per loop

使用
hstack

np.hstack(my_list).tolist()
Out[180]: [3755.16235032, 3755.16235032, 3755.16235032, 3755.16235032]

使用
hstack

np.hstack(my_list).tolist()
Out[180]: [3755.16235032, 3755.16235032, 3755.16235032, 3755.16235032]

[x[0]表示数组中的x]
？是否确实不希望它作为1D浮点数组而不是浮点列表？例如，你可以做
np.array（lst）.flatte（）
或
np.concatenate（lst）
来得到一个平面数组。（如果你真的想要一个列表，你也可以做
list（np.array（lst）.flatte（））
，它可能比listcomp稍快一些……但是对于N=4，谁在乎呢？
[x[0]对于数组中的x]
？您确定不希望它作为一个1D浮点数数组而不是浮点数列表吗？例如，你可以做
np.array（lst）.flatte（）
或
np.concatenate（lst）
来得到一个平面数组。（如果你真的想要一个列表，你也可以做
list（np.array（lst）.flatte（））
，它可能比listcomp稍快一些……但是对于N=4，谁在乎呢？），不是一个浮点数数组。我不知道为什么他想要这个，但是…不确定它是否比N=4的listcomp更好，但是，如果OP要使用numpy，至少它值得OP学习如何这样做。我实际上不知道。如果重要的话，我会
%timeit
。但如果这不重要，也可能不重要，
串联
可能更容易理解。（在我对这个问题的评论中，我把
flatte
放在
concatenate
之前的唯一原因是，这是我第一次想到的，而不是我认为它会更好……）你是对的，这可能并不重要。。。但我的好奇心征服了我（我知道你内心深处也渴望知道……）。在100000个阵列的列表中，
plant
需要约0.041秒，concat需要约0.026秒。这包括在这两种情况下都使用
tolist（）
转换为列表。现在你必须尝试从温家宝的回答中选择
hstack
，然后会有人来建议使用普通的
堆栈
，以及
重塑
。看看你自己陷入了什么样的境地。OP明确要求一个浮点列表，而不是一个浮点数组。我不知道为什么他想要这个，但是…不确定它是否比N=4的listcomp更好，但是，如果OP要使用numpy，至少它值得OP学习如何这样做。我实际上不知道。如果重要的话，我会
%timeit
。但如果这不重要，也可能不重要，
串联
可能更容易理解。（在我对这个问题的评论中，我把
flatte
放在
concatenate
之前的唯一原因是，这是我第一次想到的，而不是我认为它会更好……）你是对的，这可能并不重要。。。但我的好奇心征服了我（我知道你内心深处也渴望知道……）。在100000个阵列的列表中，
plant
需要约0.041秒，concat需要约0.026秒。这包括在这两种情况下都使用
tolist（）
转换为列表。现在你必须尝试从温家宝的回答中选择
hstack
，然后会有人来建议使用普通的
堆栈
，以及
重塑
。看看你自己陷入了什么。我认为我们时间安排的差异与以下事实有关：你的列表
x
是一个
np.array
的
np.array
，而我使用的是一个
np.array
s的列表。我也会在我的答案中加入我的基准。是我