Code - pandas知识点练习

from string import printable
import pandas as pd
import numpy as np
from sympy import primenu

Series 核心概念与操作

Series 是带标签的一维数组，可理解为“单列表格”，包含两个部分：

- values：数据本身（可是数值、字符串、布尔值等）；

- index：标签（默认是 0、1、2... 整数索引，也可自定义）。

1. 创建 Series（默认整数索引）

s1 = pd.Series([10, 20, 30, 40])
print("默认索引的 Series：")
print(s1) ## 输出包含 index 和 values，dtype 是数据类型（此处为 int64）

2. 自定义索引

s2 = pd.Series([10, 20, 30, 40, 50], index=["a", "b", "c", "d", "e"])
print("n自定义索引的 Series：")
print(s2)

3. 从字典创建 Series（字典的键作为索引，值作为数据）

dict_data = {"香蕉": 3.5, "苹果": 2.5, "橙子": 3.3}
s3 = pd.Series(dict_data)
print(s3)

4. 访问 Series 数据

print(s3["香蕉"]) # 按索引访问 #3.5
print(s3.iloc[1]) # 按位置访问 #2.5
print(s3.head(3)) # 前3行

5. Series 基本属性

print(s3.index) # 获取索引
print(s3.values) # 获取值 返回Numpy
print(s3.dtype) # 获取值类型
print(len(s3)) # 获取长度

DataFrame 核心概念与操作

DataFrame 是带标签的二维表格数据结构，可理解为“Excel 工作表”，包含：

- 行索引（index）：每行的标签；

- 列索引（columns）：每列的标签；

- 数据（values）：表格中的具体内容。

1. 从字典创建 DataFrame（字典的键为列名，值为列数据）

data = {

"姓名": ["张三", "李四", "王五", "赵六"],
"年龄": [22, 25, 23, 24],
"性别": ["男", "男", "女", "男"],
"薪资": [8000, 9500, 8800, 10000],

}

df = pd.DataFrame(data)
print("默认索引的 DataFrame：")
print(df)

2. 自定义行索引

df2 = pd.DataFrame(data, index=["员工1", "员工2", "员工3", "员工4"])
print(df2)

3. 从列表嵌套列表创建 DataFrame（需指定列名）

list_data = [

["张三", 22, "男", 8000],
["李四", 25, "男", 9500],
["王五", 23, "女", 8800],

]
df3 = pd.DataFrame(list_data, columns=["姓名", "年龄", "性别", "薪资"])

4. DataFrame 基本属性

print(df2.index) # 获取行索引
print(df2.columns) # 获取列索引
print(df2.values) # 获取数据

5. 访问列数据（两种方式）

print("n访问 '薪资' 列（方式1）：")
print(df2["薪资"]) # 返回 Series 类型
print("访问 '姓名' 列（方式2，仅列名无空格时可用）：")
print(df2.姓名)

CSV 文件读写（最常用）

读取 CSV

csvdf = pd.read_csv("test.csv", encoding="utf-8")

print("读取的 CSV 数据：")

print(csvdf.head())

示例2：读取无表头的 CSV，指定列名

df_no_header = pd.read_csv(

"no_header_data.csv",

header=None,

names=["姓名", "年龄", "性别", "薪资"],

encoding="gbk",

)

print("n无表头 CSV 读取结果：")

print(df_no_header)

写入 CSV

df2.to_csv(

"output_employee.csv", index=False, encoding="utf-8", na_rep="未知" # 不写入行索引

)

查看与探索数据（head, info, describe 等）

ndata = {

"订单ID": [1001, 1002, 1003, 1004, 1005, 1006, 1007, 1008],
"用户ID": [1, 2, 1, 3, 2, 3, 4, 4],
"商品类别": [
    "家电",
    "服饰",
    "家电",
    "食品",
    "服饰",
    "食品",
    "家电",
    np.nan,
],  # np.nan 表示缺失值
"订单金额": [2999, 599, 1299, 89, 799, 159, 3499, 1999],
"订单日期": [
    "2026-01-01",
    "2026-01-02",
    "2026-01-02",
    "2026-01-03",
    "2026-01-03",
    "2026-01-04",
    "2026-01-04",
    "2026-01-05",
],
"支付状态": [
    "已支付",
    "已支付",
    "未支付",
    "已支付",
    "已支付",
    "未支付",
    "已支付",
    "已支付",
],

}
df = pd.DataFrame(ndata)

查看数据前/后几行（head/tail）

print("前 3 行数据：")
print(df.head(3))
print("n后 2 行数据：")
print(df.tail(2))

查看数据基本信息（info）

print(df.info())

查看数值型数据统计特征（describe）

print("数值型数据统计特征：")
print(df.describe())

统计所有列（包括字符串列）的唯一值数量、最频繁值等

print("n所有列的统计特征：")
print(

df.describe(include="all")

) # 无字符串列统计：默认仅统计数值型列，需指定 include="all" 才会包含字符串列。

查看缺失值与唯一值

print("每列缺失值数量：")
print(df.isnull().sum())

2. 查看每列唯一值数量（nunique()）

print("n每列唯一值数量：")
print(df.nunique())

3. 查看指定列的唯一值（unique()）

print("n商品类别唯一值：")
print(df["商品类别"].unique())

4. 查看指定列唯一值的计数（value_counts()）

print("n各商品类别订单数量：")
print(df["商品类别"].value_counts()) # 忽略缺失值，默认按计数降序排列

查看数据形状与列名

查看数据形状（行数, 列数）

print("数据形状：", df.shape) # 输出 (8,6)

查看列名

print("列名列表：", df.columns.tolist()) # 转为列表格式，便于后续处理

查看行索引

print("行索引：", df.index.tolist())

索引与选择（loc, iloc, 条件筛选）

按标签选择（loc）

loc 基于行索引标签和列名选择数据，语法：df.loc[行标签, 列名]，支持单个标签、标签列表、切片（包含终点）。

沿用第4章的订单数据，先自定义行索引（便于演示标签选择）

df = pd.DataFrame(

{
    "订单ID": [1001, 1002, 1003, 1004, 1005],
    "商品类别": ["家电", "服饰", "家电", "食品", "服饰"],
    "订单金额": [2999, 599, 1299, 89, 799],
    "支付状态": ["已支付", "已支付", "未支付", "已支付", "已支付"],
},
index=["订单1", "订单2", "订单3", "订单4", "订单5"],

) # 自定义行标签

print("选择 '订单2' 行：")
print(df.loc["订单2"])

2. 选择多个行（标签列表）

print("n选择 '订单1' 和 '订单4' 行：")
print(df.loc[["订单1", "订单4"]])

3. 选择行切片（包含起点和终点）

print("n选择 '订单2' 到 '订单4' 行：")
print(df.loc["订单2":"订单4"])

4. 选择指定行和列（行标签+列名）

print("n选择 '订单1' 和 '订单3' 的 '商品类别' 和 '订单金额' 列：")
print(df.loc[:, ["商品类别", "订单金额"]])

按位置选择（iloc）

iloc 基于行位置和列位置选择数据（类似 Python 列表切片），语法：df.iloc[行位置, 列位置]，位置从 0 开始，切片不包含终点。

1. 选择单个行（按位置）

print("选择第 2 行（位置 1）：")
print(df.iloc[1])

2. 选择多个行（位置列表）

print("n选择第 1 行和第 4 行（位置 0 和 3）：")
print(df.iloc[[0, 3]])

3. 选择行切片（不包含终点）

print("n选择第 2 行到第 4 行（位置 1 到 3，终点 4 不包含）：")
print(df.iloc[1:4])

4. 选择指定行和列（位置组合）

print("n选择第 1、3 行（位置 0、2）的第 2、3 列（位置 1、2）：")
print(df.iloc[[0, 2], [1, 2]])

5. 选择所有行，前 2 列

print("n选择所有行的前 2 列：")
print(df.iloc[:, :2])

条件筛选

沿用订单数据

df = pd.DataFrame(

{
    "订单ID": [1001, 1002, 1003, 1004, 1005],
    "商品类别": ["家电", "服饰", "家电", "食品", "服饰"],
    "订单金额": [2999, 599, 1299, 89, 799],
    "支付状态": ["已支付", "已支付", "未支付", "已支付", "已支付"],
}

)

1. 单个条件筛选

筛选订单金额 > 1000 的行

df_high = df[df["订单金额"] > 1000]

筛选商品类别为 "家电" 的行

df_elect = df[df["商品类别"] == "家电"]
print("n商品类别为家电的数据：")
print(df_elect)

2. 多个条件筛选（& 表示且，| 表示或，条件需用 () 包裹）

筛选家电类且金额 > 2000 的行

df_elect_high = df[(df["商品类别"] == "家电") & (df["订单金额"] > 2000)]
print("n家电类且金额 > 2000 的数据：")
print(df_elect_high)

筛选服饰类或未支付的行

df_cloth_unpaid = df[(df["商品类别"] == "服饰") | (df["支付状态"] == "未支付")]
print("n服饰类或未支付的数据：")
print(df_cloth_unpaid)

3. isin() 筛选（属于某个列表中的值）

筛选商品类别为家电或食品的行

df_filter = df[df["商品类别"].isin(["家电", "食品"])]
print("n商品类别为家电或食品的数据：")
print(df_filter)

缺失值处理方法

1. 查看每列缺失值数量

df = pd.DataFrame(

{
    "订单ID": [1001, 1002, 1003, 1004, 1005],
    "商品类别": ["家电", "服饰", "家电", "食品", np.nan],
    "订单金额": [2999, 599, np.nan, 89, 799],
    "支付状态": ["已支付", "已支付", "未支付", np.nan, "已支付"],
}

)

print(df.isna().sum())

2. 查看含缺失值的行

print("n含缺失值的行：")
print(df[df.isna().any(axis=1)])

方法1：删除缺失值（dropna()）

1.1 删除含任何缺失值的行（默认 axis=0，how="any"）

df_drop_any = df.dropna()
print("删除含任何缺失值的行：")
print(df_drop_any)

仅删除所有列都缺失的行

df_dorp_all = df.dropna(how="all")

按列删除缺失值

df_drop_col = df.dropna(axis=1, thresh=3)

指定列删除

df_drop_set_col = df.dropna(subset=["订单金额"])
print(df_drop_set_col)

方法2：填充缺失值（fillna()）

2.1 用固定值填充

df_fill_fixed = df.fillna(1)

2.2 用均值/中位数填充数值型缺失值

df_fill_mean = df.copy()
df_fill_mean["订单金额"] = df_fill_mean["订单金额"].fillna(

df_fill_mean["订单金额"].mean()

)
print(df_fill_mean)

中位数

df_fill_mean["订单金额"] = df_fill_mean["订单金额"].fillna(

df_fill_mean["订单金额"].median()

)
df_fill_ffill = df.copy()

2.3 用前一个值/后一个值填充（ffill/bfill）

df_fill_ffill["支付状态"] = df_fill_ffill[

"支付状态"

].ffill() # ffill：forward fill，前向填
print(df_fill_ffill)

df_fill_ffill["支付状态"] = df_fill_ffill[

"支付状态"

].bfill() # bfill：backward fill，后向填充，前向填
print(df_fill_ffill)

重复值处理

模拟含重复值的数据

df = pd.DataFrame(

{
    "姓名": ["张三", "李四", "张三", "赵六", "李四"],
    "年龄": [22, 25, 22, 24, 25],
    "薪资": [8000, 9500, 8000, 10000, 9500],
    "部门": ["技术", "销售", "技术", "技术", "销售"],
}

)

识别重复行

print(df.duplicated())

2. 查看重复行

print(df[df.duplicated()])

3. 删除重复行（drop_duplicates()）

3.1 保留第一行，删除后续重复行（默认）

df_drop_duplicates = df.drop_duplicates()
print(df_drop_duplicates)

3.2 保留最后一行，删除前面重复行

df_drop_dup_last = df.drop_duplicates(keep="last")
print("n删除重复行（保留最后一行）：")
print(df_drop_dup_last)

3.3 按指定列判断重复（仅这些列值相同即为重复）

df_drop_dup_col = df.drop_duplicates(subset=["姓名", "部门"], keep="first")
print("n按姓名和部门判断重复并删除：")
print(df_drop_dup_col)
df.drop_duplicates(subset=["姓名"], keep="first")

6.3 数据类型转换

模拟数据类型不规范的数据

df = pd.DataFrame(

{
    "订单ID": [1001, 1002, 1003],
    "订单金额": ["2999", "599", "1299"],  # 字符串类型的数值
    "订单日期": ["2026-01-01", "2026-01-02", "2026-01-03"],  # 字符串类型的日期
    "支付状态": [1, 1, 0],  # 数值类型的布尔值（1=已支付，0=未支付）
}

)

print(df.dtypes)

2. 转换数据类型

2.1 字符串转数值（astype()）

df["订单金额"] = df["订单金额"].astype(float)
print(df.dtypes)

2.2 数值转布尔值

df["支付状态"] = df["支付状态"].astype(bool)
print(df.dtypes)

2.3 字符串转日期（to_datetime()，核心方法）

df["订单日期"] = pd.to_datetime(df["订单日期"])
print(df.dtypes)

3. 处理转换失败的情况（errors参数）

df_error = pd.DataFrame({"数值列": ["100", "200", "abc", "300"]})

直接转换会报错，用 errors="coerce" 将无法转换的值设为 np.nan

df_error["数值列"] = pd.to_numeric(df_error["数值列"], errors="coerce")
print("n处理转换失败的数据：")
print(df_error)

数据变换（新增列、apply、map、字符串/日期处理）

模拟数据

df = pd.DataFrame(

{
    "商品名": ["A", "B", "C", "D"],
    "单价": [100, 200, 150, 300],
    "销量": [50, 30, 40, 25],
    "成本": [60, 120, 90, 180],
}

)

1. 基于现有列计算新增列

新增“销售额”列（单价 * 销量）

df["销售额"] = df["单价"] * df["销量"]

新增“利润”列（销售额 - 成本 * 销量）

df["利润"] = df["销售额"] - (df["成本"] * df["销量"])
df["利润率"] = (df["利润"] / df["销售额"]).round(4)
print("新增列后的数据：")
print(df)

2. 条件赋值新增列

新增“销量等级”列：销量>40为“A级”，20-40为“B级”，<20为“C级”

df["销量等级"] = pd.cut(

df["销量"],
bins=[0, 20, 40, 100],  # 区间边界
labels=["C级", "B级", "A级"],  # 区间对应标签
right=True,  # 左闭右开区间（如 [0,20) 为 C级）

)
print("n条件赋值新增列：")
print(df[["商品名", "销量", "销量等级"]])

3. 直接赋值新增列（固定值或列表）

df["品牌"] = "XX品牌" # 固定值
df["批次"] = ["202601", "202601", "202602", "202602"] # 列表（长度需与行数一致）
print("n直接赋值新增列：")
print(df[["商品名", "品牌", "批次"]])

apply 与 map 方法

apply 用于对行/列执行自定义函数，map 用于对 Series 元素执行映射（一对一转换），是灵活处理数据的核心工具。

df = pd.DataFrame(

{
    "商品名": ["A", "B", "C", "D"],
    "类别": ["家电", "服饰", "家电", "食品"],
    "销量": [50, 30, 40, 25],
}

)

1. 字典映射（替换值）

将“类别”列映射为中文全称

category_map = {"家电": "家用电器", "服饰": "服装鞋帽", "食品": "生鲜食品"}
df["类别全称"] = df["类别"].map(category_map)

df["类别全称"] = df["类别"].map(category_map)

2. 函数映射

对“销量”列进行标准化（(销量 - 最小值) / (最大值 - 最小值)）

def normalize_sales(x):

return (x - df["销量"].min()) / (df["销量"].max() - df["销量"].min())

df["销量标准化"] = df["销量"].map(normalize_sales)

print("map 方法处理后：")

print(df[["商品名", "类别", "类别全称", "销量", "销量标准化"]])

apply 方法（Series/DataFrame 均可）

df = pd.DataFrame(

{"单价": [100, 200, 150, 300], "销量": [50, 30, 40, 25], "成本": [60, 120, 90, 180]}

)

1. 对 Series 用 apply（与 map 类似，更灵活）

df["利润"] = (df["单价"] - df["成本"]) * df["销量"]

用 apply 判断利润等级

def profit_level(profit):

if profit > 2000:
    return "高利润"
elif profit > 1000:
    return "中利润"
else:
    return "低利润"

df["利润等级"] = df["利润"].apply(profit_level)

2. 对 DataFrame 用 apply（按行/列执行函数）

按列执行（默认 axis=0）：计算每列的最大值

col_max = df.apply(lambda x: x.max(), axis=0)
print("每列最大值：")
print(col_max)

按行执行（axis=1）：计算每行的“单价+成本”总和

df["单价成本和"] = df.apply(lambda x: x["单价"] + x["成本"], axis=1)
print(df)

字符串处理

pandas 为字符串列提供了 str 访问器，支持大小写转换、替换、分割、提取等常用操作，无需循环遍历元素。

模拟含字符串数据

df = pd.DataFrame(

{
    "商品名": ["Apple-手机", "banana-耳机", "Xiaomi-电视", "华为-平板"],
    "备注": [" 新品上架  ", "促销活动！", "限时折扣~~", "库存充足"],
    "规格": ["128G", "无线款", "55英寸", "11英寸"],
}

)

1. 去除空格与特殊字符

df["备注_清理"] = df["备注"].str.strip() # 去除首尾空格
df["备注_无符号"] = df["备注_清理"].str.replace(

r"[！~]", "", regex=True

) # 正则替换特殊字符

2.字符串分割

按 "-" 分割商品名，提取品牌和品类

df[["品牌", "品类"]] = df["商品名"].str.split(

"-", expand=True

) # expand=True 返回 DataFrame

3字符串匹配和提取

判断商品名是否包含字母

df["含字母"] = df["商品名"].str.contains(r"[a-zA-Z]", regex=True)

从规格中提取数字

df["规格数值"] = df["规格"].str.extract(r"(d+)", expand=False) # 提取第一个数字

4. 大小写转换

df["品牌大写"] = df["品牌"].str.upper() # 转大写
df["品类小写"] = df["品类"].str.lower() # 转大写
print("字符串处理后的数据：")
print(df[["商品名", "品牌", "品类", "备注", "备注_无符号", "规格数值"]])

日期时间处理

将日期列转为datetime64 类型后，可通过 dt 访问器提取时间特征、计算时间差，满足时间序列分析需求。

模拟日期数据

df = pd.DataFrame(

{
    "订单ID": [1001, 1002, 1003, 1004],
    "下单时间": [
        "2026-01-01 09:30:00",
        "2026-01-02 14:15:00",
        "2026-01-03 10:00:00",
        "2026-01-05 16:45:00",
    ],
    "发货时间": [
        "2026-01-01 18:00:00",
        "2026-01-03 08:30:00",
        "2026-01-03 16:00:00",
        "2026-01-06 10:10:00",
    ],
}

)

1. 转换为日期时间类型

df["下单时间"] = pd.to_datetime(df["下单时间"])
df["发货时间"] = pd.to_datetime(df["发货时间"])

2.提取时间特征

df["下单日期"] = df["下单时间"].dt.date
df["下单小时"] = df["下单时间"].dt.hour
df["星期几"] = df["下单时间"].dt.day_name()
df["是否周末"] = df["下单时间"].dt.dayofweek.isin([5, 6])

3.计算时间差

df["发货时长（小时）"] = (df["发货时间"] - df["下单时间"]).dt.total_seconds() / 3600

4. 日期偏移与过滤

df["预计送达时间"] = df["发货时间"] + pd.Timedelta(days=2)

筛选1月2日及以后下单的订单

df_jan2 = df[df["下单时间"] >= pd.Timestamp("2026-01-02")]
print(df_jan2)

数据聚合与分组（groupby、pivot_table）

模拟销售数据

df = pd.DataFrame(

{
    "部门": [
        "技术部",
        "销售部",
        "技术部",
        "销售部",
        "技术部",
        "人事部",
        "销售部",
        "人事部",
    ],
    "姓名": ["张三", "李四", "王五", "赵六", "孙七", "周八", "吴九", "郑十"],
    "薪资": [8000, 9500, 8800, 10000, 9200, 7500, 11000, 7800],
    "绩效": [85, 92, 88, 95, 90, 82, 98, 86],
}

)

1. 按单列分组，计算单个指标

按“部门”分组，计算薪资均值

salary_mean = df.groupby("部门")["薪资"].mean()
print(salary_mean)

2. 按单列分组，计算多个指标

按“部门”分组，计算薪资的均值、最大值、最小值

dept_salary_stats = df.groupby("部门")["薪资"].agg(["mean", "max", "min"])
dept_salary_stats.columns = ["薪资均值", "薪资最高", "薪资最低"] # 重命名列
print(dept_salary_stats)

3. 按单列分组，对多列计算不同指标

dept_multi_stats = df.groupby("部门").agg({"薪资": "mean", "绩效": "sum"})

4. 按多列分组

按“部门”和“性别”分组（新增性别列）

df["性别"] = ["男", "男", "女", "男", "女", "女", "男", "女"]
dept_gender_stats = df.groupby(["部门", "性别"])["薪资"].mean()
print(dept_gender_stats)

重置索引（将分组标签转为列）

dept_gender_stats_reset = dept_gender_stats.reset_index()
print("n重置索引后：")
print(dept_gender_stats_reset)

高级用法（自定义聚合函数）

df = pd.DataFrame(

{
    "部门": ["技术部", "销售部", "技术部", "销售部", "技术部"],
    "薪资": [8000, 9500, 8800, 10000, 9200],
    "绩效": [85, 92, 88, 95, 90],
}

)

def salary_perf_product_mean(group):

product = group["薪资"] * group["绩效"]
return product.mean()

按部门分组应用自定义函数

dept_custom_stats = df.groupby("部门").apply(salary_perf_product_mean)

结合 agg 应用多个自定义函数

def range_calc(series):

return series.max() - series.min()  # 计算极差

dept_multi_custom = df.groupby("部门")["薪资"].agg([range_calc, "mean"])
dept_multi_custom.columns = ["薪资极差", "薪资均值"]

pivot_table 透视表

沿用销售数据，新增“入职年份”列

df = pd.DataFrame(

{
    "部门": [
        "技术部",
        "销售部",
        "技术部",
        "销售部",
        "技术部",
        "人事部",
        "销售部",
        "人事部",
    ],
    "性别": ["男", "男", "女", "男", "女", "女", "男", "女"],
    "入职年份": [2023, 2022, 2023, 2021, 2022, 2023, 2022, 2021],
    "薪资": [8000, 9500, 8800, 10000, 9200, 7500, 11000, 7800],
    "绩效": [85, 92, 88, 95, 90, 82, 98, 86],
}

)

1. 基础透视表：行=部门，列=性别，值=薪资，聚合函数=均值

pivot1 = pd.pivot_table(

df,
index="部门",  # 行维度
columns="性别",  # 列维度
values="薪资",  # 聚合值
aggfunc="mean",  # 聚合函数

)

print(pivot1)

数据合并与连接

实际数据分析中，数据常分散在多个表格中，需通过合并/连接操作整合为一张完整表格，pandas 提供 merge（按列连接）、concat（拼接）、join（按索引连接）三种核心方法

merge 按列连接（类似 SQL 连接）

merge 基于一个或多个共同列（键）连接两个 DataFrame，支持内连接、左连接、右连接、外连接四种类型，与 SQL 连接逻辑一致。

准备两个表格数据

员工基本信息表

df_emp = pd.DataFrame(

{
    "员工ID": [101, 102, 103, 104],
    "姓名": ["张三", "李四", "王五", "赵六"],
    "部门ID": [1, 2, 1, 3],
}

)

部门信息表

df_dept = pd.DataFrame(

{
    "部门ID": [1, 2, 3, 4],
    "部门名称": ["技术部", "销售部", "人事部", "财务部"],
    "部门经理": ["孙七", "周八", "吴九", "郑十"],
}

)

1. 内连接（默认 how="inner"）：只保留两个表中键值匹配的行

merge_inner = pd.merge(df_emp, df_dept, on="部门ID")
print("内连接结果：")
print(merge_inner)

2. 左连接（how="left"）：保留左表所有行，右表匹配不到的填充 NaN

merge_left = pd.merge(df_emp, df_dept, on="部门ID", how="left")
print("n左连接结果：")
print(merge_left)

4. 外连接（how="outer"）：保留两个表所有行，匹配不到的填充 NaN

merge_outer = pd.merge(df_emp, df_dept, on="部门ID", how="outer")
print("n外连接结果：")
print(merge_outer)

5. 按多列连接（键为多个列）

df1 = pd.DataFrame({"A": [1, 2], "B": [3, 4], "C": [5, 6]})
df2 = pd.DataFrame({"A": [1, 2], "B": [3, 5], "D": [7, 8]})
merge_multi_key = pd.merge(df1, df2, on=["A", "B"], how="inner")
print("n按多列内连接结果：")
print(merge_multi_key)

concat 拼接（上下/左右）

concat 用于沿指定轴拼接多个 DataFrame，无需共同键，支持上下拼接（axis=0，默认）和左右拼接（axis=1）。

准备拼接数据

df_a = pd.DataFrame(

{"员工ID": [101, 102], "姓名": ["张三", "李四"], "薪资": [8000, 9500]}

)

df_b = pd.DataFrame(

{"员工ID": [103, 104], "姓名": ["王五", "赵六"], "薪资": [8800, 10000]}

)

df_c = pd.DataFrame(

{"绩效": [85, 92, 88, 95], "入职年份": [2023, 2022, 2023, 2021]}, index=[0, 1, 2, 3]

)

1. 上下拼接（axis=0）：合并行，列需一致或部分一致

concat_rows = pd.concat([df_a, df_b], ignore_index=True) # ignore_index=True 重置行索引
print("上下拼接结果：")
print(concat_rows)

2. 左右拼接（axis=1）：合并列，按索引匹配行

concat_cols = pd.concat([concat_rows, df_c], axis=1)
print("n左右拼接结果：")
print(concat_cols)

3. 拼接时去重（join="inner"）：只保留索引/列匹配的部分

df_d = pd.DataFrame({"绩效": [85, 92]}, index=[0, 1])
concat_inner = pd.concat([df_a, df_d], axis=1, join="inner")
print("n内连接左右拼接结果：")
print(concat_inner)

4. 给拼接的数据添加来源标识

df_a["来源"] = "旧员工"
df_b["来源"] = "新员工"
concat_flag = pd.concat([df_a, df_b], ignore_index=True)
print("n带来源标识的拼接结果：")
print(concat_flag)