pandas数据分析（一）
一、生成数据表
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)
执行输出如下：
⑵.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)
执行如下：
⑶.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)
如下：
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
执行如下：
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'列的值升序排序DataFramedf_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()按照DataFramedf_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'，索引与原始DataFramedf_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 """
说明:
pd.merge(df_inner, split, left_index=True, right_index=True)根据索引将分割后的DataFrame与原始DataFramedf_inner进行合并。
浙公网安备 33010602011771号