📚 Python入门到高级（知识点六）
💡 关键知识点
一、Pandas中的缺失值是什么
1.1 三种空值表现形式
Pandas中，缺失值主要有三种表现形式：
| 类型 |
说明 |
示例 |
None |
Python原生的空值，类型为 NoneType |
None |
np.nan |
NumPy中的空值，类型为 float |
np.nan |
pd.NA |
Pandas 1.0+ 引入的专属空值 |
pd.NA |
import numpy as np
import pandas as pd
print(None, type(None)) # None <class 'NoneType'>
print(np.nan, type(np.nan)) # nan <class 'float'>
print(pd.NA, type(pd.NA)) # <NA> <class 'pandas._libs.missing.NAType'>
1.2 注意：这些「看起来像空值」的其实不是
| 值 |
是否识别为空值 |
说明 |
'null' |
❌ |
只是一个普通字符串 |
''（空字符串） |
❌ |
Pandas认为空字符串是有内容的 |
np.inf（无穷大） |
❌ |
是有效数值 |
1.3 为什么不能用 == 判断空值？
在Python中，np.nan 有一个特殊性质------它不等于自身：
print(np.nan == np.nan) # False
print(np.nan is np.nan) # False
因此，判断空值必须使用Pandas提供的专用方法，而不是 == 运算符。
二、如何检测缺失值
2.1 核心检测方法
Pandas提供了两套功能完全等价的方法：
| 方法 |
含义 |
返回值 |
isna() / isnull() |
检测是否为缺失值 |
True表示缺失 |
notna() / notnull() |
检测是否不是缺失值 |
True表示非缺失 |
import pandas as pd
# 单个值测试
print(pd.isna(None)) # True
print(pd.isna(np.nan)) # True
print(pd.isna(pd.NA)) # True
print(pd.isna('null')) # False
print(pd.isna('')) # False
2.2 实战：检测DataFrame中的缺失值
import pandas as pd
import numpy as np
df = pd.DataFrame({
'姓名': ['张三', '李四', '王五', '赵六'],
'年龄': [25, np.nan, 30, 28],
'城市': ['北京', '上海', np.nan, '广州'],
'收入': [5000, 6000, 5500, np.nan]
})
print(df)
# 姓名 年龄 城市 收入
# 0 张三 25.0 北京 5000.0
# 1 李四 NaN 上海 6000.0
# 2 王五 30.0 NaN 5500.0
# 3 赵六 28.0 广州 NaN
# 检测缺失值
print(df.isnull())
# 姓名 年龄 城市 收入
# 0 False False False False
# 1 False True False False
# 2 False False True False
# 3 False False False True
2.3 快速统计缺失情况
# 每列缺失数量
print(df.isnull().sum())
# 姓名 0
# 年龄 1
# 城市 1
# 收入 1
# dtype: int64
# 每列缺失比例（%）
print(df.isnull().sum() / len(df) * 100)
# 姓名 0.0
# 年龄 25.0
# 城市 25.0
# 收入 25.0
# dtype: float64
# 总缺失数量
print(df.isnull().sum().sum()) # 3
2.4 关于 isna() 和 isnull() 的疑问
很多初学者会问：为什么有两套名字不同的方法，做的事情却完全一样？
官方的说法是：isnull() 是 isna() 的别名（alias），两者功能完全相同。
原因在于Pandas的设计借鉴了R语言。在R中，NA（Not Available）和 NULL 是两个不同的概念，而Python/Numpy中统一使用 NaN 表示缺失值。Pandas为了兼容不同背景的用户，同时保留了两套命名。
建议 ：任选其一，在项目中保持风格统一即可。我个人习惯使用 isna() / notna()，因为更简短。
三、Pandas读取CSV时的缺失值处理参数总结
1. keep_default_na 参数
| 参数值 |
作用 |
True（默认） |
自动将常见缺失值（空值、NULL、null、None、NA、nan等）填充为 NaN |
False |
关闭自动识别，所有值保持原始内容，不填充 NaN |
2. na_values 参数
- 作用 ：手动指定哪些值应被识别为缺失值并填充为
NaN
- 使用前提 ：通常与
keep_default_na=False 配合使用
- 注意 ：设置
na_values 后，只有列表中指定的值会被替换为 NaN
方式一：默认读取（自动填充）
import pandas as pd
import numpy as np
# keep_default_na=True（默认），自动填充常见缺失值为 NaN
df = pd.read_csv('data/survey_visited.csv')
方式二：关闭自动填充
import pandas as pd
import numpy as np
# keep_default_na=False，不填充任何值，保留原始数据
df = pd.read_csv('data/survey_visited.csv', keep_default_na=False)
方式三：关闭自动填充 + 自定义缺失值
import pandas as pd
import numpy as np
# keep_default_na=False 关闭自动填充 + na_values 手动指定哪些值算缺失
df = pd.read_csv('data/survey_visited.csv', keep_default_na=False, na_values=[None, np.nan, pd.NA])
四、Pandas删除缺失值详解
# 1. 导包
import pandas as pd
# 2. 加载数据
train = pd.read_csv('data/titanic_train.csv')
# 3. 了解数据
train.info()
print(train.shape) # (892, 12)
# ============================================================
# 4. 删除缺失值
# ============================================================
# 重要概念：
# dropna(inplace=True) → 直接在原数据上修改
# dropna() → 默认复制一份，原数据不变，返回新DataFrame
方式一：dropna() 默认删除任意缺失行
# 4.1 dropna() 默认 how='any'，删除包含任何缺失值的行
new_train1 = train.dropna() # 默认 how='any'
print(new_train1.shape) # (183, 12)
# 示例数据理解：
# 原始数据 (892行, 12列)
# Age列缺失 178行，Cabin列缺失 688行，Embarked列缺失 3行
# dropna() 删除所有包含缺失值的行后，只剩下 183行
# 这183行是 Age、Cabin、Embarked 三列都没有缺失的乘客
方式二：dropna(how='all') 删除全为空的行
# 4.2 dropna(how='all') 只有整行都是缺失值才删除
new_train2 = train.dropna(how='all')
print(new_train2.shape) # (891, 12)
# 示例数据理解：
# 原始数据有 892行，删除了 1行（该行所有列都是NaN）
# 因为泰坦尼克数据中，只有极少数行可能全为空
# 所以结果几乎没变化：892 → 891
方式三：dropna(subset=[列名]) 指定列检测缺失
# 4.3 dropna(subset=[列名]) 只检测指定列是否有缺失
# 如果指定列有缺失，就删除该行
# 示例1：只检测 Age 列
new_train3 = train.dropna(subset=['Age'])
print(new_train3.shape) # (714, 12)
# 示例数据理解：
# Age列原来有 178个缺失值 → 删除178行
# 892 - 178 = 714 ✓
# 示例2：同时检测多列（Age 和 Cabin）
new_train3 = train.dropna(subset=['Age', 'Cabin'])
print(new_train3.shape) # (183, 12)
# 示例数据理解：
# 删除 Age 或 Cabin 任一列有缺失的行
# 结果和 dropna() 一样，因为 Cabin 缺失最多
# 892 - 688 = 183（Cabin非空的行数）✓
方式四：drop() 直接删除指定列
# 4.4 drop() 直接删除指定的列（不是删除行）
# axis=1 表示按列删除
# 删除 Cabin 列（缺失比例高达77%）
new_train4 = train.drop('Cabin', axis=1)
print(new_train4.shape) # (892, 11)
# 示例数据理解：
# 原始数据有 12列，删除了 'Cabin' 这一列
# 892行不变，列数 12 → 11
# 也可以删除多列
new_train5 = train.drop(['Cabin', 'Age'], axis=1)
print(new_train5.shape) # (892, 10)
五种方法对比总结
| 方法 |
代码 |
删除对象 |
结果 (行, 列) |
| 原始数据 |
train |
无 |
(892, 12) |
dropna() |
train.dropna() |
任意列有缺失的行 |
(183, 12) |
dropna(how='all') |
train.dropna(how='all') |
整行全为空的行 |
(891, 12) |
dropna(subset=['Age']) |
train.dropna(subset=['Age']) |
Age列有缺失的行 |
(714, 12) |
dropna(subset=['Age','Cabin']) |
train.dropna(subset=['Age','Cabin']) |
Age或Cabin有缺失的行 |
(183, 12) |
drop('Cabin', axis=1) |
train.drop('Cabin', axis=1) |
Cabin这一列 |
(892, 11) |
关键区别：dropna() vs drop()
| 方法 |
作用 |
axis参数 |
dropna() |
删除行（有缺失的行） |
默认 axis=0 |
drop() |
删除列（指定的列） |
需指定 axis=1 |
常用参数速查表
| 参数 |
作用 |
示例 |
how='any' |
只要有缺失就删除（默认） |
dropna(how='any') |
how='all' |
全部缺失才删除 |
dropna(how='all') |
subset=[列名] |
指定检测哪些列 |
dropna(subset=['Age','Cabin']) |
axis=0 |
删除行（默认） |
dropna(axis=0) |
axis=1 |
删除列 |
drop('列名', axis=1) |
inplace=True |
原地修改，不返回新对象 |
dropna(inplace=True) |
五、Pandas填充缺失值详解（带示例数据）
# 1. 导包
import pandas as pd
# 忽略所有警告
import warnings
warnings.filterwarnings('ignore')
# 2. 读取文件
df = pd.read_csv('data/students.csv')
print(df)
# ============================================================
# 3. fillna() 填充数据
# ============================================================
# 假设 students.csv 数据如下（示例）：
# name age score gender
# 0 张三 18.0 90.0 男
# 1 李四 NaN 85.0 女
# 2 王五 20.0 NaN 男
# 3 赵六 22.0 88.0 NaN
# 4 孙七 NaN 92.0 男
# 5 周八 19.0 NaN 女
方式一：直接填充固定值（0）
# 方式1：直接填充0
new_df1 = df.fillna(0)
print(new_df1)
# 示例输出：
# name age score gender
# 0 张三 18.0 90.0 男
# 1 李四 0.0 85.0 女 ← age缺失，填充为0
# 2 王五 20.0 0.0 男 ← score缺失，填充为0
# 3 赵六 22.0 88.0 0 ← gender缺失，填充为0
# 4 孙七 0.0 92.0 男 ← age缺失，填充为0
# 5 周八 19.0 0.0 女 ← score缺失，填充为0
# ⚠️ 缺点：age填充0会导致年龄异常（成年学生变成0岁）
方式二：填充平均值
# 方式2：填充平均年龄
new_df2 = df.fillna(df['age'].mean())
print(new_df2)
# 示例输出（假设 age 平均值为 19.8）：
# name age score gender
# 0 张三 18.0 90.0 男
# 1 李四 19.8 85.0 女 ← age缺失，填充为平均值19.8
# 2 王五 20.0 NaN 男
# 3 赵六 22.0 88.0 NaN
# 4 孙七 19.8 92.0 男 ← age缺失，填充为平均值19.8
# 5 周八 19.0 NaN 女
# ⚠️ 注意：只有age列被填充了，其他列（score、gender）的缺失值没有被填充
方式三：前向填充（ffill）
# 方式3：填充当前缺失值的前一个数据（向前填充）
new_df3 = df.fillna(method='ffill')
print(new_df3)
# 示例输出：
# name age score gender
# 0 张三 18.0 90.0 男
# 1 李四 18.0 85.0 女 ← age用上一行的18.0填充
# 2 王五 20.0 85.0 男 ← score用上一行的85.0填充
# 3 赵六 22.0 88.0 NaN ← gender用上一行的"男"填充
# 4 孙七 22.0 92.0 男 ← age用上一行的22.0填充
# 5 周八 19.0 92.0 女 ← score用上一行的92.0填充
# ✅ 适用场景：时间序列数据，用前一时刻的值填充
# ⚠️ 注意：第3行gender原本是NaN，前向填充时用了第2行的"男"
方式四：后向填充（bfill）
# 方式4：填充当前缺失值的后一个数据（向后填充）
new_df4 = df.fillna(method='bfill')
print(new_df4)
# 示例输出：
# name age score gender
# 0 张三 18.0 90.0 男
# 1 李四 20.0 85.0 女 ← age用下一行的20.0填充
# 2 王五 20.0 88.0 男 ← score用下一行的88.0填充
# 3 赵六 22.0 88.0 NaN ← gender用下一行的"男"填充
# 4 孙七 19.0 92.0 男 ← age用下一行的19.0填充
# 5 周八 19.0 NaN 女 ← score后面没有数据，无法填充（仍然NaN）
# ✅ 适用场景：时间序列数据，用后一时刻的值填充
# ⚠️ 注意：最后一行score缺失，后面没有数据，填充失败
四种方式对比总结
| 方式 |
代码 |
填充逻辑 |
适用场景 |
| 固定值 |
fillna(0) |
所有缺失填同一个值 |
临时占位 |
| 平均值 |
fillna(df['age'].mean()) |
用该列平均值填充 |
数值列，无明显异常值 |
| 前向填充 |
fillna(method='ffill') |
用上一行同列的值 |
时间序列，数据渐变 |
| 后向填充 |
fillna(method='bfill') |
用下一行同列的值 |
时间序列，数据渐变 |
常用填充方式汇总
# 1. 填充固定值
df.fillna(0)
# 2. 填充指定值
df.fillna('未知')
# 3. 填充平均值（数值列）
df['age'] = df['age'].fillna(df['age'].mean())
# 4. 填充中位数（更稳健，不受异常值影响）
df['age'] = df['age'].fillna(df['age'].median())
# 5. 填充众数（分类列）
df['gender'] = df['gender'].fillna(df['gender'].mode()[0])
# 6. 前向填充
df.fillna(method='ffill')
# 7. 后向填充
df.fillna(method='bfill')
# 8. 不同列填不同值
df.fillna({
'age': df['age'].median(),
'score': 0,
'gender': '未知'
})
# 9. 限制连续填充数量
df.fillna(method='ffill', limit=1) # 连续缺失只填1个
特殊知识点
1. 为什么 df.fillna(df['age'].mean()) 只填充了 age 列？
因为只传入了 df['age'].mean() 这一个值，Pandas 会将这个值应用到所有列的缺失值上。
- age 列是数值型，填充平均值 → 合理
- score 列也是数值型，填充 age 的平均值 → 错误！应该用 score 自己的平均值
- gender 列是字符串，填充数值 → 无法填充
正确做法：对不同列使用不同的填充值
# 分别填充
df['age'] = df['age'].fillna(df['age'].mean())
df['score'] = df['score'].fillna(df['score'].mean())
df['gender'] = df['gender'].fillna(df['gender'].mode()[0])
2. ffill 和 bfill 的局限性
- 如果开头就有缺失，
ffill 无法填充（前面没有数据）
- 如果结尾就有缺失，
bfill 无法填充（后面没有数据）
- 连续多个缺失时，
ffill 会用同一个值填充所有缺失
# 示例：连续缺失
# 原数据：10, NaN, NaN, 40
# ffill后：10, 10, 10, 40 ← 两个NaN都被填充为10
# bfill后：10, 40, 40, 40 ← 两个NaN都被填充为40
六、Pandas分组聚合（GroupBy）详解（带示例数据）
# 1. 导包
import numpy as np
import pandas as pd
# 2. 读取文件
# csv: 具有固定分隔符的结构化数据，都是csv格式，不用关注后缀名是不是.csv
df = pd.read_csv('data/gapminder.txt', sep='\t')
print(df.shape) # (1704, 6)
数据简介
gapminder.txt 数据包含以下列：
country：国家year：年份pop：人口continent：大洲lifeExp：平均寿命gdpPercap：人均GDP
需求1：求每个年份的平均寿命
四种写法对比
# 写法1：df.列名（返回Series）
print(df.groupby('year').lifeExp.mean())
# 示例输出：
# year
# 1952 49.057620
# 1957 51.507401
# 1962 53.609247
# 1967 55.678290
# 1972 57.647386
# 1977 59.570157
# 1982 61.533197
# 1987 63.212613
# 1992 64.160338
# 1997 65.014676
# 2002 65.694923
# 2007 67.007423
# Name: lifeExp, dtype: float64
# 写法2：df['列名']（返回Series）
print(df.groupby('year')['lifeExp'].mean())
# 输出与写法1相同
# 写法3：df[['列名']]（返回DataFrame）
print(df.groupby('year')[['lifeExp']].mean())
# 示例输出：
# lifeExp
# year
# 1952 49.057620
# 1957 51.507401
# 1962 53.609247
# 1967 55.678290
# 1972 57.647386
# 1977 59.570157
# 1982 61.533197
# 1987 63.212613
# 1992 64.160338
# 1997 65.014676
# 2002 65.694923
# 2007 67.007423
# 写法4：agg()方法（推荐，可扩展）
print(df.groupby('year').agg({"lifeExp": 'mean'}))
# 输出与写法3相同
print(df.groupby('year').agg({"lifeExp": np.mean}))
# 输出与写法3相同
四种写法对比总结
| 写法 |
代码 |
返回类型 |
特点 |
| 写法1 |
df.groupby('year').lifeExp.mean() |
Series |
最简洁，点语法 |
| 写法2 |
df.groupby('year')['lifeExp'].mean() |
Series |
括号语法，适合列名有空格 |
| 写法3 |
df.groupby('year')[['lifeExp']].mean() |
DataFrame |
双层括号，返回DataFrame |
| 写法4 |
df.groupby('year').agg({"lifeExp": 'mean'}) |
DataFrame |
最推荐，可多个字段多个函数 |
需求2：求每个年份、每个大洲的平均寿命和最高GDP
# 需求2：求每个年份，每个大洲的平均寿命和最高GDP
# 伪SQL：SELECT AVG(lifeExp), MAX(gdpPercap) FROM 表名 GROUP BY year, continent
print(df.groupby(['year', 'continent']).agg({"lifeExp": 'mean', "gdpPercap": 'max'}))
# 或
print(df.groupby(['year', 'continent']).agg({"lifeExp": np.mean, "gdpPercap": np.max}))
# 示例输出（部分）：
# lifeExp gdpPercap
# year continent
# 1952 Africa 39.135500 4725.00000
# Americas 53.279840 12000.00000
# Asia 46.317394 10000.00000
# Europe 64.408500 15000.00000
# Oceania 69.255000 12000.00000
# 1957 Africa 41.266346 5489.00000
# Americas 55.960280 13000.00000
# ...（省略）
常用聚合函数
| 函数 |
作用 |
示例 |
mean() |
平均值 |
'mean' 或 np.mean |
max() |
最大值 |
'max' 或 np.max |
min() |
最小值 |
'min' 或 np.min |
sum() |
总和 |
'sum' 或 np.sum |
count() |
计数 |
'count' |
std() |
标准差 |
'std' 或 np.std |
var() |
方差 |
'var' 或 np.var |
median() |
中位数 |
'median' |
多个聚合函数同时使用
# 对同一列使用多个聚合函数
# 球每个年份的平均寿命的平均值、最大值、最小值、标准差
print(df.groupby('year')['lifeExp'].agg(['mean', 'max', 'min', 'std']))
# 示例输出（部分）：
# mean max min std
# year
# 1952 49.057620 72.0 30.0 10.0000
# 1957 51.507401 73.0 31.0 10.0000
# 1962 53.609247 74.0 32.0 10.0000
# ...
# 对不同列使用不同聚合函数
print(df.groupby('year').agg({
'lifeExp': ['mean', 'max'],
'gdpPercap': ['mean', 'max'],
'pop': 'sum'
}))
关键知识点总结
1. groupby() 返回类型
# 分组后选择列的方式决定返回类型
df.groupby('year')['lifeExp'] # SeriesGroupBy
df.groupby('year')[['lifeExp']] # DataFrameGroupBy
df.groupby('year')[['lifeExp', 'gdpPercap']] # DataFrameGroupBy
2. 点语法 df.列名 和括号语法 df['列名']
| 语法 |
适用场景 |
df.lifeExp |
列名无空格、无特殊字符 |
df['lifeExp'] |
列名有空格、有特殊字符，或需要动态列名 |
df[['lifeExp']] |
需要返回DataFrame（单列也返回DataFrame） |
3. agg() 是万能方法
# 单个字段单个聚合
df.groupby('year').agg({"lifeExp": 'mean'})
# 单个字段多个聚合
df.groupby('year').agg({"lifeExp": ['mean', 'max', 'min']})
# 多个字段多个聚合
df.groupby('year').agg({
"lifeExp": ['mean', 'max'],
"gdpPercap": ['mean', 'max'],
"pop": 'sum'
})
# 重命名列名
df.groupby('year').agg(
平均寿命=('lifeExp', 'mean'),
最高GDP=('gdpPercap', 'max')
)
七、Pandas分组聚合：groupby() vs pivot_table()
# 1. 导包
import numpy as np
import pandas as pd
# 2. 读取文件
df = pd.read_csv('data/gapminder.txt', sep='\t')
print(df.shape) # (1704, 6)
# 3. 分析数据（分组聚合操作）
# 需求：求每个年份的平均寿命
# 方式1：groupby() + agg()
print(df.groupby('year').agg({"lifeExp": 'mean'}))
# 方式2：pivot_table() 透视表
result = df.pivot_table(index=['year'], values='lifeExp', aggfunc='mean')
print(result)
两种方式对比
| 对比项 |
groupby() + agg() |
pivot_table() |
| 语法 |
df.groupby('year').agg({"lifeExp": 'mean'}) |
df.pivot_table(index=['year'], values='lifeExp', aggfunc='mean') |
| 参数含义 |
groupby() 指定分组字段 agg() 指定聚合字段和函数 |
index 指定分组字段 values 指定聚合字段 aggfunc 指定聚合函数 |
| 返回类型 |
DataFrame |
DataFrame |
| 适用场景 |
简单分组聚合 |
类似Excel透视表习惯 |
参数说明
groupby() + agg() 写法
df.groupby('year').agg({"lifeExp": 'mean'})
# │ │ │ │
# │ │ │ └── 聚合函数
# │ │ └─────────── 聚合字段
# │ └──────────────── 聚合方法
# └─────────────────────────────── 分组字段
pivot_table() 写法
df.pivot_table(index=['year'], values='lifeExp', aggfunc='mean')
# │ │ │ │
# │ │ │ └── 聚合函数
# │ │ └───────────────── 聚合字段
# │ └─────────────────────────────── 分组字段
# └────────────────────────────────────────────── 透视表方法
两种方式等价关系
# 两者完全等价，输出结果相同
# 方式1
df.groupby('year').agg({"lifeExp": 'mean'})
# 方式2
df.pivot_table(index=['year'], values='lifeExp', aggfunc='mean')
多字段扩展写法
多分组字段
# groupby 写法
df.groupby(['year', 'continent']).agg({"lifeExp": 'mean'})
# pivot_table 写法
df.pivot_table(index=['year', 'continent'], values='lifeExp', aggfunc='mean')
多聚合字段
# groupby 写法
df.groupby('year').agg({
"lifeExp": 'mean',
"gdpPercap": 'max'
})
# pivot_table 写法
df.pivot_table(
index='year',
values=['lifeExp', 'gdpPercap'],
aggfunc={'lifeExp': 'mean', 'gdpPercap': 'max'}
)
多聚合函数
# groupby 写法
df.groupby('year').agg({"lifeExp": ['mean', 'max', 'min']})
# pivot_table 写法
df.pivot_table(
index='year',
values='lifeExp',
aggfunc=['mean', 'max', 'min']
)
选择建议
| 场景 |
推荐方式 |
| 简单分组聚合 |
groupby() + agg() |
| 习惯Excel透视表操作 |
pivot_table() |
| 需要将字段值转为列名 |
pivot_table()（加 columns 参数） |
| 追求性能 |
groupby() 通常更快 |