pandas数据分析（一）

原创

Anabelle 2024-06-22 14:14:33 ©著作权

©著作权归作者所有：来自51CTO博客作者Anabelle的原创作品，请联系作者获取转载授权，否则将追究法律责任

一、生成数据表

1.1.文件读取

1.1.1.导入Excel文件

首先导入pandas库，一般都会用到numpy库先导入，导入CSV或者xlsx文件：

import numpy as np
import pandas as pd

# 读取 Excel 文件，从第 4 行开始（跳过前 3 行），只读取第 B 列到第 E 列
df1 = pd.DataFrame(pd.read_excel('零售订单数据.xlsx', sheet_name='orderinfo', skiprows=3, usecols='B:E'))
print(df1)

这段代码使用了 pandas 库中的 read_excel 函数来读取 Excel 文件 '零售订单数据.xlsx' 中的特定工作表 'orderinfo'。以下是参数的作用和含义：

'零售订单数据.xlsx'：这是要读取的 Excel 文件的文件名。
sheet_name='orderinfo'：指定要读取的工作表的名称为 'orderinfo'。如果 Excel 文件中有多个工作表，可以通过这个参数选择要读取的工作表。如果不指定 sheet_name，默认会读取第一个工作表。
skiprows=3：跳过前面的 3 行数据。在这个例子中，从第四行开始读取数据（因为索引是从0开始计算的）。
usecols='B:E'：指定要读取的列范围，从 B 列到 E 列。这意味着只有 B、C、D、E 四列的数据会被读取，而不会读取其他列的数据。

1.1.2.导入csv文件

pandas读取csv文件语法：

import pandas as pd

# 示例 CSV 文件路径
csv_file_path = 'data.csv'

# 读取 CSV 文件
df = pd.read_csv(csv_file_path, sep=',', header=0, names=None, index_col=None, skiprows=0, usecols=None, dtype=None, parse_dates=None, na_values=None)

# 打印数据框
print(df)

read_csv 函数的常用参数及其说明：

filepath_or_buffer:

文件路径或 URL。
例子：'data.csv'，'http://example.com/data.csv'

sep:

指定分隔符。
默认值是逗号（,）。
例子：sep=','，sep='\t'（制表符）

header:

指定哪一行作为列名。
默认是 header=0，即第一行作为列名。
例子：header=0，header=None（无列名）

names:

指定列名。
例子：names=['A', 'B', 'C']

index_col:

指定哪一列作为行索引。
默认值是 None。
例子：index_col=0

skiprows:

跳过前几行数据。
例子：skiprows=3（跳过前 3 行）

usecols:

指定要读取的列。
例子：usecols=['A', 'B'] 或 usecols=[0, 1]

dtype:

指定列的数据类型。
例子：dtype={'A': int, 'B': float}

parse_dates:

解析日期列。
例子：parse_dates=['date']

na_values:

指定哪些值被视为缺失值（NaN）。
例子：na_values=['NA', '?']

读取指定的 CSV 文件，并将其内容加载到一个 pandas DataFrame 中：

import numpy as np
import pandas as pd

# 示例 CSV 文件路径
csv_file_path = 'large_sample_data.csv'

# 导入CSV文件：
df = pd.DataFrame(pd.read_csv(csv_file_path, sep=',', header=1, encoding='utf-8'))
print(df)

1.2.用pandas创建数据表

上一个章节已经说过了，就不在赘述了：

import numpy as np
import pandas as pd

df = pd.DataFrame({"id": [1001, 1002, 1003, 1004, 1005, 1006],
                   "date": pd.date_range('20130102', periods=6),
                   "city": ['Beijing ', 'SH', ' guangzhou ', 'Shenzhen', 'shanghai', 'BEIJING '],
                   "age": [23, 44, 54, 32, 34, 32],
                   "category": ['100-A', '100-B', '110-A', '110-C', '210-A', '130-F'],
                   "price": [1200, np.nan, 2133, 5433, np.nan, 4432]},
                  columns=['id', 'date', 'city', 'category', 'age', 'price'])

"""
     id       date         city category  age   price
0  1001 2013-01-02     Beijing     100-A   23  1200.0
1  1002 2013-01-03           SH    100-B   44     NaN
2  1003 2013-01-04   guangzhou     110-A   54  2133.0
3  1004 2013-01-05     Shenzhen    110-C   32  5433.0
4  1005 2013-01-06     shanghai    210-A   34     NaN
5  1006 2013-01-07     BEIJING     130-F   32  4432.0
"""

二、数据表信息查看

数据表信息查询如下：

维度查看：
数据表基本信息（维度、列名称、数据格式、所占空间等）：
每一列数据的格式：
某一列格式：
空值：
查看某一列空值：
查看某一列的唯一值：
查看数据表的值：
查看列名称：
查看前5行数据、后5行数据

示例代码如下：

import numpy as np
import pandas as pd

# 创建示例 DataFrame
data = {
    'A': [1, 2, 3, 4, 5],
    'B': [10, 20, 30, np.nan, 50],
    'C': ['a', 'b', 'c', 'd', 'e']
}
index = ['row1', 'row2', 'row3', 'row4', 'row5']

df = pd.DataFrame(data, index=index)

# 输出 DataFrame
print("DataFrame 示例:")
print(df)

# 1.查看维度
print("\nDataFrame 的维度:")
print(df.shape)  # (5, 3)

# 2. 查看数据表的基本信息
print("\nDataFrame 的基本信息:")
print(df.info())

# 3. 查看每一列数据的格式
print("\n每一列数据的格式:")
print(df.dtypes)

# 4. 查看某一列的数据格式
print("\n列 'A' 的数据格式:")
print(df['A'].dtype)

# 5. 查看每一列的空值数量
print("\n每一列的空值数量:")
print(df.isnull().sum())

# 6. 查看某一列的空值位置
print("\n列 'B' 的空值位置:")
print(df['B'].isnull())

# 7. 查看某一列的唯一值
print("\n列 'C' 的唯一值:")
print(df['C'].unique())

# 8. 查看 DataFrame 的所有值
print("\nDataFrame 的所有值:")
print(df.values)

# 9. 查看 DataFrame 的列名称
print("\nDataFrame 的列名称:")
print(df.columns)

# 10. 查看前5行数据
print("\nDataFrame 的前5行数据:")
print(df.head())

# 10. 查看后5行数据
print("\nDataFrame 的后5行数据:")
print(df.tail())

三、数据表清洗

利用pandas中数据表清洗，往往需要进行如下处理：

用数字0填充空值：

df.fillna(value=0)

使用列prince的均值对NA进行填充：

df['prince'].fillna(df['prince'].mean())

清除city字段的字符空格：

df['city']=df['city'].map(str.strip)

大小写转换：

df['city']=df['city'].str.lower()

更改数据格式：

df['price'].astype('int')

更改列名称：

df.rename(columns={'category': 'category-size'})

删除后出现的重复值：

df['city'].drop_duplicates()

删除先出现的重复值：

df['city'].drop_duplicates(keep='last')

数据替换：

# 替换单个值
df_replaced['city'] = df_replaced['city'].replace('Shanghai', 'sh')
# 同时替换多个值
df_replaced.replace({'city': {'Shanghai': 'sh', 'Shenzhen':'sz', 'Guangzhou': 'gz', 'Beijing':'bj'}}, inplace=True)

示例代码：

import numpy as np
import pandas as pd

# 创建示例 DataFrame
data = {
    'price': [10, np.nan, 30, 40, np.nan, 50],
    'city': ['  Shanghai', 'Beijing  ', 'Shenzhen', 'Guangzhou', 'Shanghai', 'sh'],
    'category': ['A', 'B', 'A', 'B', 'A', 'A']
}
index = ['row1', 'row2', 'row3', 'row4', 'row5', 'row6']

df = pd.DataFrame(data, index=index)

# 输出 DataFrame
print("DataFrame 示例:")
print(df)
"""
      price        city category
row1   10.0    Shanghai        A
row2    NaN   Beijing          B
row3   30.0    Shenzhen        A
row4   40.0   Guangzhou        B
row5    NaN    Shanghai        A
row6   50.0          sh        A
"""

# 1. 用数字0填充空值
# df_filled_with_zero = df.fillna(value=0)
# print("\n用数字0填充空值:")
# print(df_filled_with_zero)

# 2. 使用列 price 的均值对 NA 进行填充
df_filled_with_mean = df.copy()
# 将数据表df_filled_with_mean中price列中的缺失值（NaN）用该列的均值填充
df_filled_with_mean['price'] = df_filled_with_mean['price'].fillna(df_filled_with_mean['price'].mean())
"""
df_filled_with_mean['price']：选择数据表df_filled_with_mean中的price列。
df_filled_with_mean['price'].mean()：计算price列的均值。
df_filled_with_mean['price'].fillna(df_filled_with_mean['price'].mean())：将price列中的缺失值（NaN）用该列的均值填充。
"""
print("\n使用列 price 的均值对 NA 进行填充:")
print(df_filled_with_mean)

# 3. 清除 city 字段的字符空格
df_strip = df.copy()
"""
将数据表df_strip中city列中的每个元素（字符串）去除首尾空格，并更新到city列中
map方法常用于对列中的元素进行清洗、转换或处理，例如去除空格、转换数据类型、进行数值计算等操作
经过map方法处理后，会生成一个新的列，其中包含了每个元素经过函数处理后的结果。
"""
df_strip['city'] = df_strip['city'].map(str.strip)
print("\n清除 city 字段的字符空格:")
print(df_strip)

# 4. 大小写转换(两种写法均可)
df_lower = df.copy()
# df_lower['city'] = df_lower['city'].map(str.lower)
df_lower['city'] = df_lower['city'].str.lower()
print("\n将 city 字段转换为小写:")
print(df_lower)

# 5. 更改数据格式
df_format_change = df.fillna(value=0) # 先将NaN转换为0, 否则下面无法将price转换为int类型
# 将price列类型转换为int类型
df_format_change['price'] = df_format_change['price'].astype('int')
print("\n更改 price 列的数据格式为 int:")
print(df_format_change)

# 6. 更改列名称(将price改为price_new)
df_renamed = df.copy()
df_renamed.rename(columns={'price': 'price_new'}, inplace=True)
print("\n更改列名称:")
print(df_renamed)

# 7. 删除后面出现的重复值 (保留第一次出现的)
df_no_duplicates_last = df['category'].drop_duplicates()  # 指定删除category列中重复值 (保留第一次出现的)
print("\n删除后出现的重复值 (保留第一次出现的):")
print(df_no_duplicates_last)

# 8. 删除先出现的重复值 (保留最后一次出现的)
df_no_duplicates_first = df['category'].drop_duplicates(keep='last')
print("\n删除先出现的重复值 (保留最后一次出现的):")
print(df_no_duplicates_first)

# 9. 数据替换
df_replaced = df.copy()
# 先将city中值的左右空格去掉，否则后面替换会出现匹配出错
df_replaced['city'] = df_replaced['city'].map(str.strip)
# 将Shanghai替换为sh, 可以同时替换多个值：df_replaced.replace({'city': {'Shanghai': 'sh', 'Shenzhen':'sz', 'Guangzhou': 'gz', 'Beijing':'bj'}}, inplace=True)
df_replaced.replace({'city': {'Shanghai': 'sh'}}, inplace=True)
print("\n数据替换 ('sh' 替换为 'shanghai'):")
print(df_replaced)

四、数据预处理

4.1.数据表合并

⑴.merge

作用: 使用一个或多个键（key）连接 DataFrame。这类似于 SQL 中的合并操作。
含义: 根据指定的列或索引进行连接，可以指定不同的连接方式（如内连接、左连接、右连接、外连接）。

import pandas as pd

# 示例数据 df
df = pd.DataFrame({"id": [1001, 1002, 1003, 1004],
                   "name": ['Alice', 'Bob', 'Charlie', 'David'],
                   "age": [25, 30, 35, 40]})

df1 = pd.DataFrame({"id": [1001, 1002, 1003, 1004, 1005, 1006, 1007, 1008],
                    "gender": ['male', 'female', 'male', 'female', 'male', 'female', 'male', 'female'],
                    "pay": ['Y', 'N', 'Y', 'Y', 'N', 'Y', 'N', 'Y', ],
                    "m-point": [10, 12, 20, 40, 40, 40, 30, 20]})

# 合并操作
df_inner = pd.merge(df, df1, on='id', how='inner') # 内连接，交集
df_left = pd.merge(df, df1, on='id', how='left')    # 左连接，保留df所有行
df_right = pd.merge(df, df1, on='id', how='right')  # 右连接，保留df1所有行
df_outer = pd.merge(df, df1, on='id', how='outer')  # 外连接，并集

# 输出结果
print("内连接 (Inner Join):")
print(df_inner)

print("\n左连接 (Left Join):")
print(df_left)

print("\n右连接 (Right Join):")
print(df_right)

print("\n外连接 (Outer Join):")
print(df_outer)

执行输出如下：

pandas数据分析（一）_ci

⑵.join

作用: 将两个 DataFrame 基于它们的索引（index）连接。
含义: 基于索引对两个 DataFrame 进行连接，类似于 SQL 中的 JOIN 操作，默认是左连接。

案例代码:

import pandas as pd

# 示例数据
# 示例数据
left = pd.DataFrame({'A': ['A0', 'A1', 'A2'], 'B': ['B0', 'B1', 'B2']}, index=['K0', 'K1', 'K2'])
right = pd.DataFrame({'C': ['C0', 'C1', 'C2'], 'D': ['D0', 'D1', 'D2']}, index=['K0', 'K2', 'K3'])
print(left)
print(right)

# 使用 join 进行连接，这里指定成了内连接：
joined_df = left.join(right, how='inner')
print("使用 join 连接后的数据表:")
print(joined_df)

执行如下：

pandas数据分析（一）_数据格式_02

⑶.concat

concat：

作用: 沿指定轴（axis）将多个 DataFrame 连接在一起。
含义: 可以沿行或列方向将多个 DataFrame 连接在一起，通过指定轴向进行连接操作。

语法：

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

参数：

objs︰一个序列或系列、综合或面板对象的映射。如果字典中传递，将作为键参数，使用排序的键，除非它传递，在这种情况下的值将会选择（见下文）。任何没有任何反对将默默地被丢弃，除非他们都没有在这种情况下将引发 ValueError。
axis: {0，1，…}，默认值为 0。要连接沿轴。
join: {‘内部’、 ‘外’}，默认 ‘外’。如何处理其他 axis(es) 上的索引。联盟内、外的交叉口。
ignore_index︰布尔值、默认 False。如果为 True，则不要串联轴上使用的索引值。由此产生的轴将标记
0，…，n-1。这是有用的如果你串联串联轴没有有意义的索引信息的对象。请注意在联接中仍然受到尊重的其他轴上的索引值。
join_axes︰索引对象的列表。具体的指标，用于其他 n-1 轴而不是执行内部/外部设置逻辑。 keys︰
序列，默认为无。构建分层索引使用通过的键作为最外面的级别。如果多个级别获得通过，应包含元组。
levels︰列表的序列，默认为无。具体水平（唯一值）用于构建多重。否则，他们将推断钥匙。
names︰列表中，默认为无。由此产生的分层索引中的级的名称。
verify_integrity︰布尔值、默认 False。检查是否新的串联的轴包含重复项。这可以是相对于实际数据串联非常昂贵。
副本︰布尔值、默认 True。如果为 False，请不要，不必要地复制数据

案例代码：

import pandas as pd

# 示例数据
df1 = pd.DataFrame({'A': ['A0', 'A1', 'A2'], 'B': ['B0', 'B1', 'B2']})
df2 = pd.DataFrame({'A': ['A3', 'A4', 'A5'], 'B': ['B3', 'B4', 'B5']})

"""
使用 concat 进行连接
在 pd.concat() 函数中，ignore_index=True 参数的含义是忽略原来的索引，生成一个新的从 0 开始的连续索引。
这在需要将多个 DataFrame 连接在一起时很有用，特别是当原始 DataFrame 的索引可能重复或者不连续时。
"""
concatenated_df = pd.concat([df1, df2], ignore_index=True)
print("使用 concat 连接后的数据表:")
print(concatenated_df)

如下：

pandas数据分析（一）_数据_03

4.2.设置索引列

当df.set_index('A', inplace=True)的作用是将DataFrame中的某一列作为索引列，这里将'A'列作为索引列。设置索引列后，原来的整数索引将被替换，DataFrame的索引将变为'A'列的值。如果想要取消设置的索引列，可以使用df.reset_index(inplace=True)方法来恢复默认的整数索引。这样就可以重新使用默认的整数索引进行取值操作了。

import pandas as pd

# 包含两列'A'和'B'，分别对应数值1、2、3和数值4、5、6。
df = pd.DataFrame({'A': [1, 2, 3], 'B': [4, 5, 6]})
print(df)

# 将DataFrame的索引列设置为'A'列的值，参数inplace=True表示在原DataFrame上进行操作，而不是返回一个新的DataFrame。
df.set_index('A', inplace=True)
print("\n设置索引列后的数据表:")
print(df)
# 通过.loc[]方法根据索引值取值
print(df.loc[1, 'B'])  # 获取索引值为1的行的'B'列的值: 4

执行如下：

pandas数据分析（一）_数据_04

4.3.按照特定列的值排序(默认升序排列)

语法：

df_inner.sort_values(by=['age'])

案例：

import pandas as pd
import numpy as np

# 示例数据
data = {
    'age': [25, 30, 20, 35],
    'name': ['小明', '小红', '小刚', '小美'],
    'city': ['北京', '上海', '广州', '北京'],
    'price': [2500, 4000, 1500, 3000],
    'category': ['A-10', 'B-20', 'A-15', 'C-25']
}

# 创建DataFrame
df_inner = pd.DataFrame(data)
"""
   age name city  price category
0   25   小明   北京   2500     A-10
1   30   小红   上海   4000     B-20
2   20   小刚   广州   1500     A-15
3   35   小美   北京   3000     C-25
"""
# 按照 age 列排序
df_sorted_by_age = df_inner.sort_values(by='age')
print("\n按照'age'列排序后的DataFrame:")
print(df_sorted_by_age)
"""
   age name city  price category
2   20   小刚   广州   1500     A-15
0   25   小明   北京   2500     A-10
1   30   小红   上海   4000     B-20
3   35   小美   北京   3000     C-25
"""

说明:

df_inner.sort_values(by='age') 按照'age'列的值升序排序DataFrame df_inner

如果要按 age 列进行降序排序，可以这样写：

df_sorted_by_age_desc = df_inner.sort_values(by='age', ascending=False)

4.4.按照索引列排序

语法：

df_inner.sort_index()

案例：

import pandas as pd
import numpy as np

# 示例数据
data = {
    'age': [25, 30, 20, 35],
    'name': ['小明', '小红', '小刚', '小美'],
    'city': ['北京', '上海', '广州', '北京'],
    'price': [2500, 4000, 1500, 3000],
    'category': ['A-10', 'B-20', 'A-15', 'C-25']
}

# 创建DataFrame
df_inner = pd.DataFrame(data)
"""
   age name city  price category
0   25   小明   北京   2500     A-10
1   30   小红   上海   4000     B-20
2   20   小刚   广州   1500     A-15
3   35   小美   北京   3000     C-25
"""

# 按照 索引列 排序, 不设置默认是升序，可以添加参数ascending=False设置降序
df_sorted_by_index = df_inner.sort_index(ascending=False)
print("\n按照索引列排序后的DataFrame:")
print(df_sorted_by_index)
"""
按照索引列排序后的DataFrame:
   age name city  price category
3   35   小美   北京   3000     C-25
2   20   小刚   广州   1500     A-15
1   30   小红   上海   4000     B-20
0   25   小明   北京   2500     A-10
"""

说明:

df_inner.sort_index() 按照DataFrame df_inner 的索引升序排序。

4.5.如果prince列的值>3000，group列显示high，否则显示low：

语法：

df_inner['group'] = np.where(df_inner['price'] > 3000,'high','low')

案例：

import pandas as pd
import numpy as np

# 示例数据
data = {
    'age': [25, 30, 20, 35],
    'name': ['小明', '小红', '小刚', '小美'],
    'city': ['北京', '上海', '广州', '北京'],
    'price': [2500, 4000, 1500, 3000],
    'category': ['A-10', 'B-20', 'A-15', 'C-25']
}

# 创建DataFrame
df_inner = pd.DataFrame(data)
"""
   age name city  price category
0   25   小明   北京   2500     A-10
1   30   小红   上海   4000     B-20
2   20   小刚   广州   1500     A-15
3   35   小美   北京   3000     C-25
"""

# 根据 price 列条件添加group列
df_inner['group'] = np.where(df_inner['price'] > 3000, 'high', 'low')
print("\n添加'group'列后的DataFrame:")
print(df_inner)

说明:

np.where(df_inner['price'] > 3000, 'high', 'low') 根据条件将'price'列大于3000的行赋值为'high'，否则赋值为'low'，创建新列'group'

4.6.对复合多个条件的数据进行分组标记

语法：

df_inner.loc[(df_inner['city'] == 'beijing') & (df_inner['price'] >= 4000), 'sign']=1

案例：

import pandas as pd
import numpy as np

# 示例数据
data = {
    'age': [25, 30, 20, 35],
    'name': ['小明', '小红', '小刚', '小美'],
    'city': ['北京', '上海', '广州', '北京'],
    'price': [2500, 4000, 1500, 3000],
    'category': ['A-10', 'B-20', 'A-15', 'C-25']
}

# 创建DataFrame
df_inner = pd.DataFrame(data)
"""
   age name city  price category
0   25   小明   北京   2500     A-10
1   30   小红   上海   4000     B-20
2   20   小刚   广州   1500     A-15
3   35   小美   北京   3000     C-25
"""

# 根据多个条件添加'sign'列
df_inner.loc[(df_inner['city'] == '上海') & (df_inner['price'] >= 4000), 'sign'] = 1
print("\n添加'sign'列后的DataFrame:")
print(df_inner)
"""
添加'sign'列后的DataFrame:
   age name city  price category  sign
0   25   小明   北京   2500     A-10   NaN
1   30   小红   上海   4000     B-20   1.0
2   20   小刚   广州   1500     A-15   NaN
3   35   小美   北京   3000     C-25   NaN
"""

说明:

df_inner.loc[(df_inner['city'] == '上海') & (df_inner['price'] >= 4000), 'sign'] = 1 对满足'城市为北京'且'价格大于等于4000'的行添加'sign'列，并赋值为1。

4.7.对category字段的值依次进行分列，并创建数据表，索引值为df_inner的索引列，列名称为category和size

语法：

pd.DataFrame((x.split('-') for x in df_inner['category']),index=df_inner.index,columns=['category','size'])

案例：

import pandas as pd
import numpy as np

# 示例数据
data = {
    'age': [25, 30, 20, 35],
    'name': ['小明', '小红', '小刚', '小美'],
    'city': ['北京', '上海', '广州', '北京'],
    'price': [2500, 4000, 1500, 3000],
    'category': ['A-10', 'B-20', 'A-15', 'C-25']
}

# 创建DataFrame
df_inner = pd.DataFrame(data)
"""
   age name city  price category
0   25   小明   北京   2500     A-10
1   30   小红   上海   4000     B-20
2   20   小刚   广州   1500     A-15
3   35   小美   北京   3000     C-25
"""

# 分割 category 列 并创建新DataFrame
data_split = pd.DataFrame((x.split('-') for x in df_inner['category']), index=df_inner.index, columns=['category', 'size'])
print("\n分割后的DataFrame:")
print(data_split)

说明:

pd.DataFrame((x.split('-') for x in df_inner['category']), index=df_inner.index, columns=['category', 'size']) 将'category'列按照'-'分割，创建新的DataFrame，列名为'category'和'size'，索引与原始DataFrame df_inner 的索引对应。

4.8.将完成分裂后的数据表和原df_inner数据表进行匹配

pd.merge 是 pandas 中用于合并两个 DataFrame 的函数。它类似于 SQL 中的 JOIN 操作。下面是 pd.merge 函数的语法及其主要参数的说明：

pd.merge(left, right, how='inner', on=None, left_on=None, right_on=None, left_index=False, right_index=False, sort=False, suffixes=('_x', '_y'), copy=True, indicator=False, validate=None)

参数说明

left: 第一个 DataFrame。
right: 第二个 DataFrame。
how: 合并方式，默认为 'inner'。常用的合并方式包括：

'left': 左连接，保留左表的所有行。
'right': 右连接，保留右表的所有行。
'outer': 外连接，保留左右表的所有行。
'inner': 内连接，只保留左右表中匹配的行。

on: 用于连接的列名。如果左右表都有这个列名，则直接使用该列进行连接。
left_on: 左表中用作连接键的列名。
right_on: 右表中用作连接键的列名。
left_index: 如果为 True，则使用左表的索引作为连接键。
right_index: 如果为 True，则使用右表的索引作为连接键。
sort: 按连接键对合并后的数据进行排序，默认为 False。
suffixes: 连接后的列名后缀，默认为 ('_x', '_y')。
copy: 如果为 True，则总是复制数据，默认为 True。
indicator: 如果为 True，则添加一个 _merge 列，指示每一行的来源。
validate: 如果指定，可以用于检查合并是否符合预期。比如 'one_to_one', 'one_to_many', 'many_to_one', 'many_to_many'。

案例：

import pandas as pd
import numpy as np

# 示例数据
data = {
    'age': [25, 30, 20, 35],
    'name': ['小明', '小红', '小刚', '小美'],
    'city': ['北京', '上海', '广州', '北京'],
    'price': [2500, 4000, 1500, 3000],
    'category': ['A-10', 'B-20', 'A-15', 'C-25']
}

# 创建DataFrame
df_inner = pd.DataFrame(data)
"""
   age name city  price category
0   25   小明   北京   2500     A-10
1   30   小红   上海   4000     B-20
2   20   小刚   广州   1500     A-15
3   35   小美   北京   3000     C-25
"""
# 将category字段按照-分割，创建新DataFrame split，列名为category和size。
split = pd.DataFrame(
    [x.split('-') for x in df_inner['category']],
    index=df_inner.index,
    columns=['category', 'size']
)
print("\n分割后的DataFrame:")
print(split)
"""
分割后的DataFrame:
  category size
0        A   10
1        B   20
2        A   15
3        C   25
"""

# 将分割后的DataFrame与原始DataFrame进行合并
df_inner = pd.merge(df_inner, split, left_index=True, right_index=True)
print("\n合并后的DataFrame:")
print(df_inner)
"""
合并后的DataFrame:
   age name city  price category_x category_y size
0   25   小明   北京   2500       A-10          A   10
1   30   小红   上海   4000       B-20          B   20
2   20   小刚   广州   1500       A-15          A   15
3   35   小美   北京   3000       C-25          C   25
"""

说明: