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

wen python案例 2026-07-15 182

本文目录导读：

最大最小值归一化 (Min-Max Normalization)
使用sklearn的MinMaxScaler
实际应用案例
处理异常值的归一化
批量处理多个DataFrame
保存和恢复归一化参数
关键要点：

我来介绍几种用Pandas进行数据归一化到特定区间的方法：

最大最小值归一化 (Min-Max Normalization)

将数据缩放到[0,1]区间或自定义区间：

import pandas as pd
import numpy as np
# 创建示例数据
data = {
    'A': [10, 20, 30, 40, 50],
    'B': [100, 200, 300, 400, 500],
    'C': [1, 2, 3, 4, 5]
}
df = pd.DataFrame(data)
print("原始数据：")
print(df)
# 方法1：手动实现归一化到[0,1]
def minmax_normalize(series):
    return (series - series.min()) / (series.max() - series.min())
df_normalized = df.apply(minmax_normalize)
print("\n归一化到[0,1]：")
print(df_normalized)
# 方法2：使用lambda表达式
df_normalized_lambda = df.apply(lambda x: (x - x.min()) / (x.max() - x.min()))
print("\n使用lambda表达式：")
print(df_normalized_lambda)
# 方法3：归一化到指定区间[a,b]
def normalize_to_range(series, a=0, b=1):
    min_val = series.min()
    max_val = series.max()
    return a + (series - min_val) * (b - a) / (max_val - min_val)
# 归一化到[0, 100]
df_to_100 = df.apply(lambda x: normalize_to_range(x, 0, 100))
print("\n归一化到[0,100]：")
print(df_to_100)

使用sklearn的MinMaxScaler

from sklearn.preprocessing import MinMaxScaler
# 方法4：使用sklearn
scaler = MinMaxScaler(feature_range=(0, 1))  # 可以设置自定义区间
df_scaled = pd.DataFrame(
    scaler.fit_transform(df),
    columns=df.columns,
    index=df.index
)
print("\n使用sklearn归一化到[0,1]：")
print(df_scaled)
# 归一化到[0, 100]
scaler_custom = MinMaxScaler(feature_range=(0, 100))
df_scaled_custom = pd.DataFrame(
    scaler_custom.fit_transform(df),
    columns=df.columns,
    index=df.index
)
print("\n使用sklearn归一化到[0,100]：")
print(df_scaled_custom)

实际应用案例

# 创建更真实的数据集
data_real = {
    '年龄': [25, 30, 35, 40, 45, 50, 55, 60],
    '收入': [5000, 8000, 12000, 15000, 20000, 25000, 30000, 35000],
    '工作年限': [1, 3, 5, 8, 10, 15, 20, 25],
    '评分': [60, 65, 70, 75, 80, 85, 90, 95]
}
df_real = pd.DataFrame(data_real)
print("原始数据：")
print(df_real)
print("\n数据统计：")
print(df_real.describe())
# 归一化到[0,1]
df_norm = df_real.apply(lambda x: (x - x.min()) / (x.max() - x.min()))
print("\n归一化到[0,1]后的数据：")
print(df_norm.round(3))
# 归一化到[-1,1]
def normalize_to_neg1_1(series):
    min_val = series.min()
    max_val = series.max()
    # 映射到[-1, 1]
    return 2 * (series - min_val) / (max_val - min_val) - 1
df_neg1_1 = df_real.apply(normalize_to_neg1_1)
print("\n归一化到[-1,1]：")
print(df_neg1_1.round(3))

处理异常值的归一化

# 创建包含异常值的数据
data_with_outliers = {
    '正常列': [10, 20, 30, 40, 50],
    '异常列': [10, 20, 30, 1000, 50]  # 1000是异常值
}
df_outliers = pd.DataFrame(data_with_outliers)
print("包含异常值的数据：")
print(df_outliers)
# 使用百分位数裁剪后再归一化
def robust_normalize(series, low_percentile=5, high_percentile=95):
    """使用百分位数裁剪后再归一化"""
    low = np.percentile(series, low_percentile)
    high = np.percentile(series, high_percentile)
    # 裁剪数据
    clipped = series.clip(low, high)
    # 归一化
    return (clipped - clipped.min()) / (clipped.max() - clipped.min())
df_robust = df_outliers.apply(robust_normalize)
print("\n鲁棒归一化后的数据：")
print(df_robust.round(3))

批量处理多个DataFrame

# 创建多个数据集
dfs = {
    'df1': pd.DataFrame({'A': [10, 20, 30], 'B': [100, 200, 300]}),
    'df2': pd.DataFrame({'A': [5, 15, 25], 'B': [50, 150, 250]})
}
# 批量归一化
def batch_normalize(df_list, range_min=0, range_max=1):
    normalized_dfs = {}
    for name, df in df_list.items():
        scaler = MinMaxScaler(feature_range=(range_min, range_max))
        normalized_dfs[name] = pd.DataFrame(
            scaler.fit_transform(df),
            columns=df.columns,
            index=df.index
        )
    return normalized_dfs
normalized_results = batch_normalize(dfs, 0, 100)
for name, df_norm in normalized_results.items():
    print(f"\n{name} 归一化结果：")
    print(df_norm)

保存和恢复归一化参数

# 保存归一化参数以便后续恢复
scaler = MinMaxScaler(feature_range=(0, 1))
scaler.fit(df)
# 保存参数
normalization_params = {
    'min_': scaler.data_min_,
    'max_': scaler.data_max_,
    'feature_range': scaler.feature_range
}
print("归一化参数：")
print(f"最小值: {normalization_params['min_']}")
print(f"最大值: {normalization_params['max_']}")
print(f"范围: {normalization_params['feature_range']}")
# 对新数据使用相同的参数进行归一化
new_data = pd.DataFrame({'A': [35], 'B': [250], 'C': [3.5]})
new_data_scaled = pd.DataFrame(
    scaler.transform(new_data),
    columns=new_data.columns
)
print("\n新数据归一化结果：")
print(new_data_scaled)