简体中文 繁體中文 English Deutsch 한국 사람 بالعربية TÜRKÇE português คนไทย Français Japanese

开启辅助访问 切换到宽版

站内搜索

搜索

活动公告

通知：本站资源由网友上传分享，如有违规等问题请到版务模块进行投诉，将及时处理！
10-23 09:31
>社区 > 科技 > 经验交流 >帖子
本版发帖返回

pandas数据清洗入门教程新手必备的数据处理技能从零开始学起轻松应对数据分析中的各种清洗问题提升工作效率

威震华夏关云长
SunJu_FaceMall

3万

主题

166

科技点

3万

积分

大区版主

碾压王

积分
32106
发表于 2025-8-27 11:20:00 | 显示全部楼层 |阅读模式 [标记阅至此楼]

马上注册，结交更多好友，享用更多功能，让你轻松玩转社区。

您需要 登录 才可以下载或查看，没有账号？立即注册

x
引言

在数据分析的旅程中，数据清洗是最基础也是最关键的一步。俗话说”垃圾进，垃圾出”，无论你的分析模型多么复杂，如果输入的数据质量不高，结果也必然不可靠。据估计，数据科学家通常花费60%-80%的时间在数据清洗和准备工作上。掌握高效的数据清洗技能，不仅能提高你的工作效率，还能确保后续分析的准确性和可靠性。

pandas作为Python生态中最强大的数据处理库，提供了丰富而灵活的工具来应对各种数据清洗挑战。本教程将从零开始，带你逐步掌握pandas数据清洗的核心技能，帮助你轻松应对数据分析中的各种清洗问题。

pandas基础

在开始数据清洗之前，我们需要先了解pandas的基本概念和数据结构。

安装和导入pandas

如果你还没有安装pandas，可以通过以下命令安装：
  2. pip install pandas
复制代码

安装完成后，我们可以在Python脚本中导入pandas：
  2. import pandas as pd
  3. import numpy as np  # 通常与pandas一起使用
复制代码

pandas的核心数据结构

pandas有两个核心数据结构：Series和DataFrame。

Series：一维标记数组，能够保存任何数据类型（整数、字符串、浮点数、Python对象等）。
  2. # 创建一个Series
  3. s = pd.Series([1, 3, 5, np.nan, 6, 8])
  4. print(s)
复制代码

输出：
  2. 0    1.0
  3. 1    3.0
  4. 2    5.0
  5. 3    NaN
  6. 4    6.0
  7. 5    8.0
  8. dtype: float64
复制代码

DataFrame：二维标记数据结构，可以看作是一个表格或Series对象的集合。
  2. # 创建一个DataFrame
  3. data = {'Name': ['Tom', 'Nick', 'John', 'Tom'],
  4.         'Age': [20, 21, 19, 20],
  5.         'Score': [85.5, 90.0, 76.5, 85.5]}
  6. df = pd.DataFrame(data)
  7. print(df)
复制代码

输出：
  2. Name  Age  Score
  3. 0   Tom   20   85.5
  4. 1  Nick   21   90.0
  5. 2  John   19   76.5
  6. 3   Tom   20   85.5
复制代码

数据加载与初步检查

数据清洗的第一步是加载数据并进行初步检查，了解数据的基本情况。

加载数据

pandas支持多种数据格式的加载，包括CSV、Excel、SQL数据库等。
  2. # 从CSV文件加载数据
  3. df = pd.read_csv('data.csv')
  5. # 从Excel文件加载数据
  6. df = pd.read_excel('data.xlsx')
  8. # 从SQL数据库加载数据
  9. import sqlite3
  10. conn = sqlite3.connect('database.db')
  11. df = pd.read_sql('SELECT * FROM table_name', conn)
复制代码

查看数据基本信息

加载数据后，我们需要查看数据的基本信息，包括数据维度、前几行、数据类型等。
  2. # 查看数据维度（行数和列数）
  3. print(df.shape)
  5. # 查看前5行数据
  6. print(df.head())
  8. # 查看后5行数据
  9. print(df.tail())
  11. # 查看数据的基本信息
  12. print(df.info())
  14. # 查看数据的统计摘要
  15. print(df.describe())
  17. # 查看各列的数据类型
  18. print(df.dtypes)
复制代码

示例：加载数据集并初步检查

让我们使用pandas内置的泰坦尼克号数据集作为示例：
  2. # 加载泰坦尼克号数据集
  3. df = pd.read_csv('https://raw.githubusercontent.com/datasciencedojo/datasets/master/titanic.csv')
  5. # 查看数据维度
  6. print(f"数据维度: {df.shape}")
  8. # 查看前5行数据
  9. print("\n前5行数据:")
  10. print(df.head())
  12. # 查看数据基本信息
  13. print("\n数据基本信息:")
  14. df.info()
  16. # 查看数值型列的统计摘要
  17. print("\n数值型列的统计摘要:")
  18. print(df.describe())
复制代码

通过这些初步检查，我们可以了解到数据的基本情况，包括数据量、列名、数据类型、缺失值情况等，为后续的数据清洗工作奠定基础。

处理缺失值

缺失值是数据清洗中最常见的问题之一。pandas中缺失值通常表示为NaN（Not a Number）。

检测缺失值
  2. # 检查每列的缺失值数量
  3. print(df.isnull().sum())
  5. # 检查整个数据框的缺失值数量
  6. print(df.isnull().sum().sum())
  8. # 检查哪些行包含缺失值
  9. print(df[df.isnull().any(axis=1)])
  11. # 检查每列的缺失值比例
  12. missing_percentage = df.isnull().mean() * 100
  13. print(missing_percentage)
复制代码

处理缺失值的方法

处理缺失值有几种常见策略：删除、填充和插值。
  2. # 删除包含缺失值的行
  3. df_dropna_rows = df.dropna()
  5. # 删除包含缺失值的列
  6. df_dropna_cols = df.dropna(axis=1)
  8. # 删除所有值都为缺失值的行
  9. df_dropna_all = df.dropna(how='all')
  11. # 删除至少有n个非缺失值的行
  12. df_dropna_thresh = df.dropna(thresh=5)  # 至少有5个非缺失值的行才会被保留
复制代码
  2. # 用特定值填充缺失值
  3. df_filled = df.fillna(0)
  5. # 用列的平均值填充缺失值（仅适用于数值型列）
  6. df_mean_filled = df.fillna(df.mean())
  8. # 用列的中位数填充缺失值（仅适用于数值型列）
  9. df_median_filled = df.fillna(df.median())
  11. # 用众数填充缺失值（适用于分类数据）
  12. df_mode_filled = df.fillna(df.mode().iloc[0])
  14. # 用前一个值填充缺失值（向前填充）
  15. df_ffill = df.fillna(method='ffill')
  17. # 用后一个值填充缺失值（向后填充）
  18. df_bfill = df.fillna(method='bfill')
  20. # 对不同的列使用不同的填充策略
  21. df_specific_fill = df.fillna({
  22.     'Age': df['Age'].median(),
  23.     'Cabin': 'Unknown',
  24.     'Embarked': df['Embarked'].mode()[0]
  25. })
复制代码
  2. # 线性插值
  3. df_linear = df.interpolate()
  5. # 时间序列数据的插值
  6. # 如果有日期时间索引，可以使用时间插值
  7. df_time = df.interpolate(method='time')
  9. # 多项式插值
  10. df_poly = df.interpolate(method='polynomial', order=2)
复制代码

示例：处理泰坦尼克号数据集中的缺失值

让我们继续使用泰坦尼克号数据集来处理缺失值：
  2. # 加载数据
  3. df = pd.read_csv('https://raw.githubusercontent.com/datasciencedojo/datasets/master/titanic.csv')
  5. # 检查缺失值
  6. print("缺失值统计:")
  7. print(df.isnull().sum())
  9. # 处理Age列的缺失值：使用中位数填充
  10. df['Age'].fillna(df['Age'].median(), inplace=True)
  12. # 处理Cabin列的缺失值：填充为'Unknown'
  13. df['Cabin'].fillna('Unknown', inplace=True)
  15. # 处理Embarked列的缺失值：使用众数填充
  16. df['Embarked'].fillna(df['Embarked'].mode()[0], inplace=True)
  18. # 再次检查缺失值
  19. print("\n处理后的缺失值统计:")
  20. print(df.isnull().sum())
复制代码

处理重复值

重复值是数据清洗中另一个常见问题，它们可能会影响数据分析的结果。

检测重复值
  2. # 检查是否有重复行
  3. print(df.duplicated().sum())
  5. # 查看重复行
  6. print(df[df.duplicated()])
  8. # 基于特定列检查重复值
  9. print(df.duplicated(subset=['Name']).sum())
复制代码

处理重复值
  2. # 删除所有重复行
  3. df_drop_duplicates = df.drop_duplicates()
  5. # 删除基于特定列的重复行，保留第一个出现的行
  6. df_drop_subset_first = df.drop_duplicates(subset=['Name'], keep='first')
  8. # 删除基于特定列的重复行，保留最后一个出现的行
  9. df_drop_subset_last = df.drop_duplicates(subset=['Name'], keep='last')
  11. # 删除所有重复行（不保留任何重复行）
  12. df_drop_all = df.drop_duplicates(subset=['Name'], keep=False)
复制代码

示例：处理重复值
  2. # 创建一个包含重复值的示例数据框
  3. data = {'Name': ['Tom', 'Nick', 'John', 'Tom', 'Alice', 'Nick'],
  4.         'Age': [20, 21, 19, 20, 22, 21],
  5.         'Score': [85.5, 90.0, 76.5, 85.5, 88.0, 90.0]}
  6. df = pd.DataFrame(data)
  8. print("原始数据:")
  9. print(df)
  11. # 检查重复行
  12. print("\n重复行数量:", df.duplicated().sum())
  14. # 删除重复行
  15. df_clean = df.drop_duplicates()
  17. print("\n删除重复行后的数据:")
  18. print(df_clean)
复制代码

数据类型转换

正确的数据类型对于数据分析至关重要。在数据清洗过程中，我们经常需要转换列的数据类型。

查看数据类型
  2. # 查看各列的数据类型
  3. print(df.dtypes)
  5. # 查看数据类型的唯一值
  6. for col in df.columns:
  7.     print(f"{col}: {df[col].dtype}")
复制代码

转换数据类型
  2. # 转换为数值类型
  3. df['Age'] = pd.to_numeric(df['Age'], errors='coerce')  # errors='coerce'将无法转换的值设为NaN
  5. # 转换为整数类型
  6. df['Age'] = df['Age'].astype(int)
  8. # 转换为浮点数类型
  9. df['Score'] = df['Score'].astype(float)
  11. # 转换为字符串类型
  12. df['Name'] = df['Name'].astype(str)
  14. # 转换为日期时间类型
  15. df['Date'] = pd.to_datetime(df['Date'])
  17. # 转换为分类类型（适用于具有有限个唯一值的列）
  18. df['Gender'] = df['Gender'].astype('category')
复制代码

处理混合类型

有时，一列中可能包含混合的数据类型，这需要我们进行特殊处理。
  2. # 假设Price列包含字符串和数值，如"$100", "200", "¥300"
  3. # 首先转换为字符串，然后移除非数字字符，最后转换为数值
  4. df['Price'] = df['Price'].astype(str).str.replace(r'[^\d.]', '', regex=True)
  5. df['Price'] = pd.to_numeric(df['Price'], errors='coerce')
复制代码

示例：数据类型转换
  2. # 创建一个包含混合数据类型的示例数据框
  3. data = {'Name': ['Tom', 'Nick', 'John'],
  4.         'Age': ['20', '21', '19'],  # 字符串类型的年龄
  5.         'Score': ['85.5', '90.0', '76.5'],  # 字符串类型的分数
  6.         'Date': ['2021-01-01', '2021-02-01', '2021-03-01'],  # 字符串类型的日期
  7.         'Member': ['Yes', 'No', 'Yes']}  # 字符串类型的布尔值
  8. df = pd.DataFrame(data)
  10. print("原始数据类型:")
  11. print(df.dtypes)
  13. # 转换数据类型
  14. df['Age'] = df['Age'].astype(int)
  15. df['Score'] = df['Score'].astype(float)
  16. df['Date'] = pd.to_datetime(df['Date'])
  17. df['Member'] = df['Member'].map({'Yes': True, 'No': False})
  19. print("\n转换后的数据类型:")
  20. print(df.dtypes)
复制代码

异常值处理

异常值是数据集中与其他观测值显著不同的数据点。它们可能是测量错误、数据录入错误或真正的异常情况。处理异常值是数据清洗的重要一步。

检测异常值
  2. # 查看数值列的统计摘要
  3. print(df.describe())
  5. # 计算四分位数和IQR（四分位距）
  6. Q1 = df['Age'].quantile(0.25)
  7. Q3 = df['Age'].quantile(0.75)
  8. IQR = Q3 - Q1
  10. # 定义异常值的边界
  11. lower_bound = Q1 - 1.5 * IQR
  12. upper_bound = Q3 + 1.5 * IQR
  14. # 找出异常值
  15. outliers = df[(df['Age'] < lower_bound) | (df['Age'] > upper_bound)]
  16. print("Age列的异常值:")
  17. print(outliers)
复制代码
  2. import matplotlib.pyplot as plt
  3. import seaborn as sns
  5. # 箱线图
  6. plt.figure(figsize=(10, 6))
  7. sns.boxplot(x=df['Age'])
  8. plt.title('Age列的箱线图')
  9. plt.show()
  11. # 直方图
  12. plt.figure(figsize=(10, 6))
  13. plt.hist(df['Age'], bins=30)
  14. plt.title('Age列的直方图')
  15. plt.show()
  17. # 散点图
  18. plt.figure(figsize=(10, 6))
  19. plt.scatter(df.index, df['Age'])
  20. plt.title('Age列的散点图')
  21. plt.show()
复制代码

处理异常值
  2. # 删除异常值
  3. df_no_outliers = df[(df['Age'] >= lower_bound) & (df['Age'] <= upper_bound)]
复制代码
  2. # 用边界值替换异常值（截尾）
  3. df_capped = df.copy()
  4. df_capped['Age'] = np.where(df_capped['Age'] < lower_bound, lower_bound,
  5.                            np.where(df_capped['Age'] > upper_bound, upper_bound, df_capped['Age']))
  7. # 用中位数替换异常值
  8. median_age = df['Age'].median()
  9. df_median_replaced = df.copy()
  10. df_median_replaced['Age'] = np.where((df_median_replaced['Age'] < lower_bound) |
  11.                                    (df_median_replaced['Age'] > upper_bound),
  12.                                    median_age, df_median_replaced['Age'])
复制代码
  2. from scipy import stats
  4. # 计算Z-score
  5. z_scores = np.abs(stats.zscore(df['Age']))
  7. # 定义阈值（通常为3）
  8. threshold = 3
  10. # 找出异常值
  11. outliers = df[z_scores > threshold]
  12. print("使用Z-score方法检测到的异常值:")
  13. print(outliers)
  15. # 删除异常值
  16. df_no_z_outliers = df[z_scores <= threshold]
复制代码

示例：处理异常值
  2. # 创建一个包含异常值的示例数据框
  3. np.random.seed(42)
  4. data = {'Name': ['Tom', 'Nick', 'John', 'Alice', 'Bob', 'Charlie', 'David', 'Eva'],
  5.         'Age': [20, 21, 19, 22, 20, 150, 18, 21],  # 150是一个明显的异常值
  6.         'Score': [85.5, 90.0, 76.5, 88.0, 85.5, 92.0, 79.5, 90.0]}
  7. df = pd.DataFrame(data)
  9. print("原始数据:")
  10. print(df)
  12. # 使用箱线图可视化Age列
  13. plt.figure(figsize=(10, 6))
  14. sns.boxplot(x=df['Age'])
  15. plt.title('Age列的箱线图')
  16. plt.show()
  18. # 使用IQR方法检测异常值
  19. Q1 = df['Age'].quantile(0.25)
  20. Q3 = df['Age'].quantile(0.75)
  21. IQR = Q3 - Q1
  22. lower_bound = Q1 - 1.5 * IQR
  23. upper_bound = Q3 + 1.5 * IQR
  25. outliers = df[(df['Age'] < lower_bound) | (df['Age'] > upper_bound)]
  26. print("\n检测到的异常值:")
  27. print(outliers)
  29. # 用中位数替换异常值
  30. median_age = df['Age'].median()
  31. df_clean = df.copy()
  32. df_clean['Age'] = np.where((df_clean['Age'] < lower_bound) | (df_clean['Age'] > upper_bound),
  33.                           median_age, df_clean['Age'])
  35. print("\n处理异常值后的数据:")
  36. print(df_clean)
复制代码

字符串处理

文本数据清洗是数据预处理的重要组成部分。pandas提供了强大的字符串处理功能，可以帮助我们高效地清洗文本数据。

基本字符串操作
  2. # 转换为小写
  3. df['Name'] = df['Name'].str.lower()
  5. # 转换为大写
  6. df['Name'] = df['Name'].str.upper()
  8. # 首字母大写
  9. df['Name'] = df['Name'].str.title()
  11. # 去除前后空格
  12. df['Name'] = df['Name'].str.strip()
  14. # 去除所有空格
  15. df['Name'] = df['Name'].str.replace(' ', '')
  17. # 替换子字符串
  18. df['Name'] = df['Name'].str.replace('Mr.', 'Mister')
复制代码

高级字符串操作
  2. # 提取数字
  3. df['Numbers'] = df['Text'].str.extract('(\d+)')
  5. # 提取特定模式的文本
  6. df['Email'] = df['Text'].str.extract('([a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,})')
  8. # 分割字符串
  9. df['First_Name'] = df['Full_Name'].str.split(' ').str[0]
  10. df['Last_Name'] = df['Full_Name'].str.split(' ').str[-1]
  12. # 检查字符串是否包含特定子字符串
  13. df['Has_Mr'] = df['Name'].str.contains('Mr', case=False)
  15. # 检查字符串是否以特定子字符串开头
  16. df['Starts_With_A'] = df['Name'].str.startswith('A')
  18. # 检查字符串是否以特定子字符串结尾
  19. df['Ends_With_E'] = df['Name'].str.endswith('e')
  21. # 计算字符串长度
  22. df['Name_Length'] = df['Name'].str.len()
复制代码

正则表达式应用
  2. # 使用正则表达式进行复杂匹配
  3. # 提取所有大写字母
  4. df['Uppercase'] = df['Text'].str.findall('[A-Z]')
  6. # 提取所有单词
  7. df['Words'] = df['Text'].str.findall('\b\w+\b')
  9. # 替换所有非字母字符
  10. df['Letters_Only'] = df['Text'].str.replace('[^a-zA-Z]', ' ')
  12. # 提取连续的数字
  13. df['Numbers'] = df['Text'].str.extract('(\d+)')
复制代码

示例：清洗文本数据
  2. # 创建一个包含脏文本数据的示例数据框
  3. data = {'Full_Name': ['  Mr. John Doe  ', ' Ms. Jane Smith ', 'Dr. Robert Johnson', 'mrs. Emily Davis'],
  4.         'Email': ['john.doe@example.com', 'jane.smith@example.com', 'invalid-email', 'emily.davis@example.com'],
  5.         'Phone': ['(123) 456-7890', '123.456.7890', '1234567890', '123-456-7890'],
  6.         'Address': ['123 Main St, Anytown, USA', '456 Oak Ave, Somewhere, Canada', '789 Pine Rd, Nowhere, UK', '']}
  7. df = pd.DataFrame(data)
  9. print("原始数据:")
  10. print(df)
  12. # 清洗Full_Name列
  13. df['Full_Name'] = df['Full_Name'].str.strip()  # 去除前后空格
  14. df['Title'] = df['Full_Name'].str.extract('(Mr|Ms|Dr|Mrs)\.', flags=re.IGNORECASE)  # 提取称谓
  15. df['Title'] = df['Title'].str.title()  # 首字母大写
  16. df['First_Name'] = df['Full_Name'].str.split().str[1]  # 提取名字
  17. df['Last_Name'] = df['Full_Name'].str.split().str[2]  # 提取姓氏
  19. # 清洗Email列
  20. df['Valid_Email'] = df['Email'].str.contains('[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}', regex=True)
  22. # 清洗Phone列
  23. df['Phone'] = df['Phone'].str.replace('[^\d]', '', regex=True)  # 移除非数字字符
  24. df['Phone'] = df['Phone'].str.replace('^(\d{3})(\d{3})(\d{4})$', r'(\1) \2-\3', regex=True)  # 格式化为(123) 456-7890
  26. # 清洗Address列
  27. df['Address'] = df['Address'].replace('', np.nan)  # 将空字符串替换为NaN
  29. print("\n清洗后的数据:")
  30. print(df[['Title', 'First_Name', 'Last_Name', 'Email', 'Valid_Email', 'Phone', 'Address']])
复制代码

数据转换

数据转换是数据清洗过程中的重要环节，包括标准化、归一化、编码分类变量等操作，使数据适合于分析和建模。

标准化和归一化

标准化将数据转换为均值为0，标准差为1的分布。
  2. from sklearn.preprocessing import StandardScaler
  4. # 创建标准化器
  5. scaler = StandardScaler()
  7. # 标准化数值列
  8. df['Age_Standardized'] = scaler.fit_transform(df[['Age']])
  10. # 或者手动计算
  11. df['Age_Standardized_Manual'] = (df['Age'] - df['Age'].mean()) / df['Age'].std()
复制代码

归一化将数据缩放到[0, 1]区间。
  2. from sklearn.preprocessing import MinMaxScaler
  4. # 创建归一化器
  5. scaler = MinMaxScaler()
  7. # 归一化数值列
  8. df['Age_Normalized'] = scaler.fit_transform(df[['Age']])
  10. # 或者手动计算
  11. df['Age_Normalized_Manual'] = (df['Age'] - df['Age'].min()) / (df['Age'].max() - df['Age'].min())
复制代码

编码分类变量

标签编码将每个类别映射到一个整数。
  2. from sklearn.preprocessing import LabelEncoder
  4. # 创建标签编码器
  5. le = LabelEncoder()
  7. # 对分类列进行标签编码
  8. df['Gender_Encoded'] = le.fit_transform(df['Gender'])
  10. # 或者使用pandas的factorize方法
  11. df['Gender_Encoded'] = pd.factorize(df['Gender'])[0]
复制代码

独热编码为每个类别创建一个新的二进制列。
  2. # 使用pandas的get_dummies方法
  3. one_hot = pd.get_dummies(df['Gender'], prefix='Gender')
  4. df = pd.concat([df, one_hot], axis=1)
  6. # 或者使用sklearn的OneHotEncoder
  7. from sklearn.preprocessing import OneHotEncoder
  9. # 创建独热编码器
  10. encoder = OneHotEncoder(sparse=False)
  12. # 对分类列进行独热编码
  13. one_hot = encoder.fit_transform(df[['Gender']])
  14. # 创建DataFrame
  15. one_hot_df = pd.DataFrame(one_hot, columns=encoder.get_feature_names(['Gender']))
  16. # 合并到原始DataFrame
  17. df = pd.concat([df, one_hot_df], axis=1)
复制代码

分箱（Binning）

分箱是将连续变量转换为分类变量的过程。
  2. # 等宽分箱
  3. df['Age_Bin'] = pd.cut(df['Age'], bins=3, labels=['Young', 'Middle', 'Old'])
  5. # 等频分箱
  6. df['Age_Bin'] = pd.qcut(df['Age'], q=3, labels=['Young', 'Middle', 'Old'])
  8. # 自定义分箱
  9. bins = [0, 18, 35, 60, 100]
  10. labels = ['Child', 'Young Adult', 'Adult', 'Senior']
  11. df['Age_Bin'] = pd.cut(df['Age'], bins=bins, labels=labels)
复制代码

特征工程
  2. # 从日期特征中提取年、月、日
  3. df['Year'] = df['Date'].dt.year
  4. df['Month'] = df['Date'].dt.month
  5. df['Day'] = df['Date'].dt.day
  6. df['DayOfWeek'] = df['Date'].dt.dayofweek
  8. # 从文本特征中提取信息
  9. df['Name_Length'] = df['Name'].str.len()
  10. df['Name_Words'] = df['Name'].str.split().str.len()
  12. # 创建交互特征
  13. df['Age_Score_Interaction'] = df['Age'] * df['Score']
复制代码
  2. # 对数变换（常用于处理偏态分布）
  3. df['Age_Log'] = np.log(df['Age'])
  5. # 平方根变换
  6. df['Age_Sqrt'] = np.sqrt(df['Age'])
  8. # 平方变换
  9. df['Age_Squared'] = df['Age'] ** 2
复制代码

示例：数据转换
  2. # 创建一个示例数据框
  3. data = {'Name': ['Tom', 'Nick', 'John', 'Alice', 'Bob'],
  4.         'Age': [20, 21, 19, 22, 20],
  5.         'Gender': ['Male', 'Male', 'Male', 'Female', 'Male'],
  6.         'Score': [85.5, 90.0, 76.5, 88.0, 85.5],
  7.         'Date': ['2021-01-01', '2021-02-01', '2021-03-01', '2021-04-01', '2021-05-01']}
  8. df = pd.DataFrame(data)
  10. # 转换日期列
  11. df['Date'] = pd.to_datetime(df['Date'])
  13. print("原始数据:")
  14. print(df)
  16. # 标准化Age列
  17. df['Age_Standardized'] = (df['Age'] - df['Age'].mean()) / df['Age'].std()
  19. # 归一化Score列
  20. df['Score_Normalized'] = (df['Score'] - df['Score'].min()) / (df['Score'].max() - df['Score'].min())
  22. # 对Gender列进行独热编码
  23. one_hot = pd.get_dummies(df['Gender'], prefix='Gender')
  24. df = pd.concat([df, one_hot], axis=1)
  26. # 从Date列提取特征
  27. df['Year'] = df['Date'].dt.year
  28. df['Month'] = df['Date'].dt.month
  29. df['Day'] = df['Date'].dt.day
  30. df['DayOfWeek'] = df['Date'].dt.dayofweek
  32. # 创建Age的分箱
  33. df['Age_Bin'] = pd.cut(df['Age'], bins=[0, 18, 25, 100], labels=['Teen', 'Young Adult', 'Adult'])
  35. # 创建交互特征
  36. df['Age_Score_Interaction'] = df['Age'] * df['Score']
  38. print("\n转换后的数据:")
  39. print(df)
复制代码

实战案例：一个完整的数据清洗示例

让我们通过一个完整的例子来应用我们学到的数据清洗技能。我们将使用一个模拟的电子商务数据集，该数据集包含客户信息、订单详情和产品信息。

1. 加载数据并初步检查
  2. # 创建模拟数据
  3. np.random.seed(42)
  5. # 客户数据
  6. customers = pd.DataFrame({
  7.     'CustomerID': range(1, 1001),
  8.     'Name': [f'Customer_{i}' for i in range(1, 1001)],
  9.     'Age': np.random.randint(18, 70, 1000),
  10.     'Gender': np.random.choice(['Male', 'Female', 'Other'], 1000),
  11.     'Email': [f'customer{i}@example.com' for i in range(1, 1001)],
  12.     'RegistrationDate': pd.date_range('2020-01-01', periods=1000, freq='D')
  13. })
  15. # 订单数据
  16. orders = pd.DataFrame({
  17.     'OrderID': range(1, 2001),
  18.     'CustomerID': np.random.randint(1, 1001, 2000),
  19.     'OrderDate': pd.date_range('2021-01-01', periods=2000, freq='6H'),
  20.     'ProductID': np.random.randint(1, 101, 2000),
  21.     'Quantity': np.random.randint(1, 10, 2000),
  22.     'Price': np.round(np.random.uniform(10, 500, 2000), 2)
  23. })
  25. # 产品数据
  26. products = pd.DataFrame({
  27.     'ProductID': range(1, 101),
  28.     'ProductName': [f'Product_{i}' for i in range(1, 101)],
  29.     'Category': np.random.choice(['Electronics', 'Clothing', 'Books', 'Home', 'Sports'], 100),
  30.     'Description': [f'Description for Product_{i}' for i in range(1, 101)]
  31. })
  33. # 引入一些数据质量问题
  34. # 在customers中引入一些缺失值
  35. customers.loc[np.random.choice(customers.index, 50, replace=False), 'Age'] = np.nan
  36. customers.loc[np.random.choice(customers.index, 30, replace=False), 'Gender'] = np.nan
  38. # 在orders中引入一些重复行
  39. orders = pd.concat([orders, orders.sample(50)], ignore_index=True)
  41. # 在orders中引入一些异常值
  42. orders.loc[np.random.choice(orders.index, 20, replace=False), 'Price'] = np.random.uniform(1000, 5000, 20)
  43. orders.loc[np.random.choice(orders.index, 10, replace=False), 'Quantity'] = np.random.randint(50, 100, 10)
  45. # 在products中引入一些不一致的产品名称
  46. products.loc[np.random.choice(products.index, 10, replace=False), 'ProductName'] = products.loc[np.random.choice(products.index, 10, replace=False), 'ProductName'].str.lower()
  48. # 保存数据到CSV文件
  49. customers.to_csv('customers.csv', index=False)
  50. orders.to_csv('orders.csv', index=False)
  51. products.to_csv('products.csv', index=False)
复制代码
  2. # 加载数据
  3. customers = pd.read_csv('customers.csv')
  4. orders = pd.read_csv('orders.csv')
  5. products = pd.read_csv('products.csv')
  7. # 初步检查
  8. print("Customers数据维度:", customers.shape)
  9. print("\nCustomers前5行:")
  10. print(customers.head())
  11. print("\nCustomers数据信息:")
  12. customers.info()
  14. print("\nOrders数据维度:", orders.shape)
  15. print("\nOrders前5行:")
  16. print(orders.head())
  17. print("\nOrders数据信息:")
  18. orders.info()
  20. print("\nProducts数据维度:", products.shape)
  21. print("\nProducts前5行:")
  22. print(products.head())
  23. print("\nProducts数据信息:")
  24. products.info()
复制代码

2. 清洗Customers数据
  2. # 处理缺失值
  3. print("\nCustomers缺失值统计:")
  4. print(customers.isnull().sum())
  6. # 用中位数填充Age的缺失值
  7. customers['Age'].fillna(customers['Age'].median(), inplace=True)
  9. # 用众数填充Gender的缺失值
  10. customers['Gender'].fillna(customers['Gender'].mode()[0], inplace=True)
  12. # 检查处理后的缺失值
  13. print("\n处理后的Customers缺失值统计:")
  14. print(customers.isnull().sum())
  16. # 处理日期列
  17. customers['RegistrationDate'] = pd.to_datetime(customers['RegistrationDate'])
  19. # 检查重复值
  20. print("\nCustomers重复行数量:", customers.duplicated().sum())
  22. # 标准化Name列
  23. customers['Name'] = customers['Name'].str.title()
  25. # 验证Email格式
  26. import re
  27. email_pattern = r'^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$'
  28. customers['ValidEmail'] = customers['Email'].str.match(email_pattern)
  30. # 检查清洗后的数据
  31. print("\n清洗后的Customers数据:")
  32. print(customers.head())
  33. print("\nCustomers数据信息:")
  34. customers.info()
复制代码

3. 清洗Orders数据
  2. # 处理重复值
  3. print("\nOrders重复行数量:", orders.duplicated().sum())
  5. # 删除重复行
  6. orders.drop_duplicates(inplace=True)
  8. # 检查处理后的重复值
  9. print("\n处理后的Orders重复行数量:", orders.duplicated().sum())
  11. # 处理日期列
  12. orders['OrderDate'] = pd.to_datetime(orders['OrderDate'])
  14. # 检查异常值
  15. # 使用箱线图检查Price列
  16. plt.figure(figsize=(10, 6))
  17. sns.boxplot(x=orders['Price'])
  18. plt.title('Price列的箱线图')
  19. plt.show()
  21. # 使用箱线图检查Quantity列
  22. plt.figure(figsize=(10, 6))
  23. sns.boxplot(x=orders['Quantity'])
  24. plt.title('Quantity列的箱线图')
  25. plt.show()
  27. # 使用IQR方法处理Price列的异常值
  28. Q1 = orders['Price'].quantile(0.25)
  29. Q3 = orders['Price'].quantile(0.75)
  30. IQR = Q3 - Q1
  31. lower_bound = Q1 - 1.5 * IQR
  32. upper_bound = Q3 + 1.5 * IQR
  34. print(f"\nPrice列的异常值边界: {lower_bound:.2f} - {upper_bound:.2f}")
  35. price_outliers = orders[(orders['Price'] < lower_bound) | (orders['Price'] > upper_bound)]
  36. print(f"Price列的异常值数量: {len(price_outliers)}")
  38. # 用边界值替换Price列的异常值
  39. orders['Price'] = np.where(orders['Price'] < lower_bound, lower_bound,
  40.                           np.where(orders['Price'] > upper_bound, upper_bound, orders['Price']))
  42. # 使用IQR方法处理Quantity列的异常值
  43. Q1 = orders['Quantity'].quantile(0.25)
  44. Q3 = orders['Quantity'].quantile(0.75)
  45. IQR = Q3 - Q1
  46. lower_bound = Q1 - 1.5 * IQR
  47. upper_bound = Q3 + 1.5 * IQR
  49. print(f"\nQuantity列的异常值边界: {lower_bound:.2f} - {upper_bound:.2f}")
  50. quantity_outliers = orders[(orders['Quantity'] < lower_bound) | (orders['Quantity'] > upper_bound)]
  51. print(f"Quantity列的异常值数量: {len(quantity_outliers)}")
  53. # 用边界值替换Quantity列的异常值
  54. orders['Quantity'] = np.where(orders['Quantity'] < lower_bound, lower_bound,
  55.                             np.where(orders['Quantity'] > upper_bound, upper_bound, orders['Quantity']))
  57. # 创建TotalAmount列
  58. orders['TotalAmount'] = orders['Quantity'] * orders['Price']
  60. # 检查清洗后的数据
  61. print("\n清洗后的Orders数据:")
  62. print(orders.head())
  63. print("\nOrders数据信息:")
  64. orders.info()
复制代码

4. 清洗Products数据
  2. # 标准化ProductName列
  3. products['ProductName'] = products['ProductName'].str.title()
  5. # 检查重复值
  6. print("\nProducts重复行数量:", products.duplicated().sum())
  8. # 检查ProductID是否唯一
  9. print("\nProductID是否唯一:", products['ProductID'].is_unique)
  11. # 检查Category列的唯一值
  12. print("\nCategory列的唯一值:")
  13. print(products['Category'].value_counts())
  15. # 标准化Category列
  16. products['Category'] = products['Category'].str.title()
  18. # 检查清洗后的数据
  19. print("\n清洗后的Products数据:")
  20. print(products.head())
  21. print("\nProducts数据信息:")
  22. products.info())
复制代码

5. 合并数据集
  2. # 合并orders和customers
  3. order_customer = pd.merge(orders, customers, on='CustomerID', how='left')
  5. # 合并order_customer和products
  6. full_data = pd.merge(order_customer, products, on='ProductID', how='left')
  8. # 检查合并后的数据
  9. print("\n合并后的数据维度:", full_data.shape)
  10. print("\n合并后的数据前5行:")
  11. print(full_data.head())
  12. print("\n合并后的数据信息:")
  13. full_data.info())
  15. # 检查合并后的缺失值
  16. print("\n合并后的缺失值统计:")
  17. print(full_data.isnull().sum())
复制代码

6. 特征工程和数据分析
  2. # 从OrderDate提取特征
  3. full_data['OrderYear'] = full_data['OrderDate'].dt.year
  4. full_data['OrderMonth'] = full_data['OrderDate'].dt.month
  5. full_data['OrderDay'] = full_data['OrderDate'].dt.day
  6. full_data['OrderDayOfWeek'] = full_data['OrderDate'].dt.dayofweek
  7. full_data['OrderHour'] = full_data['OrderDate'].dt.hour
  9. # 从RegistrationDate提取特征
  10. full_data['RegistrationYear'] = full_data['RegistrationDate'].dt.year
  11. full_data['RegistrationMonth'] = full_data['RegistrationDate'].dt.month
  13. # 计算客户年龄（基于注册日期）
  14. full_data['AgeAtRegistration'] = full_data['RegistrationYear'] - full_data['Age']
  16. # 创建Age分箱
  17. full_data['AgeGroup'] = pd.cut(full_data['Age'], bins=[0, 25, 35, 50, 100], labels=['18-25', '26-35', '36-50', '50+'])
  19. # 创建Price分箱
  20. full_data['PriceRange'] = pd.cut(full_data['Price'], bins=[0, 50, 100, 200, 500], labels=['0-50', '51-100', '101-200', '201-500'])
  22. # 检查特征工程后的数据
  23. print("\n特征工程后的数据:")
  24. print(full_data.head())
  26. # 分析不同性别的购买行为
  27. gender_analysis = full_data.groupby('Gender').agg({
  28.     'TotalAmount': ['mean', 'sum', 'count'],
  29.     'Quantity': 'mean'
  30. })
  31. print("\n不同性别的购买行为分析:")
  32. print(gender_analysis)
  34. # 分析不同年龄组的购买行为
  35. age_analysis = full_data.groupby('AgeGroup').agg({
  36.     'TotalAmount': ['mean', 'sum', 'count'],
  37.     'Quantity': 'mean'
  38. })
  39. print("\n不同年龄组的购买行为分析:")
  40. print(age_analysis)
  42. # 分析不同产品类别的销售情况
  43. category_analysis = full_data.groupby('Category').agg({
  44.     'TotalAmount': ['mean', 'sum', 'count'],
  45.     'Quantity': 'mean'
  46. })
  47. print("\n不同产品类别的销售情况分析:")
  48. print(category_analysis)
  50. # 分析不同时间段的销售情况
  51. month_analysis = full_data.groupby('OrderMonth').agg({
  52.     'TotalAmount': ['mean', 'sum', 'count'],
  53.     'Quantity': 'mean'
  54. })
  55. print("\n不同月份的销售情况分析:")
  56. print(month_analysis)
  58. # 可视化分析
  59. # 不同性别的总销售额
  60. plt.figure(figsize=(10, 6))
  61. sns.barplot(x=full_data['Gender'], y=full_data['TotalAmount'], estimator=sum)
  62. plt.title('不同性别的总销售额')
  63. plt.show()
  65. # 不同年龄组的总销售额
  66. plt.figure(figsize=(10, 6))
  67. sns.barplot(x=full_data['AgeGroup'], y=full_data['TotalAmount'], estimator=sum)
  68. plt.title('不同年龄组的总销售额')
  69. plt.show()
  71. # 不同产品类别的总销售额
  72. plt.figure(figsize=(10, 6))
  73. sns.barplot(x=full_data['Category'], y=full_data['TotalAmount'], estimator=sum)
  74. plt.title('不同产品类别的总销售额')
  75. plt.show()
  77. # 不同月份的总销售额
  78. plt.figure(figsize=(10, 6))
  79. sns.barplot(x=full_data['OrderMonth'], y=full_data['TotalAmount'], estimator=sum)
  80. plt.title('不同月份的总销售额')
  81. plt.show()
复制代码

总结与最佳实践

通过本教程，我们系统地学习了使用pandas进行数据清洗的各种技能，从处理缺失值、重复值，到数据类型转换、异常值处理，再到字符串处理和数据转换。最后，我们通过一个完整的实战案例，将这些技能应用到实际的数据清洗和分析过程中。

数据清洗的最佳实践

1. 了解你的数据：在开始清洗之前，先通过描述性统计和可视化方法深入了解数据的特征和问题。
2. 制定清洗策略：根据数据的特点和分析目标，制定合适的数据清洗策略。不是所有的缺失值都需要填充，不是所有的异常值都需要处理。
3. 记录清洗过程：记录每一步清洗操作，以便于回溯和复现。可以考虑使用函数或类来封装清洗逻辑。
4. 保持原始数据：在清洗数据时，最好保留原始数据的副本，以便在需要时进行比较或回滚。
5. 验证清洗结果：每完成一步清洗操作，都要验证结果是否符合预期。
6. 自动化清洗流程：对于需要定期处理的数据，考虑将清洗流程自动化，提高工作效率。

了解你的数据：在开始清洗之前，先通过描述性统计和可视化方法深入了解数据的特征和问题。

制定清洗策略：根据数据的特点和分析目标，制定合适的数据清洗策略。不是所有的缺失值都需要填充，不是所有的异常值都需要处理。

记录清洗过程：记录每一步清洗操作，以便于回溯和复现。可以考虑使用函数或类来封装清洗逻辑。

保持原始数据：在清洗数据时，最好保留原始数据的副本，以便在需要时进行比较或回滚。

验证清洗结果：每完成一步清洗操作，都要验证结果是否符合预期。

自动化清洗流程：对于需要定期处理的数据，考虑将清洗流程自动化，提高工作效率。

提高数据清洗效率的技巧

1. 使用向量化操作：pandas的向量化操作比循环更高效，尽量使用内置的向量化函数。
2. 使用apply函数：对于复杂的列操作，可以使用apply函数，它比循环更高效。
3. 使用链式操作：pandas支持方法链，可以将多个操作链接在一起，使代码更简洁高效。
4. 使用适当的数据结构：根据数据的特点选择合适的数据结构，例如对于分类数据使用category类型可以节省内存。
5. 并行处理：对于大型数据集，可以考虑使用并行处理技术，如Dask或Modin。

使用向量化操作：pandas的向量化操作比循环更高效，尽量使用内置的向量化函数。

使用apply函数：对于复杂的列操作，可以使用apply函数，它比循环更高效。

使用链式操作：pandas支持方法链，可以将多个操作链接在一起，使代码更简洁高效。

使用适当的数据结构：根据数据的特点选择合适的数据结构，例如对于分类数据使用category类型可以节省内存。

并行处理：对于大型数据集，可以考虑使用并行处理技术，如Dask或Modin。

持续学习

数据清洗是一个不断学习和实践的过程。随着数据处理需求的不断变化，新的工具和技术也在不断涌现。保持学习的态度，关注最新的数据处理技术和最佳实践，将帮助你更高效地应对各种数据清洗挑战。

希望本教程能帮助你掌握pandas数据清洗的基本技能，为你的数据分析工作打下坚实的基础。记住，数据清洗是数据分析过程中不可或缺的一步，掌握好这项技能，将大大提高你的工作效率和分析结果的可靠性。
清洗
「七転び八起き（ななころびやおき）」
回复

使用道具 举报

返回列表 发新帖
您需要登录后才可以回帖 登录 | 立即注册
高级模式
B Color Image Link Quote Code Smilies

本版积分规则

友情链接

keba
磕巴白菜
别管 别听 就是玩
二次元论坛
二次元论坛
按下F逃离世界！
友链交换
友链交换
友链为随机排序，不代表本论坛观点
加入Discord频道

加入Discord频道

加入QQ社群

加入QQ社群

联系我们|小黑屋|TG频道|RSS |网站地图

Powered by Pixtech

© 2025-2026 Pixtech Team.