[Pandas]深入浅出pandas常用操作，非常适合初学者[Python数据分析]

William数据分析

于 2024-07-14 13:15:18 发布

阅读量378

点赞数 18

分类专栏： python 文章标签： python 开发语言数据分析 pandas 数据挖掘数据结构

本文链接：https://blog.csdn.net/weixin_45933029/article/details/140407626

版权

python 专栏收录该内容

3 篇文章 0 订阅

订阅专栏

[一文掌握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  B5

5. 数据清理

# 处理缺失值
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: float64

8. 合并与连接

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  60000

merge 是 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