pandas concat 生成 nan 值

Question

我很好奇为什么要在 pandas 中简单地串联两个数据帧：

initId.shape                # (66441, 1)
initId.isnull().sum()       # 0

ypred.shape                 # (66441, 1)
ypred.isnull().sum()        # 0

形状相同且都没有 NaN 值

foo = pd.concat([initId, ypred], join='outer', axis=1)
foo.shape                   # (83384, 2)
foo.isnull().sum()          # 16943

如果连接可能会导致很多 NaN 值。

如何解决此问题并防止引入 NaN 值？ 尝试重现它就像

aaa  = pd.DataFrame([0,1,0,1,0,0], columns=['prediction'])
bbb  = pd.DataFrame([0,0,1,0,1,1], columns=['groundTruth'])
pd.concat([aaa, bbb], axis=1)

失败，例如工作得很好，因为没有引入 NaN 值。

Answer 1

我认为不同的索引值存在问题，因此

concat

无法对齐的地方得到

NaN

：

aaa  = pd.DataFrame([0,1,0,1,0,0], columns=['prediction'], index=[4,5,8,7,10,12])
print(aaa)
    prediction
4            0
5            1
8            0
7            1
10           0
12           0

bbb  = pd.DataFrame([0,0,1,0,1,1], columns=['groundTruth'])
print(bbb)
   groundTruth
0            0
1            0
2            1
3            0
4            1
5            1

print (pd.concat([aaa, bbb], axis=1))
    prediction  groundTruth
0          NaN          0.0
1          NaN          0.0
2          NaN          1.0
3          NaN          0.0
4          0.0          1.0
5          1.0          1.0
7          1.0          NaN
8          0.0          NaN
10         0.0          NaN
12         0.0          NaN

如果不需要索引值，解决方案是

reset_index

：

aaa.reset_index(drop=True, inplace=True)
bbb.reset_index(drop=True, inplace=True)

print(aaa)
   prediction
0           0
1           1
2           0
3           1
4           0
5           0

print(bbb)
   groundTruth
0            0
1            0
2            1
3            0
4            1
5            1

print (pd.concat([aaa, bbb], axis=1))
   prediction  groundTruth
0           0            0
1           1            0
2           0            1
3           1            0
4           0            1
5           0            1

编辑：如果需要像

aaa

一样的索引并且数据帧的长度相同，请使用：

bbb.index = aaa.index
print (pd.concat([aaa, bbb], axis=1))
    prediction  groundTruth
4            0            0
5            1            0
8            0            1
7            1            0
10           0            1
12           0            1

Answer 2

你可以这样做：

concatenated_dataframes = concat(
    [
        dataframe_1.reset_index(drop=True),
        dataframe_2.reset_index(drop=True),
        dataframe_3.reset_index(drop=True)
    ],
    axis=1,
    ignore_index=True,
)

concatenated_dataframes_columns = [
    list(dataframe_1.columns),
    list(dataframe_2.columns),
    list(dataframe_3.columns)
]
    
flatten = lambda nested_lists: [item for sublist in nested_lists for item in sublist]

concatenated_dataframes.columns = flatten(concatenated_dataframes_columns)

连接多个

DataFrame

并保留列名称/避免

NaN

。

Answer 3

正如jezrael指出的，这是由于索引标签不同造成的。

concat

在索引上匹配，所以如果它们不相同，就会出现这个问题。对于简单的水平串联，您必须“强制”索引标签相同。一种方法是通过

set_axis

方法。这使得第二个数据帧索引与第一个数据帧索引相同。

joined_df = pd.concat([df1, df2.set_axis(df1.index)], axis=1)

或者只是重置两个帧的索引

joined_df = pd.concat([df1.reset_index(drop=True), df2.reset_index(drop=True)], axis=1)

Answer 4

如果数据帧具有相同的行数，您可以转置原始数据帧，然后按行连接以避免索引问题。如果您有很多数据帧需要连接，这种方法将会很有用。

dataframes_list = [df1, df2, df3]
dataframes_list_transposed = [list_item.transpose() for list_item in dataframes_list]
merged_dataframe = pd.concat(dataframes_list_transposed, axis=0).transpose()