Python 从numpy阵列列表构建熊猫数据帧

我想知道对于这个显而易见的任务，是否有一种简单的方法可以从numpy数组列表生成一个pandas数据帧，其中列就是数组。默认行为似乎是让数组成为行，我完全不明白为什么。下面是一个简单的例子：

names = ['data1', 'data2', 'data3']
data = [np.arange(10) for _ in names]
df = pd.DataFrame(data=data, columns=names)

这将给出一个错误，表示需要10列

如果我这样做

df = pd.DataFrame(data=data)

我得到了一个包含10列和3行的数据帧

考虑到向数据帧中追加行通常比追加列困难得多，我想知道这种行为，例如，假设我很快想在数据帧中放入第四个数据数组，我想将数据组织成列

df['data4'] = new_array

---

如何快速构建所需的数据帧？

有许多方法可以解决您的问题，但最简单的方法似乎是

df.T

（

T

是缩写）：

---

正如@MaxGhenis在评论中指出的那样，

from_items

。该链接建议改为使用_dict中的

，因此旧答案可以修改为：

pd.DataFrame.from_dict(dict(zip(names, data)))

--------------------------------------------------旧答案-------------------------------------------------------------

我将使用：

给

  data1  data2  data3
0      0      0      0
1      1      1      1
2      2      2      2
3      3      3      3
4      4      4      4
5      5      5      5
6      6      6      6
7      7      7      7
8      8      8      8
9      9      9      9

  data1  data2  data3  data4
0      0      0      0      1
1      1      1      1      2
2      2      2      2      3
3      3      3      3      4
4      4      4      4      5
5      5      5      5      6
6      6      6      6      7
7      7      7      7      8
8      8      8      8      9
9      9      9      9     10

这也应该比转置更快：

%timeit pd.DataFrame.from_items(zip(names, data))

1000个回路，最好为3个：每个回路281µs

1000个回路，最好为3个：每个回路730µs

添加第四列也相当简单：

df['data4'] = range(1, 11)

给

  data1  data2  data3
0      0      0      0
1      1      1      1
2      2      2      2
3      3      3      3
4      4      4      4
5      5      5      5
6      6      6      6
7      7      7      7
8      8      8      8
9      9      9      9

  data1  data2  data3  data4
0      0      0      0      1
1      1      1      1      2
2      2      2      2      3
3      3      3      3      4
4      4      4      4      5
5      5      5      5      6
6      6      6      6      7
7      7      7      7      8
8      8      8      8      9
9      9      9      9     10

正如@jezrael在评论中提到的，第三种选择是（注意：订单不保证）

时间：

%timeit pd.DataFrame(dict(zip(names, data)))

1000个回路，最好为3个：每个回路281µs

from_items
现在已不推荐使用。改为使用来自目录的
：

df = pd.DataFrame.from_dict({
  'data1': np.arange(10),
  'data2': np.arange(10),
  'data3': np.arange(10)
})

这将返回：

    data1   data2   data3
0   0   0   0
1   1   1   1
2   2   2   2
3   3   3   3
4   4   4   4
5   5   5   5
6   6   6   6
7   7   7   7
8   8   8   8
9   9   9   9

所以我首先将我的数据名声明为索引，然后转置..我看到了thx！不过，我不理解默认行为背后的逻辑。是的，这是一种方法。我对默认行为引发的断言错误感到惊讶。很好的替代方法可以是
pd.DataFrame（dict（zip（names，data）），columns=names）
是的，但有一个问题是
dict
-顺序不能保证，所以需要指定它。尝试将
data1
更改为
data7
以了解差异；）@jezrael，好的观点：）那么我将坚持使用from_items
版本。
from_items
已被弃用：@MaxGhenis:谢谢，我相应地更新了我的答案。
df = pd.DataFrame.from_dict({
  'data1': np.arange(10),
  'data2': np.arange(10),
  'data3': np.arange(10)
})

    data1   data2   data3
0   0   0   0
1   1   1   1
2   2   2   2
3   3   3   3
4   4   4   4
5   5   5   5
6   6   6   6
7   7   7   7
8   8   8   8
9   9   9   9