文集文档索引

本文集文档发布于灏天文库

常用的数据处理函数代码示例集合

  • 文集信息
  • 目录大纲
  • 最新文档
  • 知识宇宙

文集详情

文集导读

常用的数据处理函数代码示例集合 常用的数据处理函数代码示例集合 数据处理是数据分析、机器学习等领域的基础。掌握常用的数据处理函数，能够极大地提高工作效率和代码质量。本章节将介绍一些常用的数据处理函数，并提供代码示例，涵盖数据清洗、转换、聚合等方面。 数据清洗 数据清洗是指处理缺失值、异常值、重复值等问题，使数据更加干净、可靠。 1.1 缺失值处理 缺失值是数据中常见的现象，常见的处理方法包括删除、填充等。 1.1.1 删除缺失值 适用于缺失值比例较小的情况。 1.1.2 填充缺失值 适用于缺失值比例较大，删除会损失过多信息的情况。常用的填充方法包括均值、中位数、众数、固定值等。 1.2 异常值处理 异常值是指明显偏离正常范围的数据，常见的处理方法包括删除、替换、分箱等。 1.2.1 删除异常值 适用于异常值比例较小，且对整体数据影响不大的情况。通常使用箱线图或Z-score来识别异常值。 1.2.2 替换异常值 将异常值替换为合理的值，例如均值、中位数、边界值等。 1.2.3 分箱处理 将连续变量划分为离散的区间，降低异常值的影响。 1.3 重复值处理 重复值是指完全相同的两条或多条记录，需要进行删除。 数据转换 数据转换是指将数据从一种形式转换为另一种形式，包括数据类型转换、字符串处理、日期时间处理等。 2.1 数据类型转换 将数据的类型从一种类型转换为另一种类型。 2.

常用的数据处理函数代码示例集合

常用的数据处理函数代码示例集合

数据处理是数据分析、机器学习等领域的基础。掌握常用的数据处理函数，能够极大地提高工作效率和代码质量。本章节将介绍一些常用的数据处理函数，并提供代码示例，涵盖数据清洗、转换、聚合等方面。

1. 数据清洗

数据清洗是指处理缺失值、异常值、重复值等问题，使数据更加干净、可靠。

1.1 缺失值处理

缺失值是数据中常见的现象，常见的处理方法包括删除、填充等。

1.1.1 删除缺失值

适用于缺失值比例较小的情况。

import pandas as pd
import numpy as np
# 创建包含缺失值的 DataFrame
data = {'col1': [1, 2, np.nan, 4],
        'col2': [5, np.nan, 7, 8],
        'col3': [9, 10, 11, 12]}
df = pd.DataFrame(data)
# 删除包含缺失值的行
df_dropna = df.dropna()
print("删除缺失值后的 DataFrame:\n", df_dropna)
# 删除所有值都为 NaN 的列
df_dropna_col = df.dropna(axis=1, how='all')
print("删除所有值都为 NaN 的列后的 DataFrame:\n", df_dropna_col)
​

1.1.2 填充缺失值

适用于缺失值比例较大，删除会损失过多信息的情况。常用的填充方法包括均值、中位数、众数、固定值等。

# 使用均值填充缺失值
df_fillna_mean = df.fillna(df.mean())
print("使用均值填充缺失值后的 DataFrame:\n", df_fillna_mean)
# 使用中位数填充缺失值
df_fillna_median = df.fillna(df.median())
print("使用中位数填充缺失值后的 DataFrame:\n", df_fillna_median)
# 使用固定值填充缺失值
df_fillna_value = df.fillna(0)
print("使用固定值填充缺失值后的 DataFrame:\n", df_fillna_value)
# 使用前一个非缺失值填充
df_fillna_ffill = df.fillna(method='ffill')
print("使用前一个非缺失值填充后的 DataFrame:\n", df_fillna_ffill)
# 使用后一个非缺失值填充
df_fillna_bfill = df.fillna(method='bfill')
print("使用后一个非缺失值填充后的 DataFrame:\n", df_fillna_bfill)
# 使用线性插值填充
df_interpolate = df.interpolate()
print("使用线性插值填充后的 DataFrame:\n", df_interpolate)
​

1.2 异常值处理

异常值是指明显偏离正常范围的数据，常见的处理方法包括删除、替换、分箱等。

1.2.1 删除异常值

适用于异常值比例较小，且对整体数据影响不大的情况。通常使用箱线图或Z-score来识别异常值。

# 使用箱线图识别异常值
Q1 = df['col1'].quantile(0.25)
Q3 = df['col1'].quantile(0.75)
IQR = Q3 - Q1
lower_bound = Q1 - 1.5 * IQR
upper_bound = Q3 + 1.5 * IQR
# 删除超出范围的异常值
df_no_outliers = df[(df['col1'] >= lower_bound) & (df['col1'] <= upper_bound)]
print("删除异常值后的 DataFrame:\n", df_no_outliers)
# 使用 Z-score
from scipy import stats
df_zscore = df[(np.abs(stats.zscore(df['col1'])) < 3)]
print("使用 Z-score 删除异常值后的 DataFrame:\n", df_zscore)
​

1.2.2 替换异常值

将异常值替换为合理的值，例如均值、中位数、边界值等。

# 将异常值替换为边界值
df['col1'] = np.where(df['col1'] < lower_bound, lower_bound, df['col1'])
df['col1'] = np.where(df['col1'] > upper_bound, upper_bound, df['col1'])
print("替换异常值后的 DataFrame:\n", df)
​

1.2.3 分箱处理

将连续变量划分为离散的区间，降低异常值的影响。

# 使用 pandas cut 函数进行分箱
bins = [0, 2, 4, 6, 8, 10]
labels = ['0-2', '2-4', '4-6', '6-8', '8-10']
df['col1_binned'] = pd.cut(df['col1'], bins=bins, labels=labels, right=False)
print("分箱处理后的 DataFrame:\n", df)
# 使用 pandas qcut 函数进行等频分箱
df['col1_qcut'] = pd.qcut(df['col1'], q=4, labels=['Q1', 'Q2', 'Q3', 'Q4'])
print("等频分箱处理后的 DataFrame:\n", df)
​

1.3 重复值处理

重复值是指完全相同的两条或多条记录，需要进行删除。

# 创建包含重复值的 DataFrame
data = {'col1': [1, 2, 2, 3],
        'col2': [4, 5, 5, 6]}
df = pd.DataFrame(data)
# 删除重复行
df_drop_duplicates = df.drop_duplicates()
print("删除重复行后的 DataFrame:\n", df_drop_duplicates)
# 基于指定列删除重复行
df_drop_duplicates_subset = df.drop_duplicates(subset=['col1'])
print("基于指定列删除重复行后的 DataFrame:\n", df_drop_duplicates_subset)
​

2. 数据转换

数据转换是指将数据从一种形式转换为另一种形式，包括数据类型转换、字符串处理、日期时间处理等。

2.1 数据类型转换

将数据的类型从一种类型转换为另一种类型。

# 将列的数据类型转换为 int
df['col1'] = df['col1'].astype(int)
print("转换为 int 类型后的 DataFrame:\n", df)
# 将列的数据类型转换为 float
df['col1'] = df['col1'].astype(float)
print("转换为 float 类型后的 DataFrame:\n", df)
# 将列的数据类型转换为 string
df['col1'] = df['col1'].astype(str)
print("转换为 string 类型后的 DataFrame:\n", df)
# 将列的数据类型转换为 datetime
df['date_col'] = pd.to_datetime(df['date_col'])
print("转换为 datetime 类型后的 DataFrame:\n", df)
​

2.2 字符串处理

对字符串类型的数据进行处理，例如提取子字符串、替换字符串、分割字符串等。

# 创建包含字符串的 DataFrame
data = {'name': ['Alice', 'Bob', 'Charlie'],
        'email': ['alice@example.com', 'bob@example.com', 'charlie@example.com']}
df = pd.DataFrame(data)
# 提取邮箱用户名
df['username'] = df['email'].str.split('@').str[0]
print("提取邮箱用户名后的 DataFrame:\n", df)
# 替换字符串
df['email'] = df['email'].str.replace('example.com', 'newexample.com')
print("替换字符串后的 DataFrame:\n", df)
# 判断字符串是否包含特定字符
df['has_alice'] = df['name'].str.contains('Alice')
print("判断字符串是否包含特定字符后的 DataFrame:\n", df)
# 字符串长度
df['name_length'] = df['name'].str.len()
print("字符串长度后的 DataFrame:\n", df)
# 大小写转换
df['name_upper'] = df['name'].str.upper()
df['name_lower'] = df['name'].str.lower()
print("大小写转换后的 DataFrame:\n", df)
​

2.3 日期时间处理

对日期时间类型的数据进行处理，例如提取年份、月份、日期、计算时间差等。

# 创建包含日期时间的 DataFrame
data = {'date': ['2023-01-01', '2023-01-02', '2023-01-03']}
df = pd.DataFrame(data)
df['date'] = pd.to_datetime(df['date'])
# 提取年份
df['year'] = df['date'].dt.year
print("提取年份后的 DataFrame:\n", df)
# 提取月份
df['month'] = df['date'].dt.month
print("提取月份后的 DataFrame:\n", df)
# 提取日期
df['day'] = df['date'].dt.day
print("提取日期后的 DataFrame:\n", df)
# 提取星期几
df['weekday'] = df['date'].dt.weekday
print("提取星期几后的 DataFrame:\n", df)
# 计算时间差
df['date_diff'] = df['date'].diff()
print("计算时间差后的 DataFrame:\n", df)
# 时间格式化
df['formatted_date'] = df['date'].dt.strftime('%Y/%m/%d')
print("时间格式化后的 DataFrame:\n", df)
​

2.4 数值处理

对数值类型的数据进行处理，例如缩放、标准化、归一化等。

from sklearn.preprocessing import StandardScaler, MinMaxScaler
# 创建包含数值的 DataFrame
data = {'col1': [1, 2, 3, 4, 5]}
df = pd.DataFrame(data)
# 标准化
scaler = StandardScaler()
df['col1_scaled'] = scaler.fit_transform(df[['col1']])
print("标准化后的 DataFrame:\n", df)
# 归一化
minmax_scaler = MinMaxScaler()
df['col1_minmax'] = minmax_scaler.fit_transform(df[['col1']])
print("归一化后的 DataFrame:\n", df)
​

3. 数据聚合

数据聚合是指将数据按照一定的规则进行分组，并对每个组进行统计计算，例如求和、均值、计数等。

3.1 分组聚合

使用 groupby 函数进行分组，并使用聚合函数进行计算。

# 创建 DataFrame
data = {'category': ['A', 'A', 'B', 'B', 'C', 'C'],
        'value': [1, 2, 3, 4, 5, 6]}
df = pd.DataFrame(data)
# 按照 category 分组，并计算 value 的均值
df_grouped_mean = df.groupby('category')['value'].mean()
print("分组后的均值:\n", df_grouped_mean)
# 按照 category 分组，并计算 value 的总和
df_grouped_sum = df.groupby('category')['value'].sum()
print("分组后的总和:\n", df_grouped_sum)
# 按照 category 分组，并计算 value 的计数
df_grouped_count = df.groupby('category')['value'].count()
print("分组后的计数:\n", df_grouped_count)
# 按照 category 分组，并计算 value 的最大值和最小值
df_grouped_agg = df.groupby('category')['value'].agg(['min', 'max'])
print("分组后的最大值和最小值:\n", df_grouped_agg)
# 多重分组
data2 = {'category1': ['A', 'A', 'B', 'B', 'C', 'C'],
        'category2': ['X', 'Y', 'X', 'Y', 'X', 'Y'],
        'value': [1, 2, 3, 4, 5, 6]}
df2 = pd.DataFrame(data2)
df_multi_grouped = df2.groupby(['category1', 'category2'])['value'].sum()
print("多重分组后的总和:\n", df_multi_grouped)
​

3.2 透视表

使用 pivot_table 函数创建透视表，对数据进行多维度的聚合。

# 创建 DataFrame
data = {'category': ['A', 'A', 'B', 'B', 'C', 'C'],
        'value': [1, 2, 3, 4, 5, 6],
        'year': [2021, 2022, 2021, 2022, 2021, 2022]}
df = pd.DataFrame(data)
# 创建透视表
pivot_table = pd.pivot_table(df, values='value', index='category', columns='year', aggfunc='sum')
print("透视表:\n", pivot_table)
​

3.3 交叉表

使用 crosstab 函数创建交叉表，统计不同类别之间的频数。

# 创建 DataFrame
data = {'gender': ['Male', 'Female', 'Male', 'Female', 'Male', 'Female'],
        'smoker': ['Yes', 'No', 'No', 'Yes', 'Yes', 'No']}
df = pd.DataFrame(data)
# 创建交叉表
cross_table = pd.crosstab(df['gender'], df['smoker'])
print("交叉表:\n", cross_table)
​

4. 数据连接

数据连接是指将两个或多个 DataFrame 按照一定的规则进行合并。

4.1 合并

使用 concat 函数将多个 DataFrame 按照行或列进行合并。

# 创建两个 DataFrame
df1 = pd.DataFrame({'col1': [1, 2], 'col2': [3, 4]})
df2 = pd.DataFrame({'col1': [5, 6], 'col2': [7, 8]})
# 按照行合并
df_concat_row = pd.concat([df1, df2], axis=0)
print("按照行合并后的 DataFrame:\n", df_concat_row)
# 按照列合并
df_concat_col = pd.concat([df1, df2], axis=1)
print("按照列合并后的 DataFrame:\n", df_concat_col)
​

4.2 连接

使用 merge 函数将两个 DataFrame 按照指定的列进行连接。

# 创建两个 DataFrame
df1 = pd.DataFrame({'id': [1, 2, 3], 'name': ['Alice', 'Bob', 'Charlie']})
df2 = pd.DataFrame({'id': [1, 2, 4], 'age': [25, 30, 35]})
# 内连接
df_inner_join = pd.merge(df1, df2, on='id', how='inner')
print("内连接后的 DataFrame:\n", df_inner_join)
# 左连接
df_left_join = pd.merge(df1, df2, on='id', how='left')
print("左连接后的 DataFrame:\n", df_left_join)
# 右连接
df_right_join = pd.merge(df1, df2, on='id', how='right')
print("右连接后的 DataFrame:\n", df_right_join)
# 外连接
df_outer_join = pd.merge(df1, df2, on='id', how='outer')
print("外连接后的 DataFrame:\n", df_outer_join)
​

5. 数据重塑

数据重塑是指改变数据的结构，例如长宽表转换、堆叠、拆堆叠等。

5.1 长宽表转换

将长表转换为宽表，或将宽表转换为长表。

# 创建长表
data = {'date': ['2023-01-01', '2023-01-01', '2023-01-02', '2023-01-02'],
        'item': ['A', 'B', 'A', 'B'],
        'value': [1, 2, 3, 4]}
df = pd.DataFrame(data)
# 将长表转换为宽表
df_pivot = df.pivot(index='date', columns='item', values='value')
print("长表转换为宽表后的 DataFrame:\n", df_pivot)
# 创建宽表
data_wide = {'date': ['2023-01-01', '2023-01-02'],
             'A': [1, 3],
             'B': [2, 4]}
df_wide = pd.DataFrame(data_wide)
# 将宽表转换为长表
df_melt = pd.melt(df_wide, id_vars='date', value_vars=['A', 'B'], var_name='item', value_name='value')
print("宽表转换为长表后的 DataFrame:\n", df_melt)
​

5.2 堆叠与拆堆叠

使用 stack 和 unstack 函数进行堆叠和拆堆叠操作。

# 创建 DataFrame
data = {'col1': [1, 2],
        'col2': [3, 4]}
df = pd.DataFrame(data, index=['A', 'B'])
# 堆叠
df_stacked = df.stack()
print("堆叠后的 Series:\n", df_stacked)
# 拆堆叠
df_unstacked = df_stacked.unstack()
print("拆堆叠后的 DataFrame:\n", df_unstacked)
​

6. 流程图示例

以下是一个简单的数据清洗流程图示例：

总结

本章节介绍了常用的数据处理函数，包括数据清洗、转换、聚合、连接和重塑等方面。掌握这些函数，能够有效地处理各种数据问题，为后续的数据分析和建模奠定基础。在实际应用中，需要根据具体的数据情况选择合适的处理方法，并灵活运用这些函数。

目录大纲

    最新文档

    知识宇宙

    正在加载知识图谱...

    转发

    相关文集

    软件无线电 (SDR) 计算神经科学 细胞治疗技术 硅光子技术 电子设计自动化（EDA）技术与算法 生物力学