[一文掌握pandas数据处理，python数据处理]
[Python数据分析]pandas库中的DataFrame（简称df）是Python数据处理和分析中最常用的数据结构之一。本文详细介绍了pandas DataFrame的一些常用操作，包括数据查看、选择、添加、删除、清理、转换、分组与聚合以及合并与连接。这些操作涵盖了数据分析的基本步骤，掌握这些操作可以帮助你高效地处理和分析数据，以下是一些常见的操作以及相应的示例代码：
1. 导入pandas并创建DataFrame
import pandas as pd
# 创建一个简单的DataFrame
data = {
'Name': ['Alice', 'Bob', 'Charlie', 'David'],
'Age': [24, 27, 22, 32],
'City': ['New York', 'Los Angeles', 'Chicago', 'Houston']
}
df = pd.DataFrame(data)
print(df)
2. 查看数据
# 显示前几行
print(df.head(2))
# 显示后几行
print(df.tail(2))
# 显示DataFrame的基本信息
print(df.info())
# 显示DataFrame的统计摘要
print(df.describe())
3. 选择数据
# 选择一列
print(df['Name'])
# 选择多列
print(df[['Name', 'City']])
# 选择行（按索引）
print(df.iloc[0]) # 第一行
print(df.iloc[1:3]) # 第二行到第三行
# 选择行（按条件）
print(df[df['Age'] > 25])
# 选择行（按多条件）
print(df[(df['Age'] > 25) & (df['City']=='New York')])
3.1 iloc和loc区别
iloc (基于位置的索引)，通过行号和列号来选择数据，使用整数进行索引
loc (基于标签的索引)，使用标签进行索引。它类似于字典的键值对索引。
import pandas as pd
data = {
'名字': ['Alice', 'Bob', 'Charlie', 'David'],
'年龄': [24, 27, 22, 32],
'城市': ['New York', 'Los Angeles', 'Chicago', 'Houston']
}
df = pd.DataFrame(data)
print("初始 DataFrame:")
print(df)
# iloc 示例
print("\n使用 iloc 选择数据:")
# 使用 iloc 选择第一行
print("\n1. 使用 iloc 选择第一行:")
print(df.iloc[0])
# 使用 iloc 选择前两行
print("\n2. 使用 iloc 选择前两行:")
print(df.iloc[:2])
# 使用 iloc 选择特定行和列
print("\n3. 使用 iloc 选择第一行的名字和年龄列:")
print(df.iloc[0, [0, 1]])
# 使用 iloc 选择特定行和范围列
print("\n4. 使用 iloc 选择前两行和前两列:")
print(df.iloc[:2, :2])
# loc 示例
print("\n使用 loc 选择数据:")
# 使用 loc 选择标签为 0 的行
print("\n1. 使用 loc 选择标签为 0 的行:")
print(df.loc[0])
# 使用 loc 选择标签为 0 和 1 的行
print("\n2. 使用 loc 选择标签为 0 和 1 的行:")
print(df.loc[[0, 1]])
# 使用 loc 选择特定行和列
print("\n3. 使用 loc 选择标签为 0 的行，名字和年龄列:")
print(df.loc[0, ['名字', '年龄']])
# 使用 loc 选择特定行和范围列
print("\n4. 使用 loc 选择标签为 0 和 1 的行，名字和年龄列:")
print(df.loc[[0, 1], ['名字', '年龄']])
4. 添加和删除数据
print("\n4. 添加新列:")
df['薪水'] = [70000, 80000, 50000, 60000]
print(df)
print("\n4. 删除新列:")
df = df.drop('薪水', axis=1)
print(df)
print("\n4. 添加新行:")
new_row = pd.DataFrame([{'名字': 'Eve', '年龄': 29, '城市': 'San Francisco'}])
df = pd.concat([df, new_row], ignore_index=True)
print(df)
print("\n4. 删除第一行:")
df = df.drop(0) # 删除第一行
print(df)4.1 drop 方法进行删除行或列
drop 方法用于从 DataFrame 中删除指定的行或列。
参数
labels: 要删除的行或列的标签（名称）。axis: 指定要删除的是行还是列。axis=0表示删除行，axis=1表示删除列。默认值是axis=0。inplace: 如果设置为True，则会直接在原 DataFrame 上进行删除操作，而不会返回新的 DataFrame。默认值是False。errors: 如果设置为ignore，则不会在标签不存在时引发错误。默认值是raise。
4.2 pd.concat 方法进行增加行或列
pd.concat 方法用于沿指定轴（行或列）将多个 DataFrame 或 Series 进行连接（拼接）。它可以用于合并多个 DataFrame 或 Series。
参数
objs: 一个序列或映射，其中的元素是要连接的对象（如 DataFrame 或 Series）。axis: 沿着哪一个轴进行连接，axis=0表示按行连接（垂直方向），axis=1表示按列连接（水平方向）。默认值是axis=0。ignore_index: 如果设置为True，则不保留原索引，并重新生成新的索引。默认值是False。join: 指定连接的方式，join='inner'表示交集连接，join='outer'表示并集连接。默认值是outer。keys: 如果设置了keys，则连接的对象会被层次化索引标记。默认值是None。sort: 如果设置为True，则按轴标签排序。默认值是False。
pd.concat示例代码：
import pandas as pd
# 创建初始 DataFrame
data = {
'名字': ['Alice', 'Bob', 'Charlie', 'David'],
'年龄': [24, 27, 22, 32],
'城市': ['New York', 'Los Angeles', 'Chicago', 'Houston']
}
df = pd.DataFrame(data)
print("初始 DataFrame:")
print(df)
# 添加新行
print("\n1. 添加新行:")
# 创建包含新行的 DataFrame
new_row = pd.DataFrame([{'名字': 'Eve', '年龄': 29, '城市': 'San Francisco'}])
# 使用 pd.concat 添加新行，ignore_index=True 重新生成索引
df = pd.concat([df, new_row], ignore_index=True)
print(df)
# 创建两个 DataFrame 以便按列连接
df1 = pd.DataFrame({
'A': ['A0', 'A1', 'A2'],
'B': ['B0', 'B1', 'B2']
})
df2 = pd.DataFrame({
'C': ['C0', 'C1', 'C2'],
'D': ['D0', 'D1', 'D2']
})
print("\n2. 按列连接:")
# 使用 pd.concat 按列连接两个 DataFrame，axis=1 表示按列连接
result = pd.concat([df1, df2], axis=1)
print(result)
# 创建两个 DataFrame 以便设置层次化索引
df3 = pd.DataFrame({
'A': ['A0', 'A1', 'A2'],
'B': ['B0', 'B1', 'B2']
})
df4 = pd.DataFrame({
'A': ['A3', 'A4', 'A5'],
'B': ['B3', 'B4', 'B5']
})
print("\n3. 设置层次化索引:")
# 使用 pd.concat 设置层次化索引，keys 参数指定每个 DataFrame 的索引标签
result = pd.concat([df3, df4], keys=['batch1', 'batch2'])
print(result)
# 创建两个 DataFrame 以便进行交集连接
df5 = pd.DataFrame({
'A': ['A0', 'A1', 'A2'],
'B': ['B0', 'B1', 'B2']
})
df6 = pd.DataFrame({
'B': ['B3', 'B4', 'B5'],
'C': ['C3', 'C4', 'C5']
})
print("\n4. 交集连接:")
# 使用 pd.concat 进行交集连接，join='inner' 表示只保留两个 DataFrame 中都有的列
result = pd.concat([df5, df6], join='inner')
print(result)
pd.concat示例代码运行结果：
初始 DataFrame:
名字 年龄 城市
0 Alice 24 New York
1 Bob 27 Los Angeles
2 Charlie 22 Chicago
3 David 32 Houston
1. 添加新行:
名字 年龄 城市
0 Alice 24 New York
1 Bob 27 Los Angeles
2 Charlie 22 Chicago
3 David 32 Houston
4 Eve 29 San Francisco
2. 按列连接:
A B C D
0 A0 B0 C0 D0
1 A1 B1 C1 D1
2 A2 B2 C2 D2
3. 设置层次化索引:
A B
batch1 0 A0 B0
1 A1 B1
2 A2 B2
batch2 0 A3 B3
1 A4 B4
2 A5 B5
4. 交集连接:
B
0 B0
1 B1
2 B2
0 B3
1 B4
2 B55. 数据清理
# 处理缺失值
df.loc[2, 'Age'] = None # 人为制造缺失值
print(df.isna()) # 检查缺失值
df = df.fillna(0) # 用0填充缺失值
print(df)
# 删除缺失值
df.loc[2, 'Age'] = None # 重新制造缺失值
df = df.dropna() # 删除包含缺失值的行
print(df)
6. 数据转换
# 更改数据类型
df['Age'] = df['Age'].astype(int)
print(df.dtypes)
# 应用函数
df['Age'] = df['Age'].apply(lambda x: x + 1)
print(df)
7. 数据分组与聚合
pandas 提供了强大的数据分组与聚合功能，使用 groupby 方法可以轻松对数据进行分组，并使用各种聚合函数对分组后的数据进行计算。
1. groupby 方法
groupby 方法根据一个或多个列对数据进行分组，然后对每个分组应用一个聚合函数（如 sum, mean, count, max, min 等,也可以自定义）。
2. 按单列分组并聚合：按部门分组，并计算每个部门的工资总和
3. 按多列分组并聚合：按部门和年龄分组，并计算每个分组的平均工资
4.对每个部门分别计算工资的总和、平均值和最大值
5. 自定义聚合函数；使用自定义函数计算每个部门工资的变异系数（标准差除以平均值）
groupby示例代码：
import pandas as pd
# 创建示例 DataFrame
data = {
'部门': ['销售', '销售', '技术', '技术', '人事', '人事', '销售', '技术'],
'姓名': ['Alice', 'Bob', 'Charlie', 'David', 'Eve', 'Frank', 'Grace', 'Hannah'],
'工资': [7000, 8000, 5000, 6000, 4500, 4800, 9000, 7500],
'年龄': [25, 30, 35, 40, 28, 32, 29, 38]
}
df = pd.DataFrame(data)
print("初始 DataFrame:")
print(df)
# 1. 按部门分组，并计算每个部门的工资总和
print("\n1. 按部门分组，并计算每个部门的工资总和:")
# 使用 groupby 方法按 '部门' 列进行分组，并计算每个分组的 '工资' 列的总和
grouped_sum = df.groupby('部门')['工资'].sum()
print(grouped_sum)
# 2. 按部门和年龄分组，并计算每个分组的平均工资
print("\n2. 按部门和年龄分组，并计算每个分组的平均工资:")
# 使用 groupby 方法按 '部门' 和 '年龄' 列进行多重分组，并计算每个分组的 '工资' 列的平均值
grouped_mean = df.groupby(['部门', '年龄'])['工资'].mean()
print(grouped_mean)
# 3. 对每个部门分别计算工资的总和、平均值和最大值
print("\n3. 对每个部门分别计算工资的总和、平均值和最大值:")
# 使用 groupby 方法按 '部门' 列分组，并使用 agg 方法同时计算 '工资' 列的总和、平均值和最大值
grouped_agg = df.groupby('部门')['工资'].agg(['sum', 'mean', 'max'])
print(grouped_agg)
# 4. 使用自定义函数计算每个部门工资的变异系数（标准差除以平均值）
def coeff_of_variation(series):
return series.std() / series.mean()
print("\n4. 使用自定义函数计算每个部门工资的变异系数:")
# 使用 groupby 方法按 '部门' 列分组，并使用 agg 方法应用自定义函数计算 '工资' 列的变异系数
grouped_custom = df.groupby('部门')['工资'].agg(coeff_of_variation)
print(grouped_custom)
groupby运行结果：
初始 DataFrame:
部门 姓名 工资 年龄
0 销售 Alice 7000 25
1 销售 Bob 8000 30
2 技术 Charlie 5000 35
3 技术 David 6000 40
4 人事 Eve 4500 28
5 人事 Frank 4800 32
6 销售 Grace 9000 29
7 技术 Hannah 7500 38
1. 按部门分组，并计算每个部门的工资总和:
部门
人事 9300
技术 18500
销售 24000
Name: 工资, dtype: int64
2. 按部门和年龄分组，并计算每个分组的平均工资:
部门 年龄
人事 28 4500.0
32 4800.0
技术 35 5000.0
38 7500.0
40 6000.0
销售 25 7000.0
29 9000.0
30 8000.0
Name: 工资, dtype: float64
3. 对每个部门分别计算工资的总和、平均值和最大值:
sum mean max
部门
人事 9300 4650.000000 4800
技术 18500 6166.666667 7500
销售 24000 8000.000000 9000
4. 使用自定义函数计算每个部门工资的变异系数:
部门
人事 0.04562
技术 0.20405
销售 0.12500
Name: 工资, dtype: float64
agg 方法简介
agg 方法用于在分组后的数据上应用一个或多个聚合函数。它提供了极大的灵活性，可以对不同的列应用不同的聚合函数，也可以同时应用多个聚合函数。
groupby agg示例代码:
import pandas as pd
# 创建示例 DataFrame
data = {
'部门': ['销售', '销售', '技术', '技术', '人事', '人事', '销售', '技术'],
'姓名': ['Alice', 'Bob', 'Charlie', 'David', 'Eve', 'Frank', 'Grace', 'Hannah'],
'工资': [7000, 8000, 5000, 6000, 4500, 4800, 9000, 7500],
'年龄': [25, 30, 35, 40, 28, 32, 29, 38]
}
df = pd.DataFrame(data)
print("初始 DataFrame:")
print(df)
# 1. 对单列应用单个聚合函数：按部门分组，并计算每个部门的工资总和
print("\n1. 对单列应用单个聚合函数：按部门分组，并计算每个部门的工资总和")
grouped_sum = df.groupby('部门')['工资'].agg('sum')
print(grouped_sum)
# 2. 对单列应用多个聚合函数：按部门分组，并计算每个部门的工资总和、平均值和最大值
print("\n2. 对单列应用多个聚合函数：按部门分组，并计算每个部门的工资总和、平均值和最大值")
grouped_multiple = df.groupby('部门')['工资'].agg(['sum', 'mean', 'max'])
print(grouped_multiple)
# 3. 对多列应用单个聚合函数：按部门分组，并计算每个部门的工资和年龄的平均值
print("\n3. 对多列应用单个聚合函数：按部门分组，并计算每个部门的工资和年龄的平均值")
grouped_mean_multi = df.groupby('部门').agg({'工资': 'mean', '年龄': 'mean'})
print(grouped_mean_multi)
# 4. 对多列应用多个聚合函数：按部门分组，并计算每个部门的工资总和和年龄的最大值
print("\n4. 对多列应用多个聚合函数：按部门分组，并计算每个部门的工资总和和年龄的最大值")
grouped_custom_multi = df.groupby('部门').agg({
'工资': ['sum', 'mean'],
'年龄': ['max', 'min']
})
print(grouped_custom_multi)
# 5. 使用自定义函数计算每个部门工资的变异系数
def coeff_of_variation(series):
return series.std() / series.mean()
print("\n5. 使用自定义函数计算每个部门工资的变异系数")
grouped_custom_func = df.groupby('部门')['工资'].agg(coeff_of_variation)
print(grouped_custom_func)groupby agg运行结果:
初始 DataFrame:
部门 姓名 工资 年龄
0 销售 Alice 7000 25
1 销售 Bob 8000 30
2 技术 Charlie 5000 35
3 技术 David 6000 40
4 人事 Eve 4500 28
5 人事 Frank 4800 32
6 销售 Grace 9000 29
7 技术 Hannah 7500 38
1. 对单列应用单个聚合函数：按部门分组，并计算每个部门的工资总和
部门
人事 9300
技术 18500
销售 24000
Name: 工资, dtype: int64
2. 对单列应用多个聚合函数：按部门分组，并计算每个部门的工资总和、平均值和最大值
sum mean max
部门
人事 9300 4650.000000 4800
技术 18500 6166.666667 7500
销售 24000 8000.000000 9000
3. 对多列应用单个聚合函数：按部门分组，并计算每个部门的工资和年龄的平均值
工资 年龄
部门
人事 4650.000000 30.000000
技术 6166.666667 37.666667
销售 8000.000000 28.000000
4. 对多列应用多个聚合函数：按部门分组，并计算每个部门的工资总和和年龄的最大值
工资 年龄
sum mean max min
部门
人事 9300 4650.000000 32 28
技术 18500 6166.666667 40 35
销售 24000 8000.000000 30 25
5. 使用自定义函数计算每个部门工资的变异系数
部门
人事 0.04562
技术 0.20405
销售 0.12500
Name: 工资, dtype: float648. 合并与连接
merge 是 pandas 中一个强大的函数，用于将两个 DataFrame 对象按照指定的键（key）进行合并。以下是关于 merge 函数的详细讲解：
merge合并连接示例代码:
import pandas as pd
# 使用中文数据更新DataFrame
data1 = {
'姓名': ['爱丽丝', '鲍勃', '查理', '大卫'],
'部门': ['人力资源', '技术', '销售', '财务'],
'年龄': [25, 30, 35, 40]
}
data2 = {
'姓名': ['爱丽丝', '鲍勃', '查理', '大卫'],
'工资': [70000, 80000, 50000, 60000]
}
# 创建两个中文DataFrame
df1 = pd.DataFrame(data1)
df2 = pd.DataFrame(data2)
print(f'原始DataFrame1：\n{df1}')
print(f'原始DataFrame2：\n{df2}')
# 合并中文DataFrame
merged_df = pd.merge(df1, df2, on='姓名')
print(f'合并后的DataFrame：\n{merged_df}')
merge合并连接运行结果:
原始DataFrame1：
姓名 部门 年龄
0 爱丽丝 人力资源 25
1 鲍勃 技术 30
2 查理 销售 35
3 大卫 财务 40
原始DataFrame2：
姓名 工资
0 爱丽丝 70000
1 鲍勃 80000
2 查理 50000
3 大卫 60000
合并后的DataFrame：
姓名 部门 年龄 工资
0 爱丽丝 人力资源 25 70000
1 鲍勃 技术 30 80000
2 查理 销售 35 50000
3 大卫 财务 40 60000merge 是 pandas 中一个强大的函数，用于将两个 DataFrame 对象按照指定的键（key）进行合并。以下是关于 merge 函数的详细讲解：
1. merge 进阶能做什么
- 内连接（Inner Join）：合并两个 DataFrame，只保留它们共有的键（key）的行。
- 左连接（Left Join）：以左侧 DataFrame 为基准，保留左侧 DataFrame 的所有行。如果右侧 DataFrame 中没有对应的键，则填充 NaN。
- 右连接（Right Join）：以右侧 DataFrame 为基准，保留右侧 DataFrame 的所有行。如果左侧 DataFrame 中没有对应的键，则填充 NaN。
- 外连接（Full Outer Join）：合并两个 DataFrame，保留它们所有的行。如果某个键在任一 DataFrame 中不存在，则填充 NaN。
- 半连接（Semi Join）：类似于内连接，但只保留左侧 DataFrame 的键。
- 反连接（Anti Join）：返回左侧 DataFrame 中不存在于右侧 DataFrame 的键的行。
2. 参数说明
on：指定用于合并的键（key）。如果两个 DataFrame 有相同的列名，则可以直接使用列名。left_on和right_on：用于指定左侧和右侧 DataFrame 的键。how：指定合并的类型（‘left’, ‘right’, ‘outer’ (default), ‘inner’）。indicator：如果设置为 True，则在合并后的 DataFrame 中添加一个_merge列，显示每行数据的来源（‘left_only’, ‘right_only’, ‘both’）。
使用 merge 函数时，请确保两个 DataFrame 中的键（key）是匹配的，或者您已经指定了正确的合并方式。通过灵活使用不同的合并类型，可以有效地根据需求合并和整理数据。
merge合并连接 进阶 示例代码:
# 导入pandas库
import pandas as pd
# 创建第一个DataFrame，包含姓名、部门和年龄
data1 = {
'姓名': ['爱丽丝', '鲍勃', '查理', '大卫'],
'部门': ['人力资源', '技术', '销售', '财务'],
'年龄': [25, 30, 35, 40]
}
df1 = pd.DataFrame(data1)
# 创建第二个DataFrame，包含姓名和工资
data2 = {
'姓名': ['爱丽丝', '鲍勃', '查理', '大卫'],
'工资': [70000, 80000, 50000, 60000]
}
df2 = pd.DataFrame(data2)
# 使用merge函数按姓名列进行内连接合并两个DataFrame
# 内连接只保留两个DataFrame中都有的键（姓名）的行
merged_inner = pd.merge(df1, df2, on='姓名')
print("内连接合并结果：")
print(merged_inner)
# 使用merge函数按姓名列进行左连接合并两个DataFrame
# 左连接以左侧DataFrame（df1）为基准，保留左侧DataFrame的所有行
# 如果右侧DataFrame（df2）中没有对应的键，则填充NaN
merged_left = pd.merge(df1, df2, on='姓名', how='left')
print("\n左连接合并结果：")
print(merged_left)
# 使用merge函数按姓名列进行右连接合并两个DataFrame
# 右连接以右侧DataFrame（df2）为基准，保留右侧DataFrame的所有行
# 如果左侧DataFrame（df1）中没有对应的键，则填充NaN
merged_right = pd.merge(df1, df2, on='姓名', how='right')
print("\n右连接合并结果：")
print(merged_right)
# 使用merge函数按姓名列进行外连接合并两个DataFrame
# 外连接保留两个DataFrame中的所有行
# 如果某个键在任一DataFrame中不存在，则填充NaN
merged_outer = pd.merge(df1, df2, on='姓名', how='outer')
print("\n外连接合并结果：")
print(merged_outer)
merge合并连接 进阶 运行结果:
内连接合并结果：
姓名 部门 年龄 工资
0 爱丽丝 人力资源 25 70000
1 鲍勃 技术 30 80000
2 查理 销售 35 50000
3 大卫 财务 40 60000
左连接合并结果：
姓名 部门 年龄 工资
0 爱丽丝 人力资源 25 70000
1 鲍勃 技术 30 80000
2 查理 销售 35 50000
3 大卫 财务 40 60000
右连接合并结果：
姓名 部门 年龄 工资
0 爱丽丝 人力资源 25 70000
1 鲍勃 技术 30 80000
2 查理 销售 35 50000
3 大卫 财务 40 60000
外连接合并结果：
姓名 部门 年龄 工资
0 大卫 财务 40 60000
1 查理 销售 35 50000
2 爱丽丝 人力资源 25 70000
3 鲍勃 技术 30 80000这些操作涵盖了pandas中一些最常见和最基本的DataFrame操作。通过这些操作，你可以高效地进行数据处理和分析。如果你有具体的需求或更复杂的操作，请随时告诉我
完整代码(方便复制运行)
import pandas as pd
# 1. 创建一个简单的DataFrame
data = {
'名字': ['Alice', 'Bob', 'Charlie', 'David'],
'年龄': [24, 27, 22, 32],
'城市': ['New York', 'Los Angeles', 'Chicago', 'Houston']
}
df = pd.DataFrame(data)
print("1. 初始 DataFrame:")
print(df)
# 2. 查看数据
print("\n2. 显示 DataFrame 的前几行:")
print(df.head(2))
print("\n2. 显示 DataFrame 的后几行:")
print(df.tail(2))
print("\n2. 显示 DataFrame 的基本信息:")
print(df.info())
print("\n2. 显示 DataFrame 的统计摘要:")
print(df.describe())
# 3. 选择数据
print("\n3. 选择单列:")
print(df['名字'])
print("\n3. 选择多列:")
print(df[['名字', '城市']])
print("\n3. 按索引选择单行:")
print(df.iloc[0]) # 第一行
print("\n3. 按索引选择多行:")
print(df.iloc[1:3]) # 第二行到第三行
print("\n3. 按条件选择行:")
print(df[df['年龄'] > 25])
# 4. 添加和删除数据
print("\n4. 添加新列:")
df['薪水'] = [70000, 80000, 50000, 60000]
print(df)
print("\n4. 删除新列:")
df = df.drop('薪水', axis=1)
print(df)
print("\n4. 添加新行:")
new_row = pd.DataFrame([{'名字': 'Eve', '年龄': 29, '城市': 'San Francisco'}])
df = pd.concat([df, new_row], ignore_index=True)
print(df)
print("\n4. 删除第一行:")
df = df.drop(0) # 删除第一行
print(df)
# 5. 数据清理
print("\n5. 处理缺失值:")
df.loc[2, '年龄'] = None # 人为制造缺失值
print(df.isna()) # 检查缺失值
df = df.fillna(0) # 用0填充缺失值
print(df)
print("\n5. 删除包含缺失值的行:")
df.loc[2, '年龄'] = None # 重新制造缺失值
df = df.dropna() # 删除包含缺失值的行
print(df)
# 6. 数据转换
print("\n6. 更改数据类型:")
df['年龄'] = df['年龄'].astype(int)
print(df.dtypes)
print("\n6. 应用函数到列:")
df['年龄'] = df['年龄'].apply(lambda x: x + 1)
print(df)
# 7. 数据分组与聚合
print("\n7. 按城市分组并计算平均年龄:")
grouped = df.groupby('城市')['年龄'].mean()
print(grouped)
# 8. 合并与连接
print("\n8. 合并 DataFrame:")
data2 = {
'名字': ['Alice', 'Bob', 'Charlie', 'David'],
'薪水': [70000, 80000, 50000, 60000]
}
df2 = pd.DataFrame(data2)
merged_df = pd.merge(df, df2, on='名字')
print(merged_df)
运行结果：
1. 初始 DataFrame:
名字 年龄 城市
0 Alice 24 New York
1 Bob 27 Los Angeles
2 Charlie 22 Chicago
3 David 32 Houston
2. 显示 DataFrame 的前几行:
名字 年龄 城市
0 Alice 24 New York
1 Bob 27 Los Angeles
2. 显示 DataFrame 的后几行:
名字 年龄 城市
2 Charlie 22 Chicago
3 David 32 Houston
2. 显示 DataFrame 的基本信息:
<class 'pandas.core.frame.DataFrame'>
RangeIndex: 4 entries, 0 to 3
Data columns (total 3 columns):
# Column Non-Null Count Dtype
--- ------ -------------- -----
0 名字 4 non-null object
1 年龄 4 non-null int64
2 城市 4 non-null object
dtypes: int64(1), object(2)
memory usage: 228.0+ bytes
None
2. 显示 DataFrame 的统计摘要:
年龄
count 4.000000
mean 26.250000
std 4.349329
min 22.000000
25% 23.500000
50% 25.500000
75% 28.250000
max 32.000000
3. 选择单列:
0 Alice
1 Bob
2 Charlie
3 David
Name: 名字, dtype: object
3. 选择多列:
名字 城市
0 Alice New York
1 Bob Los Angeles
2 Charlie Chicago
3 David Houston
3. 按索引选择单行:
名字 Alice
年龄 24
城市 New York
Name: 0, dtype: object
3. 按索引选择多行:
名字 年龄 城市
1 Bob 27 Los Angeles
2 Charlie 22 Chicago
3. 按条件选择行:
名字 年龄 城市
1 Bob 27 Los Angeles
3 David 32 Houston
4. 添加新列:
名字 年龄 城市 薪水
0 Alice 24 New York 70000
1 Bob 27 Los Angeles 80000
2 Charlie 22 Chicago 50000
3 David 32 Houston 60000
4. 删除新列:
名字 年龄 城市
0 Alice 24 New York
1 Bob 27 Los Angeles
2 Charlie 22 Chicago
3 David 32 Houston
4. 添加新行:
名字 年龄 城市
0 Alice 24 New York
1 Bob 27 Los Angeles
2 Charlie 22 Chicago
3 David 32 Houston
4 Eve 29 San Francisco
4. 删除第一行:
名字 年龄 城市
1 Bob 27 Los Angeles
2 Charlie 22 Chicago
3 David 32 Houston
4 Eve 29 San Francisco
5. 处理缺失值:
名字 年龄 城市
1 False False False
2 False True False
3 False False False
4 False False False
名字 年龄 城市
1 Bob 27.0 Los Angeles
2 Charlie 0.0 Chicago
3 David 32.0 Houston
4 Eve 29.0 San Francisco
5. 删除包含缺失值的行:
名字 年龄 城市
1 Bob 27.0 Los Angeles
3 David 32.0 Houston
4 Eve 29.0 San Francisco
6. 更改数据类型:
名字 object
年龄 int32
城市 object
dtype: object
6. 应用函数到列:
名字 年龄 城市
1 Bob 28 Los Angeles
3 David 33 Houston
4 Eve 30 San Francisco
7. 按城市分组并计算平均年龄:
城市
Houston 33.0
Los Angeles 28.0
San Francisco 30.0
Name: 年龄, dtype: float64
8. 合并 DataFrame:
名字 年龄 城市 薪水
0 Bob 28 Los Angeles 80000
1 David 33 Houston 60000