数据预处理_Python

若叶时代

已于 2025-05-14 18:01:39 修改

阅读量318

点赞数 10

CC 4.0 BY-SA版权

分类专栏：数据分析文章标签： python 信息可视化开发语言

于 2025-04-28 11:12:37 首次发布

本文链接：https://blog.youkuaiyun.com/weixin_43875878/article/details/147578107

数据分析专栏收录该内容

8 篇文章

订阅专栏

1 数据清洗

1.1 数据缺失

1.1.1 数值型数据缺失

(1) 识别方法

①描述性分析

import pandas as pd

# 创建示例 DataFrame
data = {
    'age': [25, None, 30, None, 40],
    'height': [170, 175, 180, 165, 185]
}
df = pd.DataFrame(data)

# 找出 age 字段数据缺失的行
# isnull()或isna()
missing_data = df[df['age'].isnull()]

print("缺失数据的行：\n", missing_data)

(2) 处理方法

①删除

# 删除列值有缺失的行
import pandas as pd

data = pd.DataFrame({
    'col1': [1, None, 3],
    'col2': ['a', 'b', None]
})

data = data.dropna(subset=['col1'])
print(data)

②填充法

import pandas as pd

# 创建包含缺失值的 DataFrame
data_missing_constant = {
    'Age': [25, None, 30, 35, None],
    'Salary': [50000, None, 60000, None, 70000],
    'Experience': [5, 10, None, 15, None],
    'Bonus': [None, 2000, 3000, None, 4000],
    'Performance': [None, 80, 90, None, 100]
}
df_missing_constant = pd.DataFrame(data_missing_constant)

# 填充规则
# 1. 常数填充
df_missing_constant['Age'] = df_missing_constant['Age'].fillna(20)

# 2. 中位数填充
median_salary = df_missing_constant['Salary'].median()
df_missing_constant['Salary'] = df_missing_constant['Salary'].fillna(median_salary)

# 3. 均值填充
mean_experience = df_missing_constant['Experience'].mean()
df_missing_constant['Experience'] = df_missing_constant['Experience'].fillna(mean_experience)

# 4. 三倍标准差法下边界填充
bonus_mean = df_missing_constant['Bonus'].mean()
bonus_std = df_missing_constant['Bonus'].std()
bonus_lower_bound = bonus_mean - 3 * bonus_std
df_missing_constant['Bonus'] = df_missing_constant['Bonus'].fillna(bonus_lower_bound)

# 5. 四分位距法下边界填充
q1 = df_missing_constant['Performance'].quantile(0.25)
q3 = df_missing_constant['Performance'].quantile(0.75)
iqr = q3 - q1
performance_lower_bound = q1 - 1.5 * iqr
df_missing_constant['Performance'] = df_missing_constant['Performance'].fillna(performance_lower_bound)

# 输出说明文字和填充后的 DataFrame
output_description = (
    "填充说明：'Age' 列使用常数 20 填充；"
    "'Salary' 列使用中位数填充；"
    "'Experience' 列使用均值填充；"
    "'Bonus' 列使用三倍标准差法下边界填充；"
    "'Performance' 列使用四分位距法下边界填充。"
)

print(output_description)
print("\n缺失值处理 - 填充后的 DataFrame:\n", df_missing_constant)

1.1.2 类别型数据缺失

1.2 数据重复

1.2.1 全字段重复

(1) 识别和处理_数据重复特征分析_基于全字段匹配

import pandas as pd

data = {
    'id': [1, 2, 2, 2, 3, 4, 4],
    'name': ['Alice', 'Bob', 'Bob', 'Bob', 'Charlie', 'David', 'David'],
    'date': ['2023 - 01 - 01', '2023 - 02 - 01', '2023 - 02 - 15', '2023 - 02 - 15', '2023 - 03 - 01', '2023 - 04 - 01', '2023 - 04 - 10']
}
df = pd.DataFrame(data)
# 将日期列转换为日期时间类型
df['date'] = pd.to_datetime(df['date'])

# 打印原始 DataFrame
print(f"原始 DataFrame:\n{df}")

# 基于全字段匹配 识别重复行
duplicate_rows = df[df.duplicated()]
# 打印重复行
print(f"\n重复的行：\n{duplicate_rows}")

# 删除完全重复的数据并打印结果
print(f"\n删除完全重复数据后的 DataFrame:\n{df.drop_duplicates()}")

1.2.2 关键字段重复

(1) 识别和处理_数据重复特征分析_基于关键字段匹配

import pandas as pd

# 创建示例 DataFrame
data = {
    'id': [1, 2, 2, 2, 3, 4, 4],
    'name': ['Alice', 'Bob', 'Bob', 'Bob', 'Charlie', 'David', 'David'],
    'date': ['2023 - 01 - 01', '2023 - 02 - 01', '2023 - 02 - 15', '2023 - 02 - 15', '2023 - 03 - 01', '2023 - 04 - 01', '2023 - 04 - 10'],
    'value': [100, 200, 250, 250, 300, 400, 450]
}
df = pd.DataFrame(data)
df['date'] = pd.to_datetime(df['date'])

# 定义关键字段
key_columns = ['id', 'name']

# 识别部分重复的行
duplicated_rows = df[df.duplicated(subset=key_columns, keep=False)]
print(f"原数据：\n{df}")
print(f"\n部分重复的数据：\n{duplicated_rows}")

# 处理部分重复数据，按 date 列取最新一条
df_processed = df.sort_values('date').drop_duplicates(subset=key_columns, keep='last')
print(f"\n部分重复时取最新一条后的 DataFrame:\n{df_processed}")

1.3 数据值异常

1.3.1 数值型数据异常

(1) 识别方法

①异常值检测_范围检查法

import pandas as pd

# 创建示例 DataFrame
data = {
    'age': [20, 25, 30, 150, 35],
    'score': [80, 90, 105, 75, 60]
}
df = pd.DataFrame(data)

# 定义各列的合理范围
ranges = {
    'age': (0, 120),
    'score': (0, 100)
}

# 查找异常值
for column, (lower_bound, upper_bound) in ranges.items():
    outliers = df[(df[column] < lower_bound) | (df[column] > upper_bound)][column]
    if not outliers.empty:
        print(f"列 {column} 的异常值: {outliers.tolist()}")
    else:
        print(f"列 {column} 没有异常值。")

②异常值检测_三倍标准差法

import pandas as pd
import numpy as np

# 创建包含多列的示例 DataFrame，修改 col1 数据
data = {
    'col1': [2, 3, 4, 3, 5, 4, 6, 3, 4, 5, 50],
    'col2': [10, 20, 30, 40, 50, 60, 70, 80, 90, 100, 110]
}
df = pd.DataFrame(data)

# 计算 col1 列的均值与标准差
mean = df['col1'].mean()
std = df['col1'].std()

# 计算下限和上限
lower_bound = mean - 3 * std
upper_bound = mean + 3 * std

# 找出异常值
outliers = df[(df['col1'] < lower_bound) | (df['col1'] > upper_bound)][
    'col1'].tolist()

print("原始数据:")
print(df)
print(f"\n正在处理的列: col1")
print(f"该列均值: {mean:.2f}")
print(f"该列标准差: {std:.2f}")
print(f"下限: {lower_bound:.2f}")
print(f"上限: {upper_bound:.2f}")
print(f"异常值: {outliers}")

③异常值检测_四分位距法

import pandas as pd
import numpy as np

# 创建一个包含两列的 DataFrame 示例数据
data = {
    'col1': [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 100],
    'col2': [101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 200]
}
df = pd.DataFrame(data)

# 计算第一四分位数（Q1）和第三四分位数（Q3）
q1 = np.percentile(df['col1'], 25)
q3 = np.percentile(df['col1'], 75)

# 计算四分位距（IQR）
iqr = q3 - q1

# 计算下限和上限
lower_bound = q1 - 1.5 * iqr
upper_bound = q3 + 1.5 * iqr

# 找出异常值
outliers = df['col1'][(df['col1'] < lower_bound) | (df['col1'] > upper_bound)]

print("原始数据:")
print(df)
print("第一四分位数 (Q1):", q1)
print("第三四分位数 (Q3):", q3)
print("四分位距 (IQR):", iqr)
print("下限:", lower_bound)
print("上限:", upper_bound)
print("异常值:", outliers.values)

(2) 处理方法

①基于异常值检测的删除

import pandas as pd

# 示例数据
data = pd.DataFrame({
    'A': [1, 2, 3, 4, 5, 6, 7, 8, 9, 100],
    'B': [10, 20, 30, 40, 50, 60, 70, 80, 90, 1000]
})

# 计算字段 A 的第一四分位数（Q1）和第三四分位数（Q3）
Q1 = data['A'].quantile(0.25)
Q3 = data['A'].quantile(0.75)

# 计算四分位距（IQR）
IQR = Q3 - Q1

# 定义异常值的上下边界
lower_bound = Q1 - 1.5 * IQR
upper_bound = Q3 + 1.5 * IQR

# 筛选出字段 A 中不在异常值范围内的数据
filtered_data = data[(data['A'] >= lower_bound) & (data['A'] <= upper_bound)]

# 输出结果
print("处理前的数据：", data)
print("处理后的数据：", filtered_data)

1.3.2 类别型数据异常

(1) 识别方法

①分布分析

import pandas as pd

# 构造示例数据，包含两个字段，我们只分析category_column字段
data = {
    'category_column': ['A', 'B', 'A', None, 'C', 'D', 'A', 'B', 'E'],
    'another_column': [10, 20, 10, 30, 40, 50, 10, 20, 60]
}
df = pd.DataFrame(data)

# 统计category_column字段每个取值的数量
# dropna=False:把缺失值也纳入统计范围
value_counts = df['category_column'].value_counts(dropna=False)
print(value_counts)

# 根据数量判断异常（例如，出现次数过少的可能是异常值，缺失值数量过多也需关注）
# 这里简单设定出现次数小于2的可能是异常值，可根据实际情况调整
print("可能的异常值：", value_counts[value_counts < 2].index.tolist())
print("缺失值数量：", df['category_column'].isnull().sum())

②合规性检查_数据字典匹配

import pandas as pd


def dictionary_method(data, column, valid_values):
    """
    此函数使用字典法识别分类型数据的异常值
    :param data: 包含分类型数据的 DataFrame
    :param column: 需要检查的列名
    :param valid_values: 合法取值列表
    :return: 包含异常值的 DataFrame
    """
    return data[~data[column].isin(valid_values)]


# 示例数据，包含两列
data = {
    'category': ['A', 'B', 'A', 'C', 'D', 'B', 'E', 'A', 'B', 'F', None],
    'other_column': [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]
}
df = pd.DataFrame(data)

# 打印原始数据
print("原始数据:", df)

# 合法取值列表
valid_values = ['A', 'B', 'C']
outliers_dict = dictionary_method(df, 'category', valid_values)
print("字典法识别的异常值:", outliers_dict)

1.4 数据格式异常

(1) 日期格式异常、数值格式异常和文本格式异常

import pandas as pd

data = {
  'sale_date': ['2025-04-01', '2025-1-5', '2025-05-01','2025-07-01'],
    'amount': ["1,000.50", "1000.50", "1010.50","2000.00"],
    'product_name': ['   space at start', 'UPPERCASE', '&embedded special char']
}
df = pd.DataFrame(data)

print("原始数据:")
print(df)

# 处理sale_date列，转换为日期时间格式
df['sale_date'] = pd.to_datetime(df['sale_date'])
# 处理amount列，去除逗号并转换为浮点数
df['amount'] = df['amount'].str.replace(',', '').astype(float)
# 处理product_name列，去掉首位空格、替换&字符并转小写
df['product_name'] = df['product_name'].str.strip().str.replace('&', '').str.lower()

print("处理后的数据:")
print(df)

2 数据转换

2.1 隐私数据转换

import pandas as pd

data = {
    'name': ['Alice', 'Bob'],
   'mobile': ['13800138001', '13900139002']
}
df = pd.DataFrame(data)

print(f"原始数据:\n{df}")

df['mobile'] = df['mobile'].str[: - 4]+'****'

print(f"加密后的数据:\n{df}")

3 数据集成

3.1 数据源集成

① 按行合并

import pandas as pd

# 创建示例DataFrame1
data1 = {
    'col1': [1, 2],
    'col2': ['a', 'b']
}
df1 = pd.DataFrame(data1)

# 创建示例DataFrame2
data2 = {
    'col1': [3, 4],
    'col2': ['c', 'd']
}
df2 = pd.DataFrame(data2)

print(f"合并前的DataFrame1:\n{df1}")
print(f"合并前的DataFrame2:\n{df2}")

# axis = 0:按行合并
result = pd.concat([df1, df2], axis = 0)
# 指定数据类型
result['col1'] = result['col1'].astype('float64')
result['col2'] = result['col2'].astype('string')
# 重命名列
result = result.rename(columns = {'col1': 'new_col1', 'col2': 'new_col2'})

print(f"\n合并后的数据:\n{result}")

②按列合并

import pandas as pd

# 创建示例DataFrame1
data1 = {
    'col1': [1, 2],
    'col2': ['a', 'b']
}
df1 = pd.DataFrame(data1)

# 创建示例DataFrame2
data2 = {
    'col3': [3, 4],
    'col4': ['c', 'd']
}
df2 = pd.DataFrame(data2)

print(f"合并前的DataFrame1:\n{df1}")
print(f"合并前的DataFrame2:\n{df2}")

# 按列合并
result = pd.concat([df1, df2], axis = 1)
# 指定数据类型
result['col1'] = result['col1'].astype('float64')
result['col2'] = result['col2'].astype('string')
result['col3'] = result['col3'].astype('float64')
result['col4'] = result['col4'].astype('string')
# 重命名列
result = result.rename(columns = {'col1': 'new_col1', 'col2': 'new_col2', 'col3': 'new_col3', 'col4': 'new_col4'})

print(f"\n合并后的数据:\n{result}")