Python 如何在不复制的情况下从单个1D Numpy阵列构造熊猫数据帧

与我能找到的所有其他问题不同，我不想从同构Numpy数组创建数据帧，也不想将结构化数组转换为数据帧

我想要的是从每个列的单个1D Numpy数组创建一个数据帧。我尝试了明显的

数据帧（{“col”：nparray，“col”：nparray}）

，但它显示在我的配置文件的顶部，所以它一定做得很慢

据我所知，Pandas数据帧是在纯Python中实现的，其中每个列都有一个Numpy数组作为后盾，因此我认为有一种有效的方法来实现它

我实际上想做的是从Cython高效地填充数据帧。 Cython的MemoryView允许高效访问Numpy阵列。 所以我的策略是分配一个Numpy数组，用数据填充它，然后把它放在一个数据帧中

相反的方法效果很好，从数据帧创建memoryview。因此，如果有一种方法可以预先分配整个数据帧，然后将列传递给Cython，这也是可以接受的

cdef int32_t[:] data_in = df['data_in'].to_numpy(dtype="int32")

我的代码的概要文件的一部分如下所示，通过在最后创建数据帧，代码所做的一切都相形见绌

         1100546 function calls (1086282 primitive calls) in 4.345 seconds

   Ordered by: cumulative time

   ncalls  tottime  percall  cumtime  percall filename:lineno(function)
        1    0.000    0.000    4.345    4.345 profile:0(<code object <module> at 0x7f4e693d1c90, file "test.py", line 1>)
    445/1    0.029    0.000    4.344    4.344 :0(exec)
        1    0.006    0.006    4.344    4.344 test.py:1(<module>)
     1000    0.029    0.000    2.678    0.003 :0(run_df)
     1001    0.017    0.000    2.551    0.003 frame.py:378(__init__)
     1001    0.018    0.000    2.522    0.003 construction.py:170(init_dict)

---

我可以建议一列一列地添加这些列吗。这可能有助于提高效率。像这样比如说,

import numpy as np
import pandas as pd

df = pd.DataFrame()

col1 = np.array([1, 2, 3])
col2 = np.array([4, 5, 6])

df['col1'] = col1
df['col2'] = col2

如果您尝试使用

list（nparray）

来代替，则此功能会起作用。以下是一个通用示例：

import numpy as np
import pandas as pd

alpha = np.array ([1, 2, 3])
beta = np.array ([4, 5, 6])
gamma = np.array ([7, 8, 9])

dikt = {"Alpha" : list (alpha), "Beta" : list (beta), "Gamma":list (gamma)}

data_frame = pd.DataFrame (dikt)
print (data_frame)

---

我不认为这完全回答了这个问题，但它可能会有所帮助

1-当您直接从2D阵列初始化数据帧时，不会进行复制

2-你没有二维数组，你有一维数组，你如何从一维数组中得到二维数组而不进行复制，我不知道

要说明这些要点，请参见以下内容：

a = np.array([1,2,3])
b = np.array([4,5,6])
c = np.array((a,b))
df = pd.DataFrame(c)
a = np.array([1,2,3])
b = np.array([4,5,6])
c = np.array((a,b))
df = pd.DataFrame(c)

print(c)
[[1 2 3]
 [4 5 6]]

print(df)
   0  1  2
0  1  2  3
1  4  5  6

c[1,1]=10
print(df)
   0   1  2
0  1   2  3
1  4  10  6

---

所以，改变c确实改变了df。但是，如果您尝试更改a或b，则不会影响c（或df）。

您确定数据帧可以使用1D numpy数组的“不规则”数组操作吗？如果它在引擎盖下使用2D阵列，我认为你不会绕过复制阵列。什么是“参差不齐”阵列？它不能在引擎盖下使用2D数组，因为数据帧是异构的，而numpy数组是同质的。不规则数组通常指不同长度的数组数组，但在本例中，我指的是一组不同的1D数组，它们不是作为单个2D数组存储的。Numpy还可以存储异构二维阵列，但它们仍然存储为单个二维阵列。您可以将其视为C中的结构数组。您是否可以预构建

数据帧

，即使用

索引

和

列

，以满足您的需要和填充值（例如

NaN

），然后遍历数组并将它们放在正确的位置？@Pepijn每列中的数据是否为单个

dtype

？如果是这样，那么只需将每个列创建为一个具有自己填充值的

pd.Series

，并将它们组合起来，或者在使用

fill

创建后将

pd.DataFrame

列转换为相应的

dtypes

？我对此投了更高的票，因为我认为这是正确的（数据帧由2D数组支持，因此当然，如果不进行复制，就无法从1D数组构建数据帧），因为这是试图解决这个问题的唯一答案。

pandas.DataFrame ({"col": nparray, "col": nparray})

import numpy as np
import pandas as pd

alpha = np.array ([1, 2, 3])
beta = np.array ([4, 5, 6])
gamma = np.array ([7, 8, 9])

dikt = {"Alpha" : list (alpha), "Beta" : list (beta), "Gamma":list (gamma)}

data_frame = pd.DataFrame (dikt)
print (data_frame)

a = np.array([1,2,3])
b = np.array([4,5,6])
c = np.array((a,b))
df = pd.DataFrame(c)
a = np.array([1,2,3])
b = np.array([4,5,6])
c = np.array((a,b))
df = pd.DataFrame(c)

print(c)
[[1 2 3]
 [4 5 6]]

print(df)
   0  1  2
0  1  2  3
1  4  5  6

c[1,1]=10
print(df)
   0   1  2
0  1   2  3
1  4  10  6