Pandas 拼接

Pandas 中的拼接操作将一个 DataFrame 追加到另一个 DataFrame 的一个轴上。它的工作方式类似于 SQL UNION ALL 操作。

我们使用 concat() 方法在 Pandas 中拼接两个或多个 DataFrame。例如，

import pandas as pd

# create dataframes
df1 = pd.DataFrame({'A': ['A0', 'A1'],
                    'B': ['B0', 'B1']},
                    index=[0, 1])

df2 = pd.DataFrame({'A': ['A2', 'A3'],
                    'B': ['B2', 'B3']},
                    index=[2, 3])

# concatenate two dataframes
result = pd.concat([df1, df2])

print(result)

输出

    A   B
0  A0  B0
1  A1  B1
2  A2  B2
3  A3  B3

在此示例中，我们创建了两个 DataFrame (df1 和 df2) 并将它们垂直堆叠 (沿轴 0)。

concat() 语法

Pandas 中 concat() 方法的语法是

pd.concat(objs, axis=0, join='outer', ignore_index=False, keys=None, levels=None, names=None, verify_integrity=False, sort=False, copy=True)

这里，

• objs: Series 或 DataFrame 对象的序列
• axis (可选): 要拼接的轴
• join (可选): 要执行的连接类型
• ignore_index (可选): 如果为 True，它将不使用拼接轴上的索引值，并将生成默认的整数索引
• keys (可选): 用于使用传递的键作为最外层来构建分层索引
• verify_integrity (可选): 如果为 True，它会检查新拼接的轴是否包含重复项，如果发现重复项则引发 ValueError
• sort (可选): 如果非拼接轴未对齐，则对其进行排序

示例：带参数的 concat()

让我们来看一个关于 ignore_index 和 sort 等参数的示例。

import pandas as pd

# create dataframes
df1 = pd.DataFrame({'Name': ['John', 'Alice', 'Bob'],
                    'Age': [25, 30, 35],
                    'City': ['New York', 'Paris', 'London']})

df2 = pd.DataFrame({'Name': ['Emily', 'Michael', 'Sophia', 'Rita'],
                    'Age': [28, 32, 27, 22],
                    'City': ['Berlin', 'Tokyo', 'Sydney', 'Delhi']})

# concatenate dataframes while ignoring index
result_ignore_index = pd.concat([df1, df2], ignore_index = True)

# concatenate dataframes and sort the result
result_sort = pd.concat([df1, df2], sort = True)

# display the concatenated results
print('ignore_index = True\n', result_ignore_index)
print('\nsort = True\n', result_sort)

输出

ignore_index = True
       Name  Age      City
0     John   25  New York
1    Alice   30     Paris
2      Bob   35    London
3    Emily   28    Berlin
4  Michael   32     Tokyo
5   Sophia   27    Sydney
6     Rita   22     Delhi

sort = True
   Age      City     Name
0   25  New York     John
1   30     Paris    Alice
2   35    London      Bob
0   28    Berlin    Emily
1   32     Tokyo  Michael
2   27    Sydney   Sophia
3   22     Delhi     Rita

在此示例中，我们在 concat() 方法中使用了 ignore_index 和 sort 参数。

当 ignore_index 设置为 True 时，将忽略各个 DataFrame 的索引值，并在生成的 DataFrame 中使用新的索引值。

当 sort 设置为 True 时，非拼接轴 (在此情况下为轴 0) 将按字母顺序排序。因此，在生成的 DataFrame 中，列会根据其名称按字母顺序排序。

沿轴 1 拼接

通过指定 axis=1，我们可以沿列 (水平) 拼接。例如，

import pandas as pd

# create dataframes
df1 = pd.DataFrame({'Name': ['John', 'Alice', 'Bob'],
                    'Age': [25, 30, 35],
                    'City': ['New York', 'Paris', 'London']})

df2 = pd.DataFrame({'Name': ['Emily', 'Michael', 'Sophia', 'Rita'],
                    'Age': [28, 32, 27, 22],
                    'City': ['Berlin', 'Tokyo', 'Sydney', 'Delhi']})

# concatenate dataframes along axis 1
result = pd.concat([df1, df2], axis=1)

print(result)

输出

    Name   Age      City     Name  Age    City
0   John  25.0  New York    Emily   28  Berlin
1  Alice  30.0     Paris  Michael   32   Tokyo
2    Bob  35.0    London   Sophia   27  Sydney
3    NaN   NaN       NaN     Rita   22   Delhi

在这里，我们将两个 DataFrame df1 和 df2 沿水平轴进行了拼接。

默认情况下，在沿轴 1 拼接 DataFrame 时会执行外连接。这意味着它会返回一个包含来自两个原始 DataFrame 的所有行的 DFS。如果某行没有匹配项，则用 NaN 填充缺失值。

如果我们想返回一个仅包含两个原始 DataFrame 中具有匹配值的行的 DataFrame，则需要通过指定 join = 'inner' 来执行内连接。

示例：内连接与外连接

import pandas as pd

# create dataframes
df1 = pd.DataFrame({'Name': ['John', 'Alice', 'Bob'],
                    'Age': [25, 30, 35],
                    'City': ['New York', 'Paris', 'London']})

df2 = pd.DataFrame({'Name': ['Emily', 'Michael', 'Sophia', 'Rita'],
                    'Age': [28, 32, 27, 22],
                    'City': ['Berlin', 'Tokyo', 'Sydney', 'Delhi']})


# concatenate dataframes with outer join
result_outer = pd.concat([df1, df2], axis = 1)

# concatenate dataframes with inner join
result_inner = pd.concat([df1, df2], axis = 1, join = 'inner')

# display the concatenated results
print('Outer Join\n', result_outer)
print('\nInner Join\n', result_inner)

输出

Outer Join
    Name   Age      City     Name  Age    City
0   John  25.0  New York    Emily   28  Berlin
1  Alice  30.0     Paris  Michael   32   Tokyo
2    Bob  35.0    London   Sophia   27  Sydney
3    NaN   NaN       NaN     Rita   22   Delhi

Inner Join
    Name  Age      City     Name  Age    City
0   John   25  New York    Emily   28  Berlin
1  Alice   30     Paris  Michael   32   Tokyo
2    Bob   35    London   Sophia   27  Sydney

请注意，在外连接的情况下，会在空白处填充 NaN 值以包含 df2 的所有行。

而在内连接的情况下，没有匹配索引的行将被完全删除。

带键的拼接

当我们需要为生成的 DataFrame 添加一个额外的信息级别时，keys 参数特别有用。

当我们向 concat() 函数传递一个键列表时，Pandas 将创建一个新的分层索引级别。新的索引级别包含根据数据来源的信息。例如，

import pandas as pd

# create dataframes
df1 = pd.DataFrame({'Name': ['John', 'Alice', 'Bob'],
                    'Age': [25, 30, 35],
                    'City': ['New York', 'Paris', 'London']})

df2 = pd.DataFrame({'Name': ['Emily', 'Michael', 'Sophia', 'Rita'],
                    'Age': [28, 32, 27, 22],
                    'City': ['Berlin', 'Tokyo', 'Sydney', 'Delhi']})


# concatenate dataframes while ignoring index
result = pd.concat([df1, df2], keys = ['from_df1', 'from_df2'])

print(result)

输出

               Name  Age      City
from_df1 0     John   25  New York
         1    Alice   30     Paris
         2      Bob   35    London
from_df2 0    Emily   28    Berlin
         1  Michael   32     Tokyo
         2   Sophia   27    Sydney
         3     Rita   22     Delhi

在此示例中，我们传递了键列表 ['from_df1', 'from_df2']。

这在生成的 DataFrame 中创建了一个双层索引。索引的第一层是我们指定的键 ('from_df1' 和 'from_df2')，索引的第二层是 df1 和 df2 的原始索引。

此功能在数据的来源对于进一步的数据分析很重要时尤其有用。