Python案例如何用Pandas做数据归一化

本文目录导读：

1. 准备示例数据
2. Min-Max归一化（0-1区间）
3. Z-Score标准化（均值为0，标准差为1）
4. 使用sklearn进行归一化
5. 自定义归一化函数
6. 实用案例：混合数据处理
7. 批量处理并保存结果
8. 选择建议

我来详细介绍Pandas进行数据归一化的几种常用方法。

准备示例数据

import pandas as pd
import numpy as np
# 创建示例数据
data = {
    '年龄': [25, 30, 35, 40, 45, 50],
    '收入': [50000, 60000, 75000, 80000, 120000, 150000],
    '消费分数': [60, 70, 80, 90, 95, 85]
}
df = pd.DataFrame(data)
print("原始数据：")
print(df)

Min-Max归一化（0-1区间）

def min_max_normalize(df, columns=None):
    """
    Min-Max归一化：将数据缩放到[0,1]区间
    公式: X_norm = (X - X_min) / (X_max - X_min)
    """
    if columns is None:
        columns = df.columns
    df_normalized = df.copy()
    for col in columns:
        min_val = df[col].min()
        max_val = df[col].max()
        df_normalized[col] = (df[col] - min_val) / (max_val - min_val)
    return df_normalized
# 应用Min-Max归一化
df_minmax = min_max_normalize(df, ['年龄', '收入', '消费分数'])
print("\nMin-Max归一化结果：")
print(df_minmax.round(3))

Z-Score标准化（均值为0，标准差为1）

def z_score_normalize(df, columns=None):
    """
    Z-Score标准化：使数据服从标准正态分布
    公式: X_std = (X - μ) / σ
    """
    if columns is None:
        columns = df.columns
    df_normalized = df.copy()
    for col in columns:
        mean_val = df[col].mean()
        std_val = df[col].std()
        df_normalized[col] = (df[col] - mean_val) / std_val
    return df_normalized
# 应用Z-Score标准化
df_zscore = z_score_normalize(df, ['年龄', '收入', '消费分数'])
print("\nZ-Score标准化结果：")
print(df_zscore.round(3))

使用sklearn进行归一化

from sklearn.preprocessing import MinMaxScaler, StandardScaler, RobustScaler
# 方法1：Min-Max归一化
scaler_minmax = MinMaxScaler()
df_sklearn_minmax = pd.DataFrame(
    scaler_minmax.fit_transform(df[['年龄', '收入', '消费分数']]),
    columns=['年龄_minmax', '收入_minmax', '消费分数_minmax']
)
print("\nSklearn Min-Max归一化：")
print(df_sklearn_minmax.round(3))
# 方法2：Z-Score标准化
scaler_standard = StandardScaler()
df_sklearn_standard = pd.DataFrame(
    scaler_standard.fit_transform(df[['年龄', '收入', '消费分数']]),
    columns=['年龄_std', '收入_std', '消费分数_std']
)
print("\nSklearn Z-Score标准化：")
print(df_sklearn_standard.round(3))
# 方法3：Robust缩放（对异常值鲁棒）
scaler_robust = RobustScaler()
df_sklearn_robust = pd.DataFrame(
    scaler_robust.fit_transform(df[['年龄', '收入', '消费分数']]),
    columns=['年龄_robust', '收入_robust', '消费分数_robust']
)
print("\nRobust缩放（基于中位数和IQR）：")
print(df_sklearn_robust.round(3))

自定义归一化函数

def custom_normalize(df, method='minmax', columns=None):
    """
    自定义归一化函数，支持多种方法
    """
    if columns is None:
        columns = df.columns
    df_normalized = df.copy()
    for col in columns:
        if method == 'minmax':
            # Min-Max归一化
            min_val = df[col].min()
            max_val = df[col].max()
            df_normalized[col] = (df[col] - min_val) / (max_val - min_val)
        elif method == 'zscore':
            # Z-Score标准化
            mean_val = df[col].mean()
            std_val = df[col].std()
            df_normalized[col] = (df[col] - mean_val) / std_val
        elif method == 'maxabs':
            # 最大绝对值归一化
            max_abs = df[col].abs().max()
            df_normalized[col] = df[col] / max_abs
        elif method == 'median':
            # 中位数归一化
            median_val = df[col].median()
            iqr_val = df[col].quantile(0.75) - df[col].quantile(0.25)
            df_normalized[col] = (df[col] - median_val) / iqr_val
    return df_normalized
# 使用自定义函数
df_custom = custom_normalize(df, method='minmax', columns=['年龄', '收入'])
print("\n自定义归一化结果：")
print(df_custom.round(3))

实用案例：混合数据处理

def normalize_mixed_data(df, numeric_columns, method='zscore'):
    """
    处理混合类型数据的归一化
    """
    df_normalized = df.copy()
    # 仅对数值列进行归一化
    for col in numeric_columns:
        if method == 'zscore':
            mean_val = df[col].mean()
            std_val = df[col].std()
            df_normalized[f'{col}_normalized'] = (df[col] - mean_val) / std_val
        elif method == 'minmax':
            min_val = df[col].min()
            max_val = df[col].max()
            df_normalized[f'{col}_normalized'] = (df[col] - min_val) / (max_val - min_val)
    return df_normalized
# 创建包含混合类型的数据
mixed_data = {
    '姓名': ['张三', '李四', '王五', '赵六'],
    '年龄': [25, 30, 35, 40],
    '收入': [50000, 60000, 75000, 80000],
    '性别': ['男', '女', '男', '女'],
    '消费分数': [60, 70, 80, 90]
}
df_mixed = pd.DataFrame(mixed_data)
# 对数值列进行归一化
df_mixed_normalized = normalize_mixed_data(df_mixed, ['年龄', '收入', '消费分数'], method='zscore')
print("\n混合数据归一化结果：")
print(df_mixed_normalized.round(3))

批量处理并保存结果

def batch_normalize_and_save(df, normalize_methods=['minmax', 'zscore', 'robust']):
    """
    批量应用不同的归一化方法并保存结果
    """
    results = {}
    for method in normalize_methods:
        if method == 'minmax':
            normalized_df = custom_normalize(df, method='minmax')
        elif method == 'zscore':
            normalized_df = custom_normalize(df, method='zscore')
        elif method == 'robust':
            normalized_df = custom_normalize(df, method='median')
        results[method] = normalized_df
    return results
# 批量处理
all_normalizations = batch_normalize_and_save(df[['年龄', '收入', '消费分数']])
# 显示每种方法的结果
for method, normalized_df in all_normalizations.items():
    print(f"\n{method.upper()} 归一化：")
    print(normalized_df.round(3))

选择建议

1. Min-Max归一化：适用于有明确边界的场景，如像素值[0,255]
2. Z-Score标准化：适用于数据近似正态分布，需处理异常值
3. Robust缩放：数据包含异常值时更稳定
4. MaxAbs归一化：稀疏数据或已有正负值的数据

这些方法可以根据具体需求灵活选择和应用！